BZOJ 3197: [Sdoi2013]assassin 树形DP + 最小费用流 + 树的同构

Description

Input

Output

其实就是给出两颗树，求一种两种树同构的方式，使得不同颜色个数最少$.$
树的重新构建，其实就是指定不同的点为根节点$.$
好在树的重心有一个重要的性质：在一颗树上只有一个/两个点之间又一条边$.$
我们可以把第一棵树随便一个重心为根，求出每个点为根节点时的哈希值$.$
再枚举第二棵树的重心，如果这个重心为根的哈希值与第一个树根的哈希值相同，说明两个树以这两个点为根的形状是相同的，我们就可以进行DP$.$
令 $f[a][b]$ 表示 $a$ 为根与 $b$ 为根的子树进行匹配的最小代价(最少不同个数)$.$
当然，必须满足 $a$ 与 $b$ 的子树形态相同$.$
有一个问题：$a$ 的若干个儿子与 $b$ 的若干个儿子的哈希值都相同，那我们该怎么进行匹配呢？因为显然，只能是两两一一配对$.$
先求出 $a$ 的所有儿子与 $b$ 的所有儿子匹配的最小代价 $f[son[a]][son[b]]$.
发现这其实是一个二分图模型，即二分图最小匹配.
将儿子哈希值相同的连边，跑一个最小费用流就能帮助我们决策出哪两个匹配是最优的$.$
这么递归下去即可$.$
感觉好多题都是这种套路：很难通过人脑进行决策，那就直接让某些特定的算法（如网络流，最小生成树)来帮我们进行一个决策$.$

