关于dsu on tree 和一些例题 CF 741 D

题意：http://codeforces.com/problemset/problem/741/D

求各个子树的最长回文链，字符可任意组合

思路：

其实肯定是要转换成进制状压的

也是dsu on tree的模板题

这里由于保留重子树要上升一条链（因为值是在边上的）

更新不太好更新，我一开始一直想着从当前根往下记录，这样非常难搞

但是从上往下就 很好搞，直接记录pos点向上的整条链，两条链异或也就是那条折链（思路就出来了

代码细节还是有点的，本人debug 滴不出来就不搞了==|||

update 2020 4 23:

de出来了

#define IOS ios_base::sync_with_stdio(0); cin.tie(0);
#include <cstdio>//sprintf islower isupper
#include <cstdlib>//malloc  exit strcat itoa system("cls")
#include <iostream>//pair
#include <fstream>//freopen("C:\Users\13606\Desktop\Input.txt","r",stdin);
#include <bitset>
//#include <map>
//#include<unordered_map>
#include <vector>
#include <stack>
#include <set>
#include <string.h>//strstr substr strcat
#include <string>
#include <time.h>// srand(((unsigned)time(NULL))); Seed n=rand()%10 - 0~9;
#include <cmath>
#include <deque>
#include <queue>//priority_queue<int, vector<int>, greater<int> > q;//less
#include <vector>//emplace_back
//#include <math.h>
#include <cassert>
#include <iomanip>
//#include <windows.h>//reverse(a,a+len);// ~ ! ~ ! floor
#include <algorithm>//sort + unique : sz=unique(b+1,b+n+1)-(b+1);+nth_element(first, nth, last, compare)
using namespace std;//next_permutation(a+1,a+1+n);//prev_permutation
//******************
clock_t __START,__END;
double __TOTALTIME;
void _MS(){__START=clock();}
void _ME(){__END=clock();__TOTALTIME=(double)(__END-__START)/CLOCKS_PER_SEC;cout<<"Time: "<<__TOTALTIME<<" s"<<endl;}
//***********************
#define rint register int
#define fo(a,b,c) for(rint a=b;a<=c;++a)
#define fr(a,b,c) for(rint a=b;a>=c;--a)
#define mem(a,b) memset(a,b,sizeof(a))
#define pr printf
#define sc scanf
#define ls rt<<1
#define rs rt<<1|1
typedef pair<int,int> PII;
typedef vector<int> VI;
typedef unsigned long long ull;
typedef long long ll;
typedef double db;
const db E=2.718281828;
const db PI=acos(-1.0);
const ll INF=(1LL<<60);
const int inf=(1<<30);
const db ESP=1e-9;
const int mod=(int)1e9+7;
const int N=(int)1e6+10;

struct EDGE
{
    int to,next;
    int c;
}edge[N<<1];
int tot;
int head[N];
void add(int from,int to,int c)
{
    ++tot;
    edge[tot].to=to;
    edge[tot].c=c;
    edge[tot].next=head[from];
    head[from]=tot;
}//for(int i=head[x];i;i=edge[i].next)

int sz[N],Bigson[N],vb[N],dis[N],deep[N];
char s[N];
int ans[N];
void dfs(int x,int fa,int dep,int val)
{
    sz[x]=1;
    dis[x]=val;
    deep[x]=dep;
    for(int i=head[x];i;i=edge[i].next)
    {
        int to=edge[i].to;
        if(to==fa)continue;
        dfs(to,x,dep+1,val^edge[i].c);
        sz[x]+=sz[to];
        if(sz[Bigson[x]]<sz[to])
            Bigson[x]=to,vb[x]=edge[i].c;
    }
}

int Son;
bool okself(int xx)
{
    bool ok=0;
    if(xx==0)ok=1;
    for(int i=1;i<=22;++i)
        if((xx^(1<<(i-1)))==0)ok=1;
    return ok;
}
int mark[1<<23];

void goself(int x,int fa,int who)
{
    mark[dis[x]]=max(mark[dis[x]],deep[x]);
    if(okself(dis[x]^dis[who]))ans[who]=max(ans[who],deep[x]-deep[who]);
    for(int i=head[x];i;i=edge[i].next)
    {
        int to=edge[i].to;
        if(to==fa||to==Son)continue;
        goself(to,x,who);
    }
}
void go(int x,int fa,int who)
{
    if(mark[dis[x]])ans[who]=max(ans[who],mark[dis[x]]+deep[x]-2*deep[who]);
    for(int i=1;i<=22;++i)
        if(mark[dis[x]^(1<<(i-1))])ans[who]=max(ans[who],mark[dis[x]^(1<<(i-1))]+deep[x]-2*deep[who]);
    for(int i=head[x];i;i=edge[i].next)
    {
        int to=edge[i].to;
        if(to==fa||to==Son)continue;
        go(to,x,who);
    }
}
void del(int x,int fa)
{
    mark[dis[x]]=0;
    for(int i=head[x];i;i=edge[i].next)
    {
        int to=edge[i].to;
        if(to==fa)continue;
        del(to,x);
    }
}

void dfs2(int x,int fa,int op)//保证回溯时,重儿子数据全留,轻儿子数据全没有
{
    for(int i=head[x];i;i=edge[i].next)
    {
        int to=edge[i].to;
        if(to==fa)continue;
        if(to!=Bigson[x])dfs2(to,x,0),ans[x]=max(ans[x],ans[to]);
    }
    if(Bigson[x])dfs2(Bigson[x],x,1),ans[x]=max(ans[x],ans[Bigson[x]]);

    Son=Bigson[x];
    if(mark[dis[x]])ans[x]=max(ans[x],mark[dis[x]]-deep[x]);
    for(int i=1;i<=22;++i)
        if(mark[dis[x]^(1<<(i-1))])ans[x]=max(ans[x],mark[dis[x]^(1<<(i-1))]-deep[x]);
    mark[dis[x]]=max(mark[dis[x]],deep[x]);
    for(int i=head[x];i;i=edge[i].next)
    {
        int to=edge[i].to;
        if(to==fa)continue;
        if(to!=Bigson[x])
            go(to,x,x),goself(to,x,x);
    }

    if(!op)del(x,fa);
}

int main()
{
    int n;
    sc("%d",&n);
    for(int i=2;i<=n;++i)
    {
        char temp[5];
        int u;
        sc("%d%s",&u,temp);
        add(u,i,1<<(temp[0]-'a'));
        add(i,u,1<<(temp[0]-'a'));
    }
    dfs(1,-1,1,0);
    dfs2(1,-1,1);
    for(int i=1;i<=n;++i)
        pr("%d ",ans[i]);
    return 0;
}

/**************************************************************************************/