bzoj 3197: [Sdoi2013]assassin 树哈希+树形dp+费用流

题意

给定一棵树和两组权值，求第一组权值最少改变多少个之后这棵树经过重标号之后与第二组权值相同。
n<=700

分析

我们可以按照3162的套路来搞，以树的重心作为根。而如果有两个重心的话就新建一个节点作为根。
设f[x,y]表示以x为根的子树最少需要需要多少步操作使得其与y为根的子树权值相同，且满足x的子树与y的子树是重构的。
因为树x与树y是重构的，所以它们的所有子树的形态也都是一样的。那么我们可以把树x所有重构的子树拿出来，是其与树y的这部分子树一一对应且总的操作步数最小。这个我们可以先求两两子树之间的f，然后问题就变成了求一个二分完全图的带权匹配，可以用费用流来解决。

代码

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;

typedef unsigned long long ull;

const int N=705;
const int inf=(int)1e9;
const int BASE=233333333;

int n,last[N],cnt,f[N][N],fa[N],size[N],val[N],root,tmp[N],a[N],b[N],dep[N];
queue<int> que;
pair<ull,int> p1[N],p2[N];
ull hash[N];
struct edge{int to,next;bool del;}e[N*2];
pair<int,pair<ull,int> > w[N];

int read()
{
    int x=0,f=1;char ch=getchar();
    while (ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while (ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}

struct Network
{
    int s,t,last[25],dis[25],cnt,pre[25];
    bool vis[25];
    struct edge{int to,next,c,w;}e[15*15*2];

    void clear(int n)
    {
        s=0;t=n+1;cnt=1;
        for (int i=s;i<=t;i++) last[i]=0;
    }

    void addedge(int u,int v,int c,int w)
    {
        e[++cnt].to=v;e[cnt].c=c;e[cnt].w=w;e[cnt].next=last[u];last[u]=cnt;
        e[++cnt].to=u;e[cnt].c=0;e[cnt].w=-w;e[cnt].next=last[v];last[v]=cnt;
    }

    bool spfa()
    {
        for (int i=s;i<=t;i++) dis[i]=inf;
        dis[s]=0;vis[s]=1;que.push(s);
        while (!que.empty())
        {
            int u=que.front();que.pop();
            for (int i=last[u];i;i=e[i].next)
                if (e[i].c&&dis[u]+e[i].w<dis[e[i].to])
                {
                    dis[e[i].to]=dis[u]+e[i].w;
                    pre[e[i].to]=i;
                    if (!vis[e[i].to]) vis[e[i].to]=1,que.push(e[i].to);
                }
            vis[u]=0;
        }
        if (dis[t]==inf) return 0;
        return 1;
    }

    int mcf()
    {
        int x=t;
        while (x!=s)
        {
            e[pre[x]].c--;
            e[pre[x]^1].c++;
            x=e[pre[x]^1].to;
        }
        return dis[t];
    }
}flow;

void addedge(int u,int v)
{
    e[++cnt].to=v;e[cnt].next=last[u];last[u]=cnt;
    e[++cnt].to=u;e[cnt].next=last[v];last[v]=cnt;
}

void get_root(int x,int fa)
{
    size[x]=1;
    for (int i=last[x];i;i=e[i].next)
    {
        if (e[i].to==fa) continue;
        get_root(e[i].to,x);
        size[x]+=size[e[i].to];
        val[x]=max(val[x],size[e[i].to]);
    }
    val[x]=max(val[x],n-size[x]);
    if (!root||val[x]<val[root]) root=x;
}

void get_hash(int x)
{
    dep[x]=dep[fa[x]]+1;
    for (int i=last[x];i;i=e[i].next)
        if (e[i].to!=fa[x]&&!e[i].del) fa[e[i].to]=x,get_hash(e[i].to);
    int s=0;
    for (int i=last[x];i;i=e[i].next)
        if (e[i].to!=fa[x]&&!e[i].del) tmp[++s]=hash[e[i].to];
    sort(tmp+1,tmp+s+1);
    hash[x]=233;
    for (int i=1;i<=s;i++) (((hash[x]*=BASE)^=tmp[i])+=tmp[i])^=tmp[i];
}

void solve(int x,int y)
{
    int s1=0,s2=0;
    for (int i=last[x];i;i=e[i].next)
        if (e[i].to!=fa[x]&&!e[i].del) p1[++s1]=make_pair(hash[e[i].to],e[i].to);
    for (int i=last[y];i;i=e[i].next)
        if (e[i].to!=fa[y]&&!e[i].del) p2[++s2]=make_pair(hash[e[i].to],e[i].to);
    sort(p1+1,p1+s1+1);sort(p2+1,p2+s2+1);
    for (int i=1;i<=s1;i++)
    {
        int j=i;
        while (j<s1&&p1[j+1].first==p1[j].first) j++;
        int len=j-i+1;
        flow.clear(len*2);
        for (int k=i;k<=j;k++)
            for (int l=i;l<=j;l++)
                flow.addedge(k-i+1,l-i+1+len,1,f[p1[k].second][p2[l].second]);
        for (int k=1;k<=len;k++) flow.addedge(flow.s,k,1,0),flow.addedge(k+len,flow.t,1,0);
        while (flow.spfa()) f[x][y]+=flow.mcf();
        i=j;
    }
    if (a[x]!=b[y]) f[x][y]++;
}

int main()
{
    n=read();
    for (int i=1;i<n;i++)
    {
        int x=read(),y=read();
        addedge(x,y);
    }
    for (int i=1;i<=n;i++) a[i]=read();
    for (int i=1;i<=n;i++) b[i]=read();
    get_root(1,0);
    int r1=0,r2=0;
    for (int i=1;i<=n;i++) if (val[i]==val[root]) r2=r1,r1=i;
    if (r2)
    {
        n++;addedge(n,r1);addedge(n,r2);root=n;
        for (int i=1;i<=cnt;i+=2) if (e[i].to==r1&&e[i+1].to==r2||e[i].to==r2&&e[i+1].to==r1) e[i].del=e[i+1].del=1;
    }
    get_hash(root);
    for (int i=1;i<=n;i++) w[i]=make_pair(-dep[i],make_pair(hash[i],i));
    sort(w+1,w+n+1);
    for (int i=1;i<=n;i++)
    {
        int j=i;
        while (j<n&&w[j+1].first==w[j].first&&w[j+1].second.first==w[j].second.first) j++;
        for (int k=i;k<=j;k++)
            for (int l=i;l<=j;l++)
                solve(w[k].second.second,w[l].second.second);
        i=j;
    }
    printf("%d",f[root][root]);
    return 0;
}