Poj 1655(树的重心、树形DP、经典)

problem

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

思路

本题所求结点即为树的重心

树的重心：对于一颗n个结点的无根树，找到一个点，使得把树变成以该点为根的有根树时，最大的子树的结点数最小。换句话说，删除这个点后最大连通块（一定是树）的结点数最小（即本题题面）。那这个点即为树的重心。

---

求解

和树的最大独立集问题类似，先任选一个结点作为根，把无根树变成有根树，然后设d(i)表示以i为根的子树的结点个数，有$d_{i}=\sum_{j\in s(i)}d(j)+1$ 。
只需一次DFS，在无根树转有根树的同时计算即可（不需要记忆化），因为本来就没有重复计算。
删除结点i后，最大的连通块有多少结点呢？结点i的子树中最大的有max{d(j)}个结点，i的“上方子树”中有n-d(i)个结点，如下图所示。这样就可以用树形DP来解决了。

---

核心dfs

void dfs(int rt,int f)
{
    dp[rt]=0,num[rt]=1;
    for(int i=head[rt];i!=-1;i=edges[i].to){
        int tt=edges[i].from;
        if(tt==f) continue;
        dfs(tt,rt);
        dp[rt]=max(dp[rt],num[tt]);
        num[rt]+=num[tt];
    }
    dp[rt]=max(dp[rt],n-num[rt]);
}

代码示例

#include<iostream>
#include<string.h>
#include<cstdio>
using namespace std;

const int maxn=20010;
int head[maxn<<1];
int tot,n;//tot辅助存边（边集数组转邻接表）,n为结点数

struct Edge{
    int from,to;
}edges[maxn<<1];

void init()
{
    memset(head,-1,sizeof(head));
    tot=0;
}

void add_edge(int u,int v){
    edges[tot].from=v;
    edges[tot].to=head[u];
    head[u]=tot++;
}

int dp[maxn],num[maxn];

void dfs(int rt,int f)
{
    dp[rt]=0,num[rt]=1;
    for(int i=head[rt];i!=-1;i=edges[i].to){
        int tt=edges[i].from;
        if(tt==f) continue;
        dfs(tt,rt);
        dp[rt]=max(dp[rt],num[tt]);
        num[rt]+=num[tt];
    }
    dp[rt]=max(dp[rt],n-num[rt]);
}

int main()
{
    //ios::sync_with_stdio(false);
    int t;
    scanf("%d",&t);
    int u,v;
    while(t--)
    {
        scanf("%d",&n);
        init();
        for(int i=1;i<n;++i){
            scanf("%d %d",&u,&v);
            add_edge(u,v);
            add_edge(v,u);
        }
        dfs(1,-1);
        int ans1=1,ans2=dp[1];
        for(int i=2;i<=n;++i){
            if(dp[i]<ans2){
                ans1=i;
                ans2=dp[i];
            }
        }
        printf("%d %d\n",ans1,ans2);
    }
    return 0;
}

树的重心性质

树的重心有一些性质，下面是部分：

定义1：找到一个点，其所有的子树中最大的子树节点数最少，那么这个点就是这棵树的重心。

定义2：以这个点为根，那么所有的子树（不算整个树自身）的大小都不超过整个树大小的一半。

性质1：树中所有点到某个点的距离和中，到重心的距离和是最小的；如果有两个重心，那么他们的距离和一样。

性质2：把两个树通过一条边相连得到一个新的树，那么新的树的重心在连接原来两个树的重心的路径上。

性质3：把一个树添加或删除一个叶子，那么它的重心最多只移动一条边的距离。