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 = 805; 
const int INF = 1e9;
const int A = 14221;
const int B = 20707;
const int P = 4481;
const int MOD = 1060469; 

struct Edge { int v,flag;
};
void read(int& x) {
    char c=getchar(); int f=1; x=0;
    while(!isdigit(c)) {if(c=='-')f=-1; c=getchar();}
    while(isdigit(c)) x=x*10+c-'0',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,0});
    g[v].push_back((Edge){u,0});
}

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

void calcHash(int u) {
    tmp.clear();
    FOR(i,0,(int)g[u].size()-1) {
        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,0,(int)tmp.size()-1)
        H[u]=(H[u]*P%MOD ^ tmp[i])%MOD;
    H[u]=(H[u]*B) %MOD;
}

int bfs(int s) {
    memset(vis,0,sizeof(vis));
    q.push(s); vis[s]=1;
    int maxu=s; dis[s]=0;
    while(!q.empty()) {
        int u=q.front(); q.pop();
        FOR(i,0,(int)g[u].size()-1) {
            int v=g[u][i].v;
            if(!vis[v]) {
                vis[v]=1; fa[v]=u; dis[v]=dis[u]+2;
                if(dis[v]>dis[maxu]) maxu=v;
                q.push(v);
            }
        }
    }
    return maxu;
}
void build(int u) {
    FOR(i,0,(int)g[u].size()-1) {
        int v=g[u][i].v;
        if(v!=fa[u] && !g[u][i].flag) {
            fa[v]=u;
            dep[v]=dep[u]+1;
            build(v);
        }
    }
    calcHash(u);
}
int getroot() {
    int x=bfs(1);
    int y=bfs(x);
    int mid=dis[y]/2,i;
    for(i=y;i!=x;i=fa[i]) {
        if(mid>=2) mid-=2;
        else break;
    }
    if(!mid) { fa[i]=-1; build(i); return i; }
    else {
        ++n;
        fa[n]=-1;
        adde(n,i); adde(fa[i],n);
        FOR(j,0,(int)g[i].size()-1)
            if(g[i][j].v==fa[i]) g[i][j].flag=1;
        FOR(j,0,(int)g[fa[i]].size()-1)
            if(g[fa[i]][j].v==i) g[fa[i]][j].flag=1;
        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,-1,sizeof(F));
    FOR(i,1,n) pos[i]=i;
    sort(pos+1,pos+n+1,cmp);
    FOR(st,1,n) {
        int last=st;
        while(last<=n&&dep[pos[last+1]]==dep[pos[st]]&&H[pos[last+1]]==H[pos[st]])
            last++;
        FOR(i,st,last) FOR(j,st,last) {
            int X=pos[i],Y=pos[j],tot=0;
            FOR(k,0,(int)g[X].size()-1)
                if(fa[X]!=g[X][k].v&&!g[X][k].flag) tot++;
            km.clear(tot);
            int idx=1,idy=1;
            FOR(k,0,(int)g[X].size()-1) {
                int v=g[X][k].v;
                if(v!=fa[X] && !g[X][k].flag) {
                    idy=1;
                    FOR(k2,0,(int)g[Y].size()-1) {
                        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]? 0:1;
        }
        st=last;
    }
}

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