Codeforces Round #397 E. Tree Folding

题目链接：http://codeforces.com/contest/765/problem/E

题意大致就是：一棵树上，如果有一个节点，他的子节点有两条链，且两条链长度相等·，那么可以把这两条链合并为一条链。重复合并之后可以继续合并，问能否把这棵树合并为一条链，如果能输出能够合并成的最短的链的边数。

如果能够把这棵树合并成一条链，那么答案就很简单了，把链的边数除以2直到为奇数就行。那么问题就是怎么找到这个根。n的2e5不能暴力枚举根。

怎么找这个根这个地方我一开始想到要么就是树的直径的中点（不会证明，画一画看出来的），要么就是某个由这个中点延伸出去的链的叶子节点。对于某个节点，他的子节点的深度只要是一样的，那么他们就可以合并在一起，否则就不能合并。但是很鬼畜的我忽略了一种情况，就是根的子节点其实可以有两种深度。

比如根连着两个深度为n的点，连着两个深度为m的点，这种情况也是可以把两个n合并之后，再把m合并，然后得到一条链的。（这个地方真的坑，我以为根只能向下合并， 真的是阅读理解幼儿园水平。）

对于根而言可以有两种深度的子节点，但是其他子节点应该都相等，然后就判一下是否能合并成链，可以的话就得到答案，注意本来就是一条链的情况。

代码改了一个下午，极其鬼畜。

#include<cmath>
#include<algorithm>
#include<cstring>
#include<string>
#include<set>
#include<map>
#include<time.h>
#include<cstdio>
#include<vector>
#include<stack>
#include<queue>
#include<iostream>
using namespace std;
#define  LONG long long
const int   INF=0x3f3f3f3f;
const LONG  MOD=1e9+7;
const double PI=acos(-1.0);
#define clrI(x) memset(x,-1,sizeof(x))
#define clr0(x) memset(x,0,sizeof x)
#define clr1(x) memset(x,INF,sizeof x)
#define clr2(x) memset(x,-INF,sizeof x)
#define EPS 1e-10
struct Edge
{
    int to ,next;
}edge[500100];
int head[500100];
int take[210000];
int fa[210000];
int deep[210000];
int rt;
int Max;
int tot = 0;
int ans = 0;
int dp[210000];
int tar;
void add_edge(int u , int v)
{
    edge[++tot].to = v;
    edge[tot].next = head[u];
    head[u] = tot ;
}
bool judge = 1;
int dfs1(int u , int pre)
{
    int p = -1;
    int maxn = 1;
    for(int i = head[u] ; i != -1 ; i = edge[i].next)
    {
        int v = edge[i].to ;
        if(v == pre) continue;
        int tmp = dfs1(v,u) + 1;
        if(tmp != p && p != -1)
        {
            judge = 0;
            return 0;
        }
        else
        {
            p = tmp ;
        }
        maxn = max(tmp , maxn);
    }
    ans = max(ans , maxn);
    return maxn ;
}
void dfs2(int u ,int pre)
{
    fa[u] = pre;
    int num = 0;
    dp[u] = dp[pre] + 1;
    for(int i = head[u];i != -1 ;i = edge[i].next)
    {
        int v  = edge[i].to ;
        if(v == pre)continue ;
        dfs2(v,u);
        num ++;
    }
    if(num == 0)
    {
        if( Max < dp[u])
        {
            tar = u;
            Max = dp[u];
        }
    }
}
void Init()
{
    Max = 0;
    clr0(dp);
    clrI(head);
    judge = 1;
    tot = 0;
    clr0(take);
}
int main()
{
    Init();
    int n;
    cin>>n;
    int u , v;
    for( int  i = 1; i < n ;++ i)
    {
        scanf("%d%d",&u,&v);
        add_edge(u , v);
        add_edge(v , u);
    }
    dp[0] = 0;
    dfs2(1 , 0);
    rt = tar ;
    dp[0 ] = 0;
    Max = 0;
    dfs2(rt,0);
    int ret [5];
    ret[1] = rt ;
    ret[2] = tar ;
    int m = 0;
    if(Max%2 == 0)
    {
    int res = 0;;
    int real_ans = INF;
    for(int i = 1; i<=2; ++ i)
    {

       // cout<<rt<<" "<<i<<endl;
        judge = 1;
        ans = 0;
        dfs1(ret[i]  , -1);
        if(judge )
        {
            res = i;
            real_ans =min(ans , real_ans);
            break ;
        }
    }
//    cout<<res<<endl;
    //cout<<ans<<endl;
    if(judge )
    {
        for(;;)
        {
            if(!(ans & 1 ))
                break;
            ans = (ans -1)/2 + 1;
        }
        cout<<ans - 1<<endl;
    }
    else cout<<-1<<endl;
    }
    else
    {
        judge = 1;
        for(int i = tar; i != 0 ; i = fa[i])
            if(dp[i] == (Max+1)/2)
            {
                dp[0] = 0;
                for(int j = head[i] ; j!= -1 ; j = edge[j].next)
                {
                    //cout<<edge[j].to<<endl;
                    deep[++m] = dfs1( edge[j].to , i );
                    if(!judge) break;
                }

            //    cout<<rt5<<endl;
                break ;
            }
        int sum = 1 , cnt = 0 ;
        for(int i = 1; i<= m ; ++ i)
        {
         //   cout<<deep[i]<<endl;
            if(!take[deep[i]])
            {
                take[deep[i]] = 1;
                cnt ++ ;
                sum += deep[i];
            }
            if(cnt >3)
            {
                judge = 0;
                break;
            }
        }
     //   cout<<cnt<<endl;
        if(!judge)cout<<-1<<endl;
        else
        {
             for(;;)
            {
                if(!(sum & 1 ))
                break;
                sum = (sum -1)/2 + 1;
            }
        cout<<sum - 1<<endl;
        }
    }
//cout<<rt2<<endl;

}