UVA11540 Sultan's Chandelier Burnside 引理 + DP

题目传送门

https://vjudge.net/problem/UVA-11540

https://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=2535（原题页面）

题解

首先如果两棵树经过一定的旋转以后能够重合，我们就称它们同构。

判断树的同构的常见方法是哈希。但是由于子树的先后顺序是有影响的，只有旋转以后相同才算等价，所以我的哈希方法是直接把所有孩子组成的序列倍长以后，用类似于字符串哈希的方法求出以每个孩子开始一圈的哈希值，取最小的作为当前这棵树的哈希。这样我们就可以轻易的判断两棵子树等不等价了。

然后，我们令 \(dp[x]\) 表示 \(x\) 的子树内，本质不同的染色方案的数量。

根据 Burnside 引理，在求 \(x\) 的方案的时候，我们可以枚举它的孩子们的环的旋转的幅度，然后判断这样旋转合不合法，即——旋转以后对应的两棵子树必须同构。这样，对于一个合法的幅度，这个环一定被分成了一些组，每一组的每棵子树必须使用一样的染色方案。我们把这样的每一组的方案乘起来以后的结果取平均就可以了。

另外，上面是 \(O(n^2)\) 的，实际上可以用 kmp 的最小循环节来线性的求，不详细展开，可以自己研究。

下面是代码，如上文所述，dp 部分的时间复杂度为 \(O(n^2)\)，建树为 \(O(n^2)\)，因此总的时间复杂度为 \(O(Tn^2)\)。

#include<bits/stdc++.h>

#define fec(i, x, y) (int i = head[x], y = g[i].to; i; i = g[i].ne, y = g[i].to)
#define dbg(...) fprintf(stderr, __VA_ARGS__)
#define File(x) freopen(#x".in", "r", stdin), freopen(#x".out", "w", stdout)
#define fi first
#define se second
#define pb push_back

template<typename A, typename B> inline char smax(A &a, const B &b) {return a < b ? a = b , 1 : 0;}
template<typename A, typename B> inline char smin(A &a, const B &b) {return b < a ? a = b , 1 : 0;}

typedef long long ll; typedef unsigned long long ull; typedef std::pair<int, int> pii;

template<typename I>
inline void read(I &x) {
    int f = 0, c;
    while (!isdigit(c = getchar())) c == '-' ? f = 1 : 0;
    x = c & 15;
    while (isdigit(c = getchar())) x = (x << 1) + (x << 3) + (c & 15);
    f ? x = -x : 0;
}

const int N = 100 + 7;
const int P = 1e9 + 7;
const int base = 1997;

int n, k, nod;
int siz[N], dp[N], vis[N];
std::vector<int> g[N];
char s[N * 10];
ull h[N], tmp[N << 1], bin[N];

inline int smod(int x) { return x >= P ? x - P : x; }
inline void sadd(int &x, int y) { x += y; x >= P ? x -= P : x; }
inline int fpow(int x, int y) {
    int ans = 1;
    for (; y; y >>= 1, x = (ll)x * x % P) if (y & 1) ans = (ll)ans * x % P;
    return ans;
}

inline int build(int l, int r) {
//  dbg("l = %d, r = %d\n", l, r);
    if (r < l) return ++nod;
    int o = ++nod, pre = l, cnt = 1;
    for (int i = l + 1; i <= r; ++i) {
        if (s[i] == '[') {
            if (!cnt) pre = i;
            ++cnt;
        } else if (s[i] == ']') {
            --cnt;
            if (!cnt) g[o].pb(build(pre + 1, i - 1));
        }
    }
    return o;
}

inline void dfs1(int x) {
    siz[x] = 1;
    int cnt = 0;
    for (int y : g[x]) {
        dfs1(y);
        siz[x] += siz[y], ++cnt;
//      tmp[tmp[0] + 1] = tmp[tmp[0]] * base + h[y], ++tmp[0];
    }
    int tt = 0;
    for (int y : g[x]) tmp[tt + 1] = tmp[tt] * base + h[y], ++tt;
    for (int y : g[x]) tmp[tt + 1] = tmp[tt] * base + h[y], ++tt;
//  dbg("****************** %llu %llu %llu %llu %llu\n", tmp[0], tmp[1], tmp[2], tmp[3], tmp[4]);
    for (int i = cnt; i; --i) tmp[i] = tmp[i + cnt] - bin[cnt] * tmp[i];
    std::sort(tmp + 1, tmp + cnt + 1);
//  dbg("****************** %llu %llu %llu %llu %llu,       %llu\n", tmp[0], tmp[1], tmp[2], tmp[3], tmp[4], bin[cnt]);
    if (cnt >= 1) h[x] = tmp[1] * siz[x];
    else h[x] = 1;
//  dbg("******************\n");
//  dbg("h[%d] = %llu, siz = %d\n", x, h[x], siz[x]);
}

inline void dfs2(int x) {
    int cnt = 0, ms = 0;
    dp[x] = 0;
    for (int y : g[x]) dfs2(y), ++cnt;
    for (int stp = 0; stp < cnt; ++stp) {
        int flag = 1, s = 1;
        for (int i = 0; i < cnt && flag; ++i) if (!vis[i]) {
            for (int j = i; !vis[j] && flag; j += stp, j >= cnt ? j -= cnt : 0) {
                vis[j] = 1;
                if (h[g[x][i]] != h[g[x][j]]) flag = 0;
            }
        }
        for (int i = 0; i < cnt; ++i) vis[i] = 0;
        if (!flag) continue;
        for (int i = 0; i < cnt; ++i) if (!vis[i]) {
            for (int j = i; !vis[j]; j += stp, j >= cnt ? j -= cnt : 0) vis[j] = 1;
            s = (ll)s * dp[g[x][i]] % P;
        }
        for (int i = 0; i < cnt; ++i) vis[i] = 0;
        sadd(dp[x], s), ++ms;
    }
//  dbg("dp[%d] = %d, ms = %d\n", x, dp[x], ms);
    dp[x] = (ll)dp[x] * fpow(ms, P - 2) % P * k % P;
    if (!cnt) dp[x] = k;
//  dbg("dp[%d] = %d, ms = %d\n", x, dp[x], ms);
}

inline void vec_cls(std::vector<int> &x) {
    std::vector<int> y;
    std::swap(x, y);
}

inline void ycl() {
    bin[0] = 1;
    for (int i = 1; i <= n; ++i) bin[i] = bin[i - 1] * base;
}

inline void work() {
    nod = -1;
    for (int i = 1; i <= n; ++i) vec_cls(g[i]);
    build(1, strlen(s + 1));
    n = nod;
    ycl();
    int ans = 1;
    for (int i = 1; i <= n; ++i) if (!siz[i]) { 
        dfs1(i);
        dfs2(i);
        ans = (ll)ans * dp[i] % P;
    }   
    static int CS = 0;
    printf("Case #%d: %d\n", ++CS, ans);
}

inline void init() {
    memset(siz, 0, sizeof(siz));
    scanf("%s", s + 1);
    read(k);
}

int main() {
#ifdef hzhkk
    freopen("hkk.in", "r", stdin);
#endif
    int T;
    read(T);
    while (T--) {
        init();
        work();
    }
    fclose(stdin), fclose(stdout);
    return 0;
}

原文地址：https://www.cnblogs.com/hankeke/p/UVA11540.html