LOJ#2723 多边形

解：首先，n<=20的直接暴力建图然后状压哈密顿回路，相信大家都会。固定1为起点，f_i,s表示结尾为i点，状态为s。每次遍历i的出边转移，最后遍历1的出边统计答案。n²2ⁿ。

然后就是正经题解了。先考虑K = 1的时候。对于一个子树，我们发现它只有三个地方有出边，左右上。而除此之外内部怎么连是没关系的，只要满足每个点都经过就行了。

于是就设f_i,j表示以i为根的子树中，与外界连通状态为j的方案数。0表示从左右出去且经过根节点，1表示从左上出去，2表示从右上出去，3表示从左右出去且不经过根节点(这是为了方便转移才设的)。

每次合并两个子树而非一次做整个根节点(方便之后K > 1的时候)，于是我们考虑每个状态如何被转移来：

• 0由所有子树中某两个相邻的12状态和两边的0状态转移来。也就是从0 + 0(前面有两个相邻的12)或1 + 2转移来。
• 1由最后的一个1和前面的所有0转移过来。也就是3 + 1。
• 2由最前面的一个2和后面的所有0转移过来，也就是2 + 0，注意要特判当前子树为第一个子树时的情况。
• 3由所有0转移过来，也就是0 + 0。

于是我们得到了一个O(n)的树形DP，注意根节点最后一个子树合并上来的时候，状态0还有一种情况就是最左2 + 中间0 + 最右1也就是2 + 1的转移。

然后输出f[1][0]即可获得30分，配合暴力有50分。

#include <bits/stdc++.h>

const int N = 1010, MO = 998244353;

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

int e[N], n, K, fa[N], stk[N], top, pw[1200000];
int f[22][1200000];
std::vector<int> G[N];
std::bitset<N> bt[N];

inline void add(int x, int y) {
    tp++;
    //printf("add %d %d 
", x, y);
    bt[x].set(y);
    edge[tp].v = y;
    edge[tp].nex = e[x];
    e[x] = tp;
    return;
}

void DFS(int x) {
    if(!G[x].size()) {
        stk[++top] = x;
    }
    for(int i = 0; i < (int)G[x].size(); i++) {
        int y = G[x][i];
        DFS(y);
    }
    return;
}

inline void link(int x, int y) {
    if(bt[x][y]) {
        return;
    }
    add(x, y);
    add(y, x);
    return;
}

inline void out(int x) {
    for(int i = 0; i < n; i++) {
        printf("%d", (x >> i) & 1);
    }
    return;
}

namespace k1 {
    int f[N][4];
    void DFS(int x) {
        if(!G[x].size()) {
            f[x][0] = f[x][1] = f[x][2] = 1;
            //printf("x = %d  %d %d %d %d 
", x, f[x][0], f[x][1], f[x][2], f[x][3]);
            return;
        }
        f[x][3] = 1;
        for(int i = 0; i < G[x].size(); i++) {
            int y = G[x][i];
            DFS(y);
            ///merge
            int t0 = (1ll * f[x][0] * f[y][0] % MO + 1ll * f[x][1] * f[y][2] % MO) % MO;
            int t1 = 1ll * f[x][3] * f[y][1] % MO;
            int t2 = i ? 1ll * f[x][2] * f[y][0] % MO : f[y][2];
            int t3 = 1ll * f[x][3] * f[y][0] % MO;
            if(x == 1 && i == G[x].size() - 1) {
                (t0 += 1ll * f[x][2] * f[y][1] % MO) %= MO;
            }
            f[x][0] = t0;
            f[x][1] = t1;
            f[x][2] = t2;
            f[x][3] = t3;
        }
        //printf("x = %d  %d %d %d %d 
", x, f[x][0], f[x][1], f[x][2], f[x][3]);
        return;
    }
    inline void solve() {
        DFS(1);
        printf("%d
", f[1][0]);
        return;
    }
}

int main() {

    //freopen("polygon.in", "r", stdin);
    //freopen("polygon.out", "w", stdout);

    scanf("%d%d", &n, &K);

    for(int i = 2, x; i <= n; i++) {
        scanf("%d", &x);
        add(x, i); add(i, x);
        fa[i] = x;
        G[x].push_back(i);
    }

    for(int i = 1; i <= n; i++) std::sort(G[i].begin(), G[i].end());

    if(K == 1) {
        k1::solve();
        return 0;
    }

    DFS(1);

    for(int i = 1; i <= top; i++) {
        for(int j = 1; j <= K; j++) {
            int temp = i + j;
            if(temp > top) {
                temp %= top;
            }
            if(!temp) {
                temp = top;
            }
            link(stk[i], stk[temp]);
        }
    }

    int lm = (1 << n);
    for(int i = 2; i <= lm; i++) pw[i] = pw[i >> 1] + 1;
    f[1][1] = 1;
    for(int s = 1; s < lm; s++) {
        for(int x = 1; x <= n; x++) {
            /// f[x][s]
            if(!f[x][s]) continue;
            //printf("f %d ", x); out(s); printf(" = %d 
", f[x][s]);
            for(int i = e[x]; i; i = edge[i].nex) {
                int y = edge[i].v;
                if((s >> (y - 1)) & 1) {
                    continue;
                }
                (f[y][s | (1 << (y - 1))] += f[x][s]) %= MO;
            }
        }
    }
    int ans = 0;
    for(int i = e[1]; i; i = edge[i].nex) {
        int y = edge[i].v;
        ans = (ans + f[y][lm - 1]) % MO;
    }
    printf("%lld
", 1ll * ans * (MO + 1) / 2 % MO);
    return 0;
}

接下来说说K > 1的部分：