CF741DArpa’s letter-marked tree and Mehrdad’s Dokhtar-kosh paths（DSU on tree）

题目大意：

　　给定一个以1为根的树，每条路径上都有一个字符（a~v共22个）询问对于每一个子树内最长的路径上字母经排序后可以形成回文串的最长路径多长

解题思路：

　　假定给你一个字符串，如何判定其经打乱能否形成回文串，那就是说所有字符中最多只有一个能出现奇数次，22个字符，可以用2进制表示每个字符出现的次数奇偶性，1为奇0为偶，那么处理出一个点到根节点路径上的异或和（设为x_i），如果两个节点i，j的x_i=x_j那么就说明这两个点的路径上符合要求。

　　暴力的思路：暴力搜索一棵树中所有的x_i看看有没有相同或差一位的再进行答案更新。

　　考虑优化，既然是不同子树中的点，那么就可以用一个数组存起来异或和为x的最大深度maxdeep[x]，每次进去找，找完再把整颗子树推进去。这样就是O(n²)

　　这样就可以用DSU了，每次处理子树时，最后处理重儿子，非重儿子直接推倒，在更新上层时直接在重儿子版本上构建数组，再重建轻儿子，注意更新答案时要更新为子树最大值，跨字数最大值，返祖链最大值中的最大值。时间复杂度O(nlogn)

　　DSU还是十分优秀啊

　　代码：

 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 struct pnt{
     int hd;
     int dp;
     int wgt;
     int mxs;
     int ans;
     int xr;
 }p[];
 struct ent{
     int twd;
     int lst;
     int vls;
 }e[];
 int n;
 int cnt;
 char cmd[];
 int mxdp[];
 void ade(int f,int t,int v)
 {
     cnt++;
     e[cnt].twd=t;
     e[cnt].lst=p[f].hd;
     e[cnt].vls=v;
     p[f].hd=cnt;
 }
 void Basic_dfs(int x,int f)
 {
     p[x].dp=p[f].dp+;
     p[x].wgt=;
     int maxs=-;
     for(int i=p[x].hd;i;i=e[i].lst)
     {
         int to=e[i].twd;
         p[to].xr=p[x].xr^e[i].vls;
         Basic_dfs(to,x);
         p[x].wgt+=p[to].wgt;
         if(maxs<p[to].wgt)
         {
             maxs=p[to].wgt;
             p[x].mxs=to;
         }
     }
 }
 void Build_dfs(int x)
 {
     mxdp[p[x].xr]=std::max(mxdp[p[x].xr],p[x].dp);
     for(int i=p[x].hd;i;i=e[i].lst)
         Build_dfs(e[i].twd);
 }
 void Destory_dfs(int x)
 {
     mxdp[p[x].xr]=;
     for(int i=p[x].hd;i;i=e[i].lst)
         Destory_dfs(e[i].twd);
 }
 void Ans_dfs(int x,int a)
 {
     if(mxdp[p[x].xr])
         p[a].ans=std::max(p[a].ans,p[x].dp+mxdp[p[x].xr]-*p[a].dp);
     for(int i=;i<;i++)
     {
         int tmp=<<i;
         if(mxdp[p[x].xr^tmp])
             p[a].ans=std::max(p[a].ans,p[x].dp+mxdp[p[x].xr^tmp]-*p[a].dp);
     }
     for(int i=p[x].hd;i;i=e[i].lst)
         Ans_dfs(e[i].twd,a);
 }
 void DSU_dfs(int x,bool hvs)
 {
     for(int i=p[x].hd;i;i=e[i].lst)
     {
         int to=e[i].twd;
         if(to==p[x].mxs)
             continue;
         DSU_dfs(to,false);
         p[x].ans=std::max(p[x].ans,p[to].ans);
     }
     if(p[x].mxs)
     {
         DSU_dfs(p[x].mxs,true);
         p[x].ans=std::max(p[x].ans,p[p[x].mxs].ans);
     }
     if(mxdp[p[x].xr])
         p[x].ans=std::max(p[x].ans,mxdp[p[x].xr]-p[x].dp);
     for(int i=;i<;i++)
     {
         int tmp=<<i;
         if(mxdp[p[x].xr^tmp])
             p[x].ans=std::max(p[x].ans,mxdp[p[x].xr^tmp]-p[x].dp);
     }
     mxdp[p[x].xr]=std::max(p[x].dp,mxdp[p[x].xr]);
     for(int i=p[x].hd;i;i=e[i].lst)
     {
         int to=e[i].twd;
         if(to==p[x].mxs)
             continue;
         Ans_dfs(to,x);
         Build_dfs(to);
     }
     if(hvs)
         return ;
     Destory_dfs(x);
 }
 int main()
 {
     scanf("%d",&n);
     for(int i=;i<=n;i++)
     {
         int x;
         scanf("%d",&x);
         scanf("%s",cmd);
         int tmp=<<(cmd[]-'a');
         ade(x,i,tmp);
     }
     Basic_dfs(,);
     DSU_dfs(,true);
     for(int i=;i<=n;i++)
         printf("%d ",p[i].ans);
     puts("");
     return ;
 }