POJ 1655 Balancing Act （树状dp入门）

Description

Consider a tree T with N (1 <= N <= 20,000) nodes numbered 1...N. Deleting any node from the tree yields a forest: a collection of one or more trees. Define the balance of a node to be the size of the largest tree in the forest T created by deleting that node from T.
For example, consider the tree:

Deleting node 4 yields two trees whose member nodes are {5} and {1,2,3,6,7}. The larger of these two trees has five nodes, thus the balance of node 4 is five. Deleting node 1 yields a forest of three trees of equal size: {2,6}, {3,7}, and {4,5}. Each of these trees has two nodes, so the balance of node 1 is two.

For each input tree, calculate the node that has the minimum balance. If multiple nodes have equal balance, output the one with the lowest number.

Input

The first line of input contains a single integer t (1 <= t <= 20), the number of test cases. The first line of each test case contains an integer N (1 <= N <= 20,000), the number of congruence. The next N-1 lines each contains two space-separated node numbers that are the endpoints of an edge in the tree. No edge will be listed twice, and all edges will be listed.

Output

For each test case, print a line containing two integers, the number of the node with minimum balance and the balance of that node.

Sample Input

1
7
2 6
1 2
1 4
4 5
3 7
3 1

Sample Output

1 2

就是给你一棵树，让你在树上去掉一个节点，这样就形成了许多子树，设所有子树中点个数最多的那颗子树的点的个数为x，现在让这个x最小，问你应该剪掉哪个节点，x是多少？
根据树形结构的特殊性，从树根走到叶子节点是严格按照层次顺序的。我现在就开始做dp。首先我们先定义一个dp数组。
我们还需要一个num[x]数组，用来表示以x为树根的子树上有多少节点。
对于每一个节点，去掉它所得到的x的值是什么呢？1.它所有子节点为根的子树的最大值 2.除了x和它下面所有的子树，剩下全部的节点。这两者比较最大值就可以了。

刚刚看了白书，就是让找树的重心。
代码如下：

#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
using namespace std;
#define M 20020
int n;
struct Node
{
    int to,pre;
}edge[M*2];
int head[M],tot,dp[M],num[M];
void init ()
{
    memset(head,-1,sizeof head);
    tot=0;
}
void addedge (int u,int v)
{
    edge[tot].to=v;
    edge[tot].pre=head[u];
    head[u]=tot++;
}
void dfs (int u,int prenode)
{
    dp[u]=0;
    num[u]=1;
    for (int i=head[u];i!=-1;i=edge[i].pre)
    {
        int v=edge[i].to;
        if (v==prenode)
        continue;
        dfs(v,u);
        dp[u]=max(dp[u],num[v]);
        num[u]+=num[v];
    }
    dp[u]=max(dp[u],n-num[u]);
}
int main()
{
    int t;
    scanf("%d",&t);
    while (t--)
    {
        scanf("%d",&n);
        init();
        for (int i=1;i<n;++i)
        {
            int u,v;
            scanf("%d %d",&u,&v);
            addedge(u,v);
            addedge(v,u);
        }
        dfs(1,-1);
        int ans1=1,ans2=dp[1];
        for (int i=2;i<=n;++i)
        {
            if (ans2>dp[i])
            {
                ans1=i;
                ans2=dp[i];
            }
        }
        printf("%d %d\n",ans1,ans2);
    }
    return 0;
}