【题目】
原题地址
题目大意：给定一棵树和两组权值，求第一组权值最少改变多少个之后这棵树经过重标号之后与第二组权值相同（即树同构）。（权值只有01）

【题目分析】
树同构这个东西显然是树哈希之类的，然后树形结构可以考虑dp，但是dp的转移需要思考。
这题真的是太神了！！！

【解题思路】
首先设$f[i][j]$表示树1的$i$子树匹配树2的$j$子树的最小代价，这样就是一个树形dp，我们从下往上更新。
转移的必要条件是$i$和$j$所在子树同构而且二者深度相同。同时，要保证这两个子树对应所有子节点的最小花费已经求出。
那么现在我们要判断子树是否同构，这个东西可以用树hash实现，hash值相同的节点，而且深度相同，就是可以对应的。
但是因为是无根树，直接任选根hash可能会有问题，因此我们还要找出重心作根来hash。（如果有多个就加一个虚点）
接下来我们要处理的问题就是最小花费的匹配，这个东西其实就是一个费用流的模型。
对于可以对应的两个点$(i,j)$，我们就在这两个点之间连一条费用为$f[i][j]$，流量为1的边即可。
因为树同构，最终的答案就是$f[rt][rt]$。

【参考代码】

#include<bits/stdc++.h>
using namespace std;

typedef long long LL;
const int INF=1e9;
const int N=1410;
const int M=4e5+10;

int n,tot,tott,can,root,rtsiz,p,T,mi,ret,IP;
int siz[N],son[N],a[N],b[N],headt[N],head[N];
int dis[N],pre[N],rt[5];
int f[N][N];
bool inq[N];
LL hs[N],r[N];
queue<int>q;

struct Tway
{
    int u,v,nex,w,c;
};
Tway et[N],e[M];

void addtree(int u,int v)
{
    et[++tott]=(Tway){u,v,headt[u],0,0};headt[u]=tott;
    et[++tott]=(Tway){v,u,headt[v],0,0};headt[v]=tott;
}

void getroot(int x,int fa)
{
    siz[x]=1;
    for(int i=headt[x];i;i=et[i].nex)
    {
        int v=et[i].v;
        if(v!=fa)
        {
            getroot(v,x);
            siz[x]+=siz[v];
            son[x]=max(son[x],siz[v]);
        }
    }
    son[x]=max(son[x],n-siz[x]);
    if(son[root]==son[x])
        rt[++rtsiz]=x;
    else
    if(son[root]>son[x])
        root=x,rt[rtsiz=1]=x;
}

void gethash(int x,int fa)
{
    LL sum=0;siz[x]=1;
    for(int i=headt[x];i;i=et[i].nex)
    {
        int v=et[i].v;
        if(v!=fa && can!=i && can!=(i^1))
        {
            gethash(v,x);
            sum+=hs[v];
            siz[x]+=siz[v];
        }
    }
    hs[x]=(1ll*sum*p)^r[siz[x]];
}

void init()
{
    srand(19260817);tot=tott=1;p=233;
    scanf("%d",&n);T=2*n+2;
    for(int i=1;i<n;++i)
    {
        int u,v;
        scanf("%d%d",&u,&v);
        addtree(u,v);
    }
    for(int i=1;i<=n;++i)
        scanf("%d",&a[i]);
    for(int i=1;i<=n;++i)
        scanf("%d",&b[i]);
    son[0]=INF;getroot(1,0);
    if(rtsiz==2)
    {
        for(int i=headt[rt[1]];i;i=et[i].nex)
            if(et[i].v==rt[2])
            {
                can=i;
                break;          
            }
        root=++n;
        a[n]=b[n]=0;
        addtree(n,rt[1]);addtree(n,rt[2]);
    }
    for(int i=1;i<=n;++i)
        r[i]=((rand()%32766)<<15ll)+(rand()%32766);
    memset(f,127/3,sizeof(f));IP=f[0][0];
}


void add(int u,int v,int w,int c)
{
    e[++tot]=(Tway){u,v,head[u],w,c};head[u]=tot;
    e[++tot]=(Tway){v,u,head[v],0,-c};head[v]=tot;
}

bool spfa()
{
    memset(dis,127/3,sizeof(dis));
    dis[0]=0;inq[0]=true;q.push(0);
    while(!q.empty())
    {
        int u=q.front();q.pop();inq[u]=false;
        for(int i=head[u];i;i=e[i].nex)
        {
            int v=e[i].v;
            if(e[i].w && dis[u]+e[i].c<dis[v])
            {
                dis[v]=dis[u]+e[i].c;
                pre[v]=i;
                if(!inq[v])
                {
                    inq[v]=true;
                    q.push(v);
                }
            }
        }
    }
    return dis[T]!=IP;
}

void mcfx()
{
    ret=0;
    while(spfa())
    {
        int t=INF;
        for(int i=pre[T];i;i=pre[e[i].u])
            t=min(t,e[i].w);

        for(int i=pre[T];i;i=pre[e[i].u])
        {
            e[i].w-=t;e[i^1].w+=t;
            ret+=t*e[i].c;
        }
    }
}

/*void debug()
{
    for(int i=1;i<=T;++i)
    {
        printf("%d:\n",i);
        for(int j=head[i];j;j=e[j].nex)
            printf("%d %d %d %d\n",e[j].v,e[j].nex,e[j].w,e[j].c);
    }
    printf("\n");
}*/

void dp(int x,int fa)
{
    for(int i=headt[x];i;i=et[i].nex)
    {
        int v=et[i].v;
        if(v!=fa && can!=i && can!=(i^1))
            dp(v,x);
    }
    for(int i=1;i<=n;++i)
    {
        if(hs[i]!=hs[x])
            continue;
        memset(head,0,sizeof(head));tot=1;
        for(int j=headt[i];j;j=et[j].nex)
        {
            int v=et[j].v;
            add(v+n,T,1,0);
        }
        for(int j=headt[x];j;j=et[j].nex)
        {
            int v=et[j].v;
            if(v!=fa && can!=j && can!=(j^1))
            {
                add(0,v,1,0);
                for(int k=headt[i];k;k=et[k].nex)
                {
                    int vs=et[k].v;
                    if(hs[v]==hs[vs])
                        add(v,vs+n,1,f[v][vs]);
                }
            }
        }
        mcfx();
//      debug();
        f[x][i]=ret+(a[x]!=b[i]);
    }
}

void solve()
{
    gethash(root,0);
    dp(root,0);
    printf("%d\n",f[root][root]);
}

int main()
{
    freopen("BZOJ3197.in","r",stdin);
    freopen("BZOJ3197.out","w",stdout);

    init();
    solve();

    return 0;
}

【总结】
其实这题在思路上看是很清晰的，就是细节比较多，尤其是寻找重心的一步比较重要。
接下来就是dinic真的有这么慢吗qwq，memset真的有这么快吗qwq。