bzoj 3197 [Sdoi2013]assassin（Hash+DP+KM）

Description

Input

Output

Sample Input

4
1 2
2 3
3 4
0 0 1 1
1 0 0 0

Sample Output

1

HINT

【思路】

Hash，DP，KM

题目就是要找一个同构的树，使能够以最少的修改转换成目标状态。

树的形态可以有多种但是他的中心只有一个。先找出中心，如果在边上则新建一个节点。以中心为根建树。同构的节点在树上是对称的。求出Hash。Hash函数如下：

H[u]=((((A*H[son1])*p+H[son2])*p+H[son3])*p)

　　 通过判断hash值和节点深度dep就可知道是否同构。

在树上进行DP，设F[i][j]表示将j子树作为i子树同构时对应的最小花费。转移就是将i和j两个节点的儿子以最小权和进行完美匹配，匹配代价为F[soni][sonj]，所以我们要按照dep序和hash将节点排一下序，这样相同的hash形成了一个区间，对于一个区间内的所有点对可以求出F，同时在求当前F的时候子结点的信息已经得到。

　　 因为形态唯一，所以最终答案为F[root][root]。

【代码】

 #include<cmath>
 #include<queue>
 #include<vector>
 #include<cstdio>
 #include<cstring>
 #include<iostream>
 #include<algorithm>
 #define FOR(a,b,c) for(int a=(b);a<=(c);a++)
 using namespace std;

 typedef long long LL;
 const int N = ;
 const int INF = 1e9;
 const int A = ;
 const int B = ;
 const int P = ;
 const int MOD = ; 

 struct Edge { int v,flag;
 };
 void read(int& x) {
     char c=getchar(); int f=; x=;
     while(!isdigit(c)) {if(c=='-')f=-; c=getchar();}
     while(isdigit(c)) x=x*+c-'',c=getchar();
     x*=f;
 }

 vector<Edge> g[N];
 vector<int> tmp;
 queue<int> q;

 void adde(int u,int v) {
     g[u].push_back((Edge){v,});
     g[v].push_back((Edge){u,});
 }

 int n,root;
 int dis[N],dep[N],fa[N],vis[N];
 int firstST[N],finalST[N];
 LL H[N];

 struct KM {
     int g[N][N];
     int lx[N],rx[N];
     int l[N],r[N],res[N];
     int slack[N];

     void clear(int n) {
         FOR(i,,n) FOR(j,,n) g[i][j]=-;
         FOR(i,,n) res[i]=;
     }

     bool find(int x,int n) {
         lx[x]=;
         FOR(i,,n)
             if(!rx[i] && g[x][i]!=-) {
                 int tmp=g[x][i]-l[x]-r[i];
                 if(!tmp) {                                //相等子图
                     rx[i]=;
                     if(!res[i] || find(res[i],n)) {
                         res[i]=x;
                         return ;
                     }
                 } else {
                     slack[i]=min(slack[i],tmp);            //更新 i 的 slack
                 }
             }
         return ;
     }
     int solve(int n) {
         if(!n) return ;
         FOR(i,,n) r[i]=;
         FOR(i,,n) {                                    //初始化顶标
             l[i]=INF;
             FOR(j,,n) if(g[i][j] != -) {
                 l[i]=min(l[i],g[i][j]);
             }
         }
         FOR(i,,n) {                                    //依次匹配 i
             FOR(j,,n) slack[j]=INF;
             int cnt=;
             for(;;) {
                 cnt++;
                 FOR(j,,n) lx[j]=rx[j]=;
                 if(find(i,n)) break;
                 int mini=INF;                            //修改顶标使容纳更多的边
                 FOR(i,,n) if(!rx[i])                    //最小 slack S->T'
                     mini=min(mini,slack[i]);
                 FOR(i,,n) {
                     if(lx[i]) l[i]+=mini;                // S 和 T 集合的修改 保证原来的边依旧存在
                     if(rx[i]) r[i]-=mini;
                     else slack[i]-=mini;                //改变 slack
                 }
             }
         }
         int ans=;
         FOR(i,,n) ans+=l[i]+r[i];                        //相等子图的完美匹配 左右顶标之和
         return ans;
     }
 } km;

 void calcHash(int u) {
     tmp.clear();
     FOR(i,,(int)g[u].size()-) {
         int v=g[u][i].v;
         if(v!=fa[u]&&!g[u][i].flag)
             tmp.push_back(H[v]);
     }
     sort(tmp.begin(),tmp.end());
     H[u]=A;
     FOR(i,,(int)tmp.size()-)
         H[u]=(H[u]*P%MOD ^ tmp[i])%MOD;
     H[u]=(H[u]*B) %MOD;
 }

 int bfs(int s) {
     memset(vis,,sizeof(vis));
     q.push(s); vis[s]=;
     int maxu=s; dis[s]=;
     while(!q.empty()) {
         int u=q.front(); q.pop();
         FOR(i,,(int)g[u].size()-) {
             int v=g[u][i].v;
             if(!vis[v]) {
                 vis[v]=; fa[v]=u; dis[v]=dis[u]+;
                 if(dis[v]>dis[maxu]) maxu=v;
                 q.push(v);
             }
         }
     }
     return maxu;
 }
 void build(int u) {
     FOR(i,,(int)g[u].size()-) {
         int v=g[u][i].v;
         if(v!=fa[u] && !g[u][i].flag) {
             fa[v]=u;
             dep[v]=dep[u]+;
             build(v);
         }
     }
     calcHash(u);
 }
 int getroot() {
     int x=bfs();
     int y=bfs(x);
     int mid=dis[y]/,i;
     for(i=y;i!=x;i=fa[i]) {
         if(mid>=) mid-=;
         else break;
     }
     if(!mid) { fa[i]=-; build(i); return i; }
     else {
         ++n;
         fa[n]=-;
         adde(n,i); adde(fa[i],n);
         FOR(j,,(int)g[i].size()-)
             if(g[i][j].v==fa[i]) g[i][j].flag=;
         FOR(j,,(int)g[fa[i]].size()-)
             if(g[fa[i]][j].v==i) g[fa[i]][j].flag=;
         build(n);
         return n;
     }
 }

 bool cmp(const int& x,const int& y) {
     return dep[x]>dep[y] || (dep[x]==dep[y]&&H[x]<H[y]);
 }

 int F[N][N],pos[N];

 void DP() {
     memset(F,-,sizeof(F));
     FOR(i,,n) pos[i]=i;
     sort(pos+,pos+n+,cmp);
     FOR(st,,n) {
         int last=st;
         while(last<=n&&dep[pos[last+]]==dep[pos[st]]&&H[pos[last+]]==H[pos[st]])
             last++;
         FOR(i,st,last) FOR(j,st,last) {
             int X=pos[i],Y=pos[j],tot=;
             FOR(k,,(int)g[X].size()-)
                 if(fa[X]!=g[X][k].v&&!g[X][k].flag) tot++;
             km.clear(tot);
             int idx=,idy=;
             FOR(k,,(int)g[X].size()-) {
                 int v=g[X][k].v;
                 if(v!=fa[X] && !g[X][k].flag) {
                     idy=;
                     FOR(k2,,(int)g[Y].size()-) {
                         int v2=g[Y][k2].v;
                         if(v2!=fa[Y] && !g[Y][k2].flag) {
                             km.g[idx][idy]=F[v][v2];
                             idy++;
                         }
                     }
                     idx++;
                 }
             }
             F[X][Y]=km.solve(tot);
             F[X][Y]+=firstST[X]==finalST[Y]? :;
         }
         st=last;
     }
 }

 int main() {
     read(n);
     int u,v;
     FOR(i,,n-) {
         read(u),read(v);
         adde(u,v);
     }
     FOR(i,,n) read(firstST[i]);
     FOR(i,,n) read(finalST[i]);
     root=getroot();
     text(root,-);
     DP();
     printf("%d",F[root][root]);
     return ;
 }