Tree Cutting POJ - 2378（树型dp）

After Farmer John realized that Bessie had installed a "tree-shaped" network among his N (1 <= N <= 10,000) barns at an incredible cost, he sued Bessie to mitigate his losses. 

Bessie, feeling vindictive, decided to sabotage Farmer John's network by cutting power to one of the barns (thereby disrupting all the connections involving that barn). When Bessie does this, it breaks the network into smaller pieces, each of which retains full connectivity within itself. In order to be as disruptive as possible, Bessie wants to make sure that each of these pieces connects together no more than half the barns on FJ. 

Please help Bessie determine all of the barns that would be suitable to disconnect.

Input

* Line 1: A single integer, N. The barns are numbered 1..N. 

* Lines 2..N: Each line contains two integers X and Y and represents a connection between barns X and Y.

Output

* Lines 1..?: Each line contains a single integer, the number (from 1..N) of a barn whose removal splits the network into pieces each having at most half the original number of barns. Output the barns in increasing numerical order. If there are no suitable barns, the output should be a single line containing the word "NONE".

Sample Input

10
1 2
2 3
3 4
4 5
6 7
7 8
8 9
9 10
3 8

Sample Output

3
8

Hint

INPUT DETAILS: 

The set of connections in the input describes a "tree": it connects all the barns together and contains no cycles. 

OUTPUT DETAILS: 

If barn 3 or barn 8 is removed, then the remaining network will have one piece consisting of 5 barns and two pieces containing 2 barns. If any other barn is removed then at least one of the remaining pieces has size at least 6 (which is more than half of the original number of barns, 5).

 

题意：有一颗树有n个节点，消除一个节点，使得所有子树的节点数小于n/2，统计这样的节点的个数

 

思路：树型dp，dp[i]记录删除节点i后，子树最大节点数。dfs求出所有子树的节点数，然后取max更新dp即可

 

#include "iostream"
#include "algorithm"
#include "vector"
using namespace std;
const int Max=1e4+10;
vector<int> G[Max];
int n,dp[Max];
int dfs(int u,int par)
{
    int sum=1,mson=0;
    dp[u]=0;
    for(int i=0;i<G[u].size();i++){
        int v=G[u][i];
        if(v==par) continue;//par记录父亲节点，避免重复计算
        int ans=dfs(v,u);
        mson=max(ans,mson);//记录这个节点最大的子树的节点个数
        sum+=ans;//记录这个节点以即他所有子数的节点个数
    }
    dp[u]=max(mson,n-sum);//我们进行遍历，只遍历了这个节点的子树，没有向这个节点的父亲节点进行遍历
            //所以，要进行比较
    return sum;
}
int main()
{
    int u,v,flag;
    while(cin>>n){
        flag=0;
        for(int i=1;i<=n;i++) G[i].clear();
        for(int i=1;i<n;i++){
            cin>>u>>v;
            G[u].push_back(v);
            G[v].push_back(u);
        }
        dfs(1,0);
        for(int i=1;i<=n;i++){//统计符合条件的节点的个数
            if(2*dp[i]<=n){
                flag=1;
                cout<<i<<endl;
            }
        }
        if(!flag) cout<<"NONE"<<endl;
    }
    return 0;
}