洛谷P3296 刺客信条

题意：

给你一棵树，有两组01权值a[]和b[]。n <= 700

你要构造一个自己到自己的映射，使得整棵树的形态不变，且映射后的a[]和映射之前的b[]中不同元素尽量少。

解：

发现这个整棵树形态不变......我们可能要用到树hash。

有个结论就是两棵树同构，当且仅当以它们重心为根的时候hash值相同。有两个重心就新建一个虚重心。

于是我们把重心搞出来当根，考虑映射之后的树，如果a映射到了b，那么a和b一定深度相同且hash值相同。

于是我们就按照深度分层，每层枚举点对，用f[a][b]来表示把点a映射到点b，子树内最少的不同元素。

于是如何求f[a][b]？发现我们要给a和b的若干个子节点进行匹配，要求权值最小。二分图匹配即可。我采用费用流实现。

复杂度：O(n³ + n * 网络流)，这个复杂度是我猜的...

#include <bits/stdc++.h>

const int N = 710, MO = 998244353, INF = 0x3f3f3f3f;

struct Edge {
    int nex, v;
    bool del;
}edge[N << 1]; int tp = 1;

int f[N][N], n, e[N], siz[N], val[N], h[N], aim[N], p[1000010], top, small, root, root2, in_e[N], lm, in[N], d[N];
bool vis[1000010];
std::vector<int> v[N];

inline void getp(int n) {
    for(int i = 2; i <= n; i++) {
        if(!vis[i]) {
            p[++top] = i;
        }
        for(int j = 1; j <= top && i * p[j] <= n; j++) {
            vis[i * p[j]] = 1;
            if(i % p[j] == 0) {
                break;
            }
        }
    }
    return;
}

inline void add(int x, int y) {
    tp++;
    edge[tp].v = y;
    edge[tp].del = 0;
    edge[tp].nex = e[x];
    e[x] = tp;
    return;
}

void getroot(int x, int f) {
    int large = 0;
    siz[x] = 1;
    for(int i = e[x]; i; i = edge[i].nex) {
        int y = edge[i].v;
        if(y == f) {
            continue;
        }
        in_e[y] = i;
        getroot(y, x);
        siz[x] += siz[y];
        large = std::max(large, siz[y]);
    }
    large = std::max(large, n - siz[x]);
    if(large < small) {
        root = x;
        root2 = 0;
        small = large;
    }
    else if(large == small) {
        root2 = x;
    }
    return;
}

void DFS_1(int x, int f) {
    d[x] = d[f] + 1;
    v[d[x]].push_back(x);
    lm = std::max(lm, d[x]);
    h[x] = 1;
    for(int i = e[x]; i; i = edge[i].nex) {
        int y = edge[i].v;
        if(y == f || edge[i].del) {
            continue;
        }
        DFS_1(y, x);
        siz[x] += siz[y];
        h[x] = (h[x] + 1ll * h[y] * p[siz[y]] % MO) % MO;
    }
    return;
}

namespace fl {

    struct Edge {
        int nex, v, c, len;
        Edge(int N = 0, int V = 0, int C = 0, int L = 0) {
            nex = N;
            v = V;
            c = C;
            len = L;
        }
    }edge[2000010]; int tp = 1;

    int e[N], d[N], vis[N], Time, pre[N], flow[N], n, tot;
    std::queue<int> Q;

    inline void add(int x, int y, int z, int w) {
        //printf("addedge : x = %d y = %d z = %d w = %d 
", x, y, z, w);
        edge[++tp] = Edge(e[x], y, z, w);
        e[x] = tp;
        edge[++tp] = Edge(e[y], x, 0, -w);
        e[y] = tp;
        return;
    }