// luogu-judger-enable-o2
#include <cstdio> 
#include <cstring> 
#include <algorithm>    
#include <vector>  
#include <queue>       
#define ll long long      
#define inf 1000              
#define setIO(s) freopen(s".in", "r" , stdin)   
using namespace std;        
namespace MCMF 
{ 
    #define maxn 40  
    struct Edge
    {
        int from,to,cap,cost; 
        Edge(int a=0,int b=0,int c=0,int d=0):from(a),to(b),cap(c),cost(d){} 
    }; 
    queue<int>Q; 
    vector<Edge>edges; 
    vector<int>G[maxn]; 
    int d[maxn],flow2[maxn],inq[maxn],pre[maxn],s,t,ans; 
    inline void addedge(int u,int v,int c,int d) 
    {
        edges.push_back(Edge(u,v,c,d)), edges.push_back(Edge(v,u,0,-d));   
        G[u].push_back(edges.size()-2), G[v].push_back(edges.size()-1);     
    }   
    inline int spfa() 
    {
        int i,j; 
        memset(inq,0,sizeof(inq)); 
        for(i=0;i<maxn;++i) d[i]=flow2[i]=inf;
        Q.push(s),d[s]=0,inq[s]=1; 
        while(!Q.empty()) 
        {
            int u=Q.front(); Q.pop(), inq[u]=0;      
            for(i=0;i<G[u].size();++i) 
            {
                Edge e=edges[G[u][i]];      
                if(d[e.to]>d[u]+e.cost&&e.cap) 
                {
                    d[e.to]=d[u]+e.cost, pre[e.to]=G[u][i];     
                    flow2[e.to]=min(e.cap,flow2[u]);
                    if(!inq[e.to]) 
                    {
                        inq[e.to]=1;    
                        Q.push(e.to);       
                    }  
                }
            }
        }       
        int f=flow2[t],tr=t;  
        if(f==inf) return 0;   
        edges[pre[tr]].cap-=f, edges[pre[tr]^1].cap+=f, tr=edges[pre[tr]].from;   
        while(tr!=s)   
            edges[pre[tr]].cap-=f,edges[pre[tr]^1].cap+=f,tr=edges[pre[tr]].from;    
        ans+=d[t]*f; 
        return 1;      
    } 
    inline void re() 
    {
        edges.clear(); 
        memset(pre,0,sizeof(pre));     
        for(int i=0;i<maxn;++i) G[i].clear(); 
        ans=0;             
    }
    inline int getcost() 
    {
        while(spfa()); 
        return ans;    
    }
}; 
const int ha=2019, mul=5589, mod=233233, N=802;        
int n, edges,root;      
int hd[N],nex[N<<1],to[N<<1],s1[N],s2[N],f[N][N];                       
inline void addedge(int u,int v) 
{
    nex[++edges]=hd[u],hd[u]=edges,to[edges]=v;      
} 
struct G 
{ 
    vector<int>sor[N];  
    int Hash[N], siz[N], mx[N],root;             
    void getroot(int u,int ff) 
    {
        siz[u]=1,mx[u]=0;     
        for(int i=hd[u];i;i=nex[i]) 
            if(to[i]!=ff) 
                getroot(to[i],u), siz[u]+=siz[to[i]],mx[u]=max(mx[u],siz[to[i]]);   
        mx[u]=max(mx[u],n-siz[u]); 
        if(mx[u]<mx[root]) root=u;                              
    }   
    void calc(int u,int ff) 
    {
        sor[u].clear(), Hash[u]=ha;    
        for(int i=hd[u];i;i=nex[i]) 
            if(to[i]!=ff)   
                calc(to[i],u), sor[u].push_back(Hash[to[i]]);       
        sort(sor[u].begin(),sor[u].end());       
        for(int i=0;i<sor[u].size();++i) Hash[u]=((Hash[u]*mul)^sor[u][i])%mod;                             
    }  
}t[6];     
vector<int>c1[N],c2[N];      
int solve(int x,int fx,int y,int fy,int ty) 
{   
    if(f[x][y]!=-1) return f[x][y];   
    f[x][y]=s1[x]^s2[y];                   
    int i,j,nn=0;                             
    for(i=hd[x];i;i=nex[i]) 
    { 
        if(to[i]==fx) continue;           
        for(j=hd[y];j;j=nex[j]) 
        { 
            if(to[j]==fy) continue;    
            if(t[0].Hash[to[i]]==t[ty].Hash[to[j]])  
                solve(to[i],x,to[j],y,ty); 
        }
    }           
    c1[x].clear(),c2[x].clear(); 
    for(i=hd[x];i;i=nex[i]) if(to[i]!=fx) ++nn, c1[x].push_back(to[i]); 
    for(i=hd[y];i;i=nex[i]) if(to[i]!=fy) c2[x].push_back(to[i]);   
    MCMF::re();  
    for(i=0;i<c1[x].size();++i) 
        for(j=0;j<c2[x].size();++j) 
            if(t[0].Hash[c1[x][i]]==t[ty].Hash[c2[x][j]]) 
                MCMF::addedge(i+1,j+1+nn,1,f[c1[x][i]][c2[x][j]]);            
    MCMF::s=0,MCMF::t=nn+c2[x].size()+1;                
    for(i=1;i<=nn;++i) MCMF::addedge(0,i,1,0);             
    for(i=1;i<=c2[x].size();++i) MCMF::addedge(nn+i,nn+c2[x].size()+1,1,0);       
    f[x][y]+=MCMF::getcost();     
    return f[x][y];          
}
int main() 
{
    int i,j,ans,ty=0;         
    // setIO("input"); 
    scanf("%d", &n);   
    for(i=1;i<n;++i) 
    {
        int a, b; 
        scanf("%d%d",&a,&b),addedge(a,b),addedge(b,a);          
    }
    for(i=1;i<=n;++i) scanf("%d",&s1[i]); 
    for(i=1;i<=n;++i) scanf("%d",&s2[i]);  
    t[0].mx[0]=n, t[0].getroot(1,0), t[0].calc(t[0].root,0);        
    for(ans=n,i=1;i<=n;++i) 
        if(t[0].mx[i]==t[0].mx[t[0].root]) 
        {  
            ++ty;      
            t[ty].calc(i, 0);     
            if(t[ty].Hash[i]==t[0].Hash[t[0].root]) 
            {   
                memset(f,-1,sizeof(f));        
                ans=min(ans,solve(t[0].root,0,i,0,ty));     
            }
        }
    printf("%d\n",ans);    
    return 0 ; 
}