【Foreign】旅行路线 [倍增]

旅行路线

Time Limit: 20 Sec  Memory Limit: 256 MB

Description

　　

Input

　　

Output

　　仅一行一个整数表示答案。

Sample Input

　　3
　　2 1
　　3 1

Sample Output

　　3

HINT

　　

Main idea

　　将每个点的入度作为标识，问从叶节点到根有几个本质不同的串。

Solution

　　我们先考虑暴力的写法，显然无重复的话是答案是ΣDep[i]，那么我们构建出一棵树，然后从任意两个点暴力往上判断找到最长相同的长度，然后减去这个长度即可。

　　我们发现这个算法慢在哪里？就是一步步判断太慢了！对于这种问题，我们显然可以使用倍增。

　　我们用字符串的哈希值来判断字符串是否相同，那么就记录一个hash[u][i]表示从u到往上跳(2^i)-1的哈希值，然后我们按照每个点到根的哈希值排序，显然得到的序列会满足：哈希值有相同的必然会在一起，若相同的长则会更接近。

　　然后我们O(n)比较相邻两个的哈希值，用倍增来跳，找到最长长度减去即可。

Code

 #include<iostream>
 #include<algorithm>
 #include<cstdio>
 #include<cstring>
 #include<cstdlib>
 #include<cmath>
 using namespace std;
 typedef long long s64;
 const int ONE = ;
 const int INF = ;
 const int P = ;

 int n;
 int x,y;
 int Input[ONE];
 int Dep[ONE],id[ONE];
 int f[ONE][];
 s64 Q[ONE],hash[ONE][];
 int next[ONE],first[ONE],go[ONE],tot;
 s64 Ans;

 int get()
 {
         int res=,Q=;    char c;
         while( (c=getchar())< || c>)
         if(c=='-')Q=-;
         if(Q) res=c-;
         while((c=getchar())>= && c<=)
         res=res*+c-;
         return res*Q;
 }

 int Add(int u,int v)
 {
         next[++tot]=first[u];    first[u]=tot;    go[tot]=v;
 }

 void Dfs(int u)
 {
         hash[u][] = Input[u];

         for(int i=;i<=P-;i++)
         {
             f[u][i+] = f[f[u][i]][i];
             hash[u][i+] = hash[u][i] + hash[f[u][i]][i] * Q[i];
         }

         for(int e=first[u];e;e=next[e])
         {
             int v=go[e];
             f[v][] = u;
             Dep[v] = Dep[u] + ;
             Dfs(v);
         }
 }

 bool cmp(int x,int y)
 {
         for(int i=P-;i>=;i--)
         if(Dep[x]>=(<<i) && hash[x][i] == hash[y][i])
         {
             x = f[x][i];
             y = f[y][i];
         }
         return hash[x][] < hash[y][];
 }

 int Same(int x,int y)
 {
         int res=;
         for(int i=P-;i>=;i--)
         if(Dep[x]>=(<<i) && hash[x][i] == hash[y][i])
         {
             x = f[x][i];
             y = f[y][i];
             res += (<<i);
         }
         return res;
 }

 int main()
 {
         n=get();
         for(int i=;i<=n;i++) id[i]=i;
         for(int i=;i<n;i++)
         {
             x=get();    y=get();
             Add(y,x);
             Input[x]++;    Input[y]++;
         }

         Q[] = 1e9+;
         for(int i=;i<=P;i++) Q[i] = Q[i-] * Q[i-];

         Dep[]=;    Dfs();
         sort(id+,id+n+,cmp);

         Ans = Dep[id[]];
         for(int i=;i<=n;i++)
         {
             Ans += Dep[id[i]] - Same(id[i],id[i-]);
         }

         printf("%lld",Ans);
 }