    inline bool SPFA(int s, int t) {
        vis[s] = Time;
        memset(d + 1, 0x3f, tot * sizeof(int));
        flow[s] = INF;
        d[s] = 0;
        Q.push(s);
        while(Q.size()) {
            int x = Q.front();
            Q.pop();
            vis[x] = 0;
            for(int i = e[x]; i; i = edge[i].nex) {
                int y = edge[i].v;
                if(d[y] > d[x] + edge[i].len && edge[i].c) {
                    d[y] = d[x] + edge[i].len;
                    flow[y] = std::min(edge[i].c, flow[x]);
                    pre[y] = i;
                    if(vis[y] != Time) {
                        vis[y] = Time;
                        Q.push(y);
                    }
                }
            }
        }
        return d[t] < INF;
    }

    inline void update(int s, int t) {

        int f = flow[t];
        while(s != t) {
            int i = pre[t];
            edge[i].c -= f;
            edge[i ^ 1].c += f;
            t = edge[i ^ 1].v;
        }
        return;
    }

    inline int solve(int x, int y) {

        int ans = 0, cost = 0;
        n = in[x] - (x != root);
        int s = 2 * n + 1, t = tot = s + 1;
        //printf("solve : x = %d  y = %d  n = %d 
", x, y, n);
        memset(e + 1, 0, tot * sizeof(int));
        tp = 1;

        for(int i = ::e[x], cnt1 = 1; i; i = ::edge[i].nex, ++cnt1) {
            int u = ::edge[i].v;
            //printf("u = %d 
", u);
            if(::d[u] < ::d[x] || ::edge[i].del) {
                --cnt1;
                continue;
            }
            add(s, cnt1, 1, 0);
            add(cnt1 + n, t, 1, 0);
            for(int j = ::e[y], cnt2 = 1; j; j = ::edge[j].nex, ++cnt2) {
                int v = ::edge[j].v;
                //printf("    v = %d 
", v);
                if(::d[v] < ::d[y] || ::edge[j].del) {
                    --cnt2;
                    continue;
                }
                /// u v
                if(f[u][v] > -INF) {
                    add(cnt1, n + cnt2, 1, f[u][v]);
                }

            }
        }

        ++Time;
        while(SPFA(s, t)) {
            //printf("inside --------------------- 
");
            ans += flow[t];
            cost += flow[t] * d[t];
            update(s, t);
            ++Time;
        }

        //printf("ans = %d cost = %d 
", ans, cost);
        if(ans != n) {
            return -INF;
        }
        else {
            return cost + (val[x] != aim[y]);
        }
    }
}

int main() {

    scanf("%d", &n);
    for(int i = 1, x, y; i < n; i++) {
        scanf("%d%d", &x, &y);
        add(x, y);
        add(y, x);
        in[x]++;
        in[y]++;
    }
    for(int i = 1; i <= n; i++) {
        scanf("%d", &val[i]);
    }
    for(int i = 1; i <= n; i++) {
        scanf("%d", &aim[i]);
    }
    root = root2 = 0;
    small = N;
    getroot(1, 0);
    //printf("root 1 = %d  root 2 = %d 
", root, root2);

    if(root2) {
        ++n;
        int i;
        if(edge[in_e[root] ^ 1].v == root2) {
            i = in_e[root];
        }
        else {
            i = in_e[root2];
        }
        edge[i].del = edge[i ^ 1].del = 1;
        add(n, root);
        add(n, root2);
        root = n;
        in[n] = 2;
    }
    ///

    //printf("root = %d 
", root);

    DFS_1(root, 0);

    for(int d = lm; d >= 1; d--) {
        int len = v[d].size();
        for(int i = 0; i < len; i++) {
            int x = v[d][i];
            for(int j = 0; j < len; j++) {
                int y = v[d][j];
                if(in[x] != in[y] || h[x] != h[y]) {
                    f[x][y] = -INF;
                    //printf("1 : ");
                }
                else {
                    //f[x][y] = KM::solve(x, y);
                    f[x][y] = fl::solve(x, y);
                    //printf("2 : ");
                }
                //printf("f %d %d = %d 
", x, y, f[x][y]);
            }
        }
    }

    printf("%d
", f[root][root]);
    return 0;
}