bzoj 4015: [FJOI2014]树的重心 dp

Description
给定一个n个点的树，每个点的编号从1至n，问这个树有多少不同的连通子树，和这个树有相同的重心。
其中n个点的树指的是n个点的最小连通图，显然n个点的树有n-1条边，去掉这n-1条边中的任何一条，原图都不再联通，任意两个点之间由唯一一条路径相连。
对于一个树，树的重心定义为：删掉某点i后，若剩余k个连通分量，那么定义d(i)为这些连通分量中点的个数的最大值，所谓重心，就是使得d(i)最小的点i。
基于以上定义，一个树的重心可能会有一个或者两个，题中所要求的联通子树，其重心编号和个数必须和原树的完全一样。
找出给定的树中有多少联通的子树和这个树有相同的重心。

Input
第1行中给出正整数Q，表示该组数据中有多少组测试样例。
每组样例首先输入一个整数n (0 < n ≤200)，表示该组样例中输入的树包含n个点，之后n-1行，每行输入两整数数x，y(1 ≤ x, y ≤ n)，表示编号为x的点和编号为y的点之间存在一条边，所有点的编号从1-n

Output
首先输出样例编号，之后输出满足条件的子树的个数，由于这个数字较大，你只需要输出这个数字对10007取模后的结果，即mod 10007，详见输出示例，请严格按照输出实例中的格式输出

Sample Input
3
2
1 2
3
1 2
2 3
5
1 2
1 3
2 4
2 5

Sample Output
Case 1: 1
Case 2: 2
Case 3: 6

HINT

100%的数据满足Q≤50，n≤200。

分析：
根据重心的性质，对于一个重心，设他的最大子树大小$x$，那么显然有$x\ast 2\le n$，不然就重心可以移动到这棵子树的父亲。
假如$x\ast 2=n$，那么$x$和这棵子树的父亲都是重心，否则只有$x$是重心。

如果只有一个点是重心，直接以$x$为根。设$f[i][j]$表示$i$为根的子树，选出一个包含根的，大小为$j$的连通块的方案。
对于根的转移有点不同，因为要保证他是重心。我们先枚举一个$size$表示答案的树的大小，那么他的儿子子树大小$s$必须满足$s\ast 2<size$，再考虑转移。可以使用枚举size法使合并复杂度变为$O(n^2)$，总复杂度为$O(n^3)$。

对于有两个点是重心，那么这两个点必定相邻，把他们的边断掉后分别对子树进行上述dp。答案是两个重心子树大小相等的方案。

代码：

/**************************************************************
    Problem: 4015
    User: ypxrain
    Language: C++
    Result: Accepted
    Time:2488 ms
    Memory:1464 kb
****************************************************************/
 
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
 
const int maxn=207;
const int mod=10007;
 
using namespace std;
 
int T,n,x,y,tot,root,ans;
int ls[maxn],h[maxn],size[maxn],f[maxn][maxn],tmp[maxn];
 
struct edge{
    int y,next;
}g[maxn*2];
 
void add(int x,int y)
{
    g[++tot]=(edge){y,ls[x]};
    ls[x]=tot;
}
 
void findroot(int x,int fa)
{
    size[x]=1;
    h[x]=0;
    for (int i=ls[x];i>0;i=g[i].next)
    {
        int y=g[i].y;
        if (y==fa) continue;
        findroot(y,x);
        size[x]+=size[y];
        h[x]=max(h[x],size[y]);
    }
    h[x]=max(h[x],n-size[x]);
    if ((h[x]<=h[root]) || (!root)) root=x;
}
 
void dfs(int x,int fa)
{
    size[x]=1;
    f[x][0]=f[x][1]=1;
    for (int i=ls[x];i>0;i=g[i].next)
    {
        int y=g[i].y;
        if (y==fa) continue;
        dfs(y,x);
        for (int j=1;j<=size[x]+size[y];j++) tmp[j]=0;
        for (int j=1;j<=size[x];j++)
        {
            for (int k=0;k<=size[y];k++)
            {
                tmp[j+k]=(tmp[j+k]+f[x][j]*f[y][k]%mod)%mod;
            }
        }
        size[x]+=size[y];
        for (int j=1;j<=size[x];j++) f[x][j]=tmp[j];
    }
}
 
void solve1(int x)
{
    memset(f,0,sizeof(f));
    dfs(x,0);
    for (int d=1;d<=n;d++)
    {
        size[x]=1;
        memset(f[x],0,sizeof(f[x]));
        f[x][0]=f[x][1]=1;
        for (int i=ls[x];i>0;i=g[i].next)
        {
            int y=g[i].y;
            for (int j=1;j<=size[x]+size[y];j++) tmp[j]=0;
            for (int j=1;j<=size[x];j++)
            {
                for (int k=0;k<=size[y];k++)
                {
                    if (k*2>=d) break;
                    tmp[j+k]=(tmp[j+k]+f[x][j]*f[y][k]%mod)%mod;
                }
            }
            size[x]+=size[y];
            for (int j=1;j<=size[x];j++) f[x][j]=tmp[j];
        }       
        ans=(ans+f[x][d])%mod;
    }
}
 
void solve2(int x,int y)
{
    memset(f,0,sizeof(f));
    dfs(x,y);
    dfs(y,x);
    for (int d=1;d<=n;d++) ans=(ans+f[x][d]*f[y][d]%mod)%mod;
}
 
int main()
{
    int ca=0;
    scanf("%d",&T);
    while (T--)
    {
        ca++;
        memset(ls,0,sizeof(ls));
        tot=ans=0;
        scanf("%d",&n);
        for (int i=1;i<n;i++)
        {
            scanf("%d%d",&x,&y);
            add(x,y);
            add(y,x);
        }   
         
        root=0;
        findroot(1,0);
        if (h[root]*2<n) solve1(root);
        else
        {
            for (int i=ls[root];i>0;i=g[i].next)
            {
                y=g[i].y;
                if (h[root]==size[y]) break;
            }
            solve2(root,y);
        }
        printf("Case %d: %d\n",ca,ans);
    }
}