CF11D A Simple Task

CF11D A Simple Task - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

数据范围容易让人想到状压 dp，状压对象为点集。

现有一条点集为 $S$ 的路径。目标是路径成环，所以转移时需要路径的开头和结尾两个信息。

可以想到：$f(S, u, v)$ 表示从 $u$ 到 $v$ 经过的点集为 $S$ 的路径数量。

但是这样一来，每个长度为 $L$ 的环会被统计 $2L$ 次（每个点为起点，顺时针或逆时针走向）。为了避免重复，在每次统计答案 $f(S, u, u)$ 的时候我们需要除以 $L$，即 $\operatorname{popcnt}(S)$。这里就会涉及到浮点数的计算，所以 $f$ 必须用浮点类型存，但是浮点类型无法在 250MB 内存储一个大小为 $n^2 \times 2^n$ 的数组。

怎么办？考虑优化状态：$f(S, u)$ 表示从 $\operatorname{lowbit}(S)$ 到 $u$ 经过的点集为 $S$ 的路径数量。

这样一来，每个长度为 $L$ 的环只会被该环中编号最小的节点统计 $2$ 次（顺时针或逆时针走向）。$2$ 是一个常数，因此我们直接统计 $f$，最后除以 $2$ 即可。这样以来 $f$ 被优化成了一个 $n \times 2^n$ 的整数数组，可以通过。

换句话说，我们只统计满足这个条件的路径：开头是 $s$，那么之后经过的点都比 $s$ 编号要大。

转移是显然的：$f(S \cup \{v\}, v) \gets f(S \cup \{v\}, v) + f(S, u)[(u, v) \in G]$。

最后，我们发现长度为 $2$ 的“环”也会被统计。注意，长度为 $2$ 的环只会被统计 $1$ 次而不是 $2$ 次，因为顺时针和逆时针走向实际上是一样的。

这里有两种方案：

• 只统计 $\operatorname{popcnt}(S) \ge 3$ 的 $f(S, \operatorname{lowbit}(S))$，设和为 $sum$，则答案为 $\dfrac{sum}{2}$；
• 都统计，设和为 $sum$，则答案为 $\dfrac{sum - m}{2}$。

第二种实现比较简单。

时间复杂度 $\mathcal{O}(n^2 \times 2^n)$。

/*
 * @Author: crab-in-the-northeast 
 * @Date: 2022-10-19 19:45:25 
 * @Last Modified by: crab-in-the-northeast
 * @Last Modified time: 2022-10-19 20:59:00
 */
#include <bits/stdc++.h>
#define int long long
inline int read() {
    int x = 0;
    bool flag = true;
    char ch = getchar();
    while (!isdigit(ch)) {
        if (ch == '-')
            flag = false;
        ch = getchar();
    }
    while (isdigit(ch)) {
        x = (x << 1) + (x << 3) + ch - '0';
        ch = getchar();
    }
    if(flag)
        return x;
    return ~(x - 1);
}

const int maxn = 20;
int f[1LL << maxn][maxn];
bool a[maxn][maxn];

signed main() {
    int n = read(), m = read();
    for (int i = 1; i <= m; ++i) {
        int u = read() - 1, v = read() - 1;
        a[u][v] = a[v][u] = true;
    }

    int N = (1LL << n);
    for (int u = 0; u < n; ++u)
        f[1LL << u][u] = 1;
    
    int ans = 0;

    for (int S = 0; S < N; ++S) {
        int s = (S & (-S));
        for (int u = 0; u < n; ++u) {
            for (int v = 0; v < n; ++v) if (a[u][v]) {
                if ((1LL << v) < s)
                    continue;
                if (S & (1LL << v)) {
                    if ((1LL << v) == s)
                        ans += f[S][u];
                } else
                    f[S | (1LL << v)][v] += f[S][u];
            }
        }
    }

    printf("%lld\n", (ans - m) >> 1LL);
    return 0;
}