【NOIP2016提高A组模拟9.4】树上摩托

这题在打的时候代码各种煞笔，所以超级丑233

题目

Description

Sherco是一位经验丰富的魔♂法师。
Sherco在第零次圣杯战争中取得了胜利,并取得了王之宝藏——王の树。
他想把这棵树砍去任意条边，拆成若干棵新树，并装饰在他的摩托上，让他的摩托更加酷炫。
但Sherco认为，这样生成的树不具有美感，于是Sherco想让每棵新树的节点数相同。
他想知道有多少种方法分割这棵树。

Input

第一行一个正整数N，表示这棵树的结点总数。
接下来N-1行，每行两个数字X，Y表示编号为X的结点与编号为Y的结点相连。结点编号的范围为[1,N]。

Output

一个整数，表示方案数。注意，不砍去任何一条边也算作一种方案。

Sample Input

6
1 2
2 3
2 4
4 5
5 6

Sample Output

3

Data Constraint

对于40%的数据，N ≤ 15
对于60%的数据，N ≤ 10^5
对于100%的数据，N ≤ 10^6
数据规模非常大，请使用高效的读入方式。

比赛时の想法

暴力

正解

首先我们可以发现几个性质：
1：设切的每一块大小都为i，那么只有当i为n的因数是有解（不解释）
2：对于同一种大小的分块，如果有解那么只有唯一解，证明如下：
i=1时只有唯一解
i不等于1时，任意取一个在树中的非叶子节点，那么我们可以把这个点当做根，其中一棵子树是这个点所连接的，那么这棵子树的节点数量一定不为i的倍数，而其他子树又都可以合法，那么其他子树的size都是i的倍数，那么如果根节点要扩展到其他的子树显然是不合法的（画一下图就很好理解）
3：对于一个有根树，一个节点可以作一个块的”根”，当且仅当该节点的 size 能被块的大小整除（显然？）
那么我们先预处理出每棵子树size的大小，再判断 size 为 k 的倍数的节点数量是否为n/k就好了

贴代码

感受恐惧吧！！！

var
    size,h,son:array[0..1000005]of longint;
    bz,bt:array[0..1000005]of boolean;
    a,b,c:array[0..2000005,1..2]of longint;
    i,j,k,l,n,tot,ans:longint;
procedure qsort(l,r:longint);
var
    i,j,mid:longint;
begin
    i:=l;
    j:=r;
    mid:=(a[(i+j) div 2,1]);
    repeat
        while a[i,1]<mid do inc(i);
        while a[j,1]>mid do dec(j);
        if i<=j then
        begin
            a[0]:=a[i];
            a[i]:=a[j];
            a[j]:=a[0];
            inc(i);
            dec(j);
        end;
    until i>j;
    if i<r then qsort(i,r);
    if l<j then qsort(l,j);
end;
procedure star;
begin
    b[a[1,1],1]:=1;
    for i:=2 to n+n-2 do
    if a[i,1]<>a[i-1,1] then
    begin
        b[a[i-1,1],2]:=i-1;
        b[a[i,1],1]:=i;
    end;
    b[a[n+n-2,1],2]:=n+n-2;
end;
procedure makeson;
var
    i,j,k:longint;
begin
    i:=1;
    j:=0;
    h[i]:=1;
    fillchar(bz,sizeof(bz),false);
    while i>j do
    begin
        inc(j);
        for k:=b[h[j],1] to b[h[j],2] do
        if bz[a[k,2]]=false then
        begin
            bz[h[j]]:=true;
            inc(i);
            h[i]:=a[k,2];
        end;
    end;
end;
procedure makesize(x:longint);
var
    i,j,k:longint;
    add,cc:array[0..1000005]of longint;
begin
    makeson;
    for i:=1 to n do size[i]:=1;
    j:=0;
    fillchar(add,sizeof(add),0);
    fillchar(h,sizeof(h),0);
    for i:=1 to n do
        if bz[i]=false then
        begin
            inc(j);
            h[j]:=i;
            add[i]:=1;
            bt[i]:=true;
        end;
    i:=j;
    j:=0;
    fillchar(bz,sizeof(bz),false);
    fillchar(cc,sizeof(cc),0);
    for k:=1 to i do bz[h[i]]:=true;
    while j<i do
    begin
        inc(j);
        for k:=b[h[j],1] to b[h[j],2] do
        if k<>0 then
        begin
          //  bz[a[k,2]]:=true;
            if bt[a[k,2]]=true then continue;
            size[a[k,2]]:=size[a[k,2]]+add[a[k,1]];
            add[a[k,2]]:=add[a[k,2]]+add[a[k,1]];
            if bz[a[k,2]]=false then
            begin
                bz[a[k,2]]:=true;
                inc(add[a[k,2]]);
            end;
            inc(cc[a[k,2]]);
            add[a[k,1]]:=0;
            if cc[a[k,2]]=son[a[k,2]]-1 then
            begin
                inc(i);
                h[i]:=a[k,2];
                bt[a[k,2]]:=true;
            end;
        end;
    end;
end;
procedure qsort1(l,r:longint);
var
    i,j,mid:longint;
begin
    i:=l;
    j:=r;
    mid:=size[(i+j) div 2];
    repeat
        while size[i]<mid do inc(i);
        while size[j]>mid do dec(j);
        if i<=j then
        begin
            size[0]:=size[i];
            size[i]:=size[j];
            size[j]:=size[0];
            inc(i);
            dec(j);
        end;
    until i>j;
    if i<r then qsort1(i,r);
    if l<j then qsort1(l,j);
end;
procedure init;
begin
    assign(input,'3.in'); reset(input);
    readln(n);
    for i:=1 to n-1 do
    begin
        readln(a[i,1],a[i,2]);
        a[n+i-1,1]:=a[i,2];
        a[n+i-1,2]:=a[i,1];
        inc(son[a[i,1]]);
        inc(son[a[i,2]]);
    end;
    qsort(1,n+n-2);
    star;
end;
begin
    init;
    inc(son[1]);
    makesize(1);
    qsort1(1,n);
    c[size[1],1]:=1;
    for i:=2 to n do
    if size[i]<>size[i-1] then
    begin
        c[size[i-1],2]:=i-1;
        c[size[i],1]:=i;
    end;
    c[size[n],2]:=n;
    for i:=1 to n do
    if n mod i=0 then
    begin
        tot:=0;
        j:=i;
        while j<=n do
        begin
            if c[j,1]<>0 then tot:=tot+c[j,2]-c[j,1]+1;
            j:=j+i;
        end;
        if i*tot=n then inc(ans);
    end;
    writeln(ans);
    close(input);
end.