[ABC213G] Connectivity 2 题解

[ABC213G] Connectivity 2 Solution

目录

• [ABC213G] Connectivity 2 Solution
  • 更好的阅读体验戳此进入
  • 题面
  • Solution
  • Code
  • UPD

更好的阅读体验戳此进入

题面

给定 $n$ 个点 $m$ 条边的简单无向图，考虑删去其中大于 $0$ 条边构成新图，显然共有 $2^m$ 张新图。求对于每个点 $k\in [2,n]$ 有多少张新图满足 $k$ 点和 $1$ 点连通。对 $998244353$ 取模。

Solution

对于 FZT（子集计数）的更具体说明可以参考 FZT - 子集计数学习笔记。

考虑 FZT，显然令 $S$ 为二进制状态，表示某个点是否钦定。

令 $F(S)$ 表示点集为 $S$ 中的点互相连通的方案数。令 $G(S)$ 表示点集为 $S$ 可以产生的子图数量。

不难想到，若 $cn{t}_S$ 表示点集为 $S$ 中的点之间有多少条边，则 $G(S)=2^{cn{t}_S}$，不难想到这个的预处理复杂度为 $O(m{2}^n)$，可以接受。

考虑如何转移 $F$，不难想到（错误的）转移为：

$$F(S)=G(S)-\sum _{T⊊S}F(T)\times G(S\oplus T)$$

可以尝试理解一下这个转移，我们要保证 $S$ 连通，那么可以考虑在所有的方案数 $G(S)$ 中枚举减去不合法的，为了不漏，不难想到枚举每个 $S$ 的真子集 $T$，然后让 $T$ 和 $S$ 中除去 $T$ 以外的部分之间不连通。为了不重，所以我们要钦定 $T$ 连通，此时 $S$ 里 $T$ 的补集，也就是 $S\oplus T$，其中的边是否存在都可以，也就是 $G(S\oplus T)$。将两者乘起来即可，此时即保证了不漏。枚举子集及其子集的复杂度和一般枚举子集复杂度相同，为 $O(3^n)$，可以接受。

然后发现，这个东西是假的。不难想到，假设我们考虑一个将 $S$ 分为几个连通块的方案，如果按照我们刚才的方案的话，钦定一个连通块之后，枚举剩下的所有方案时一定会包含了钦定其它连通块，会重复。考虑如何去重，不难想到我们只需要钦定一个点在枚举子集的时候必须被选中，这样对于多个连通块的情况就等于是我们钦定只选择该点所在区间为必须连通的，这样即可保证不重。当然这个点的选择是任意的，可以直接钦定为 $1$。

于是转移优化为：

$$F(S)=G(S)-\sum _{1\in T⊊S}F(T)\times G(S\oplus T)$$

然后因为我们要保证 $1$ 一定存在，所以可以不枚举第一位，复杂度可以少一个 $3$。也可以正常枚举，然后计算答案的时候去掉所有 $1$ 对应的状态为 $0$ 的即可。这样的复杂度也是 $1e8$ 级别，可以接受，且更易于实现。

同时不难对于初始值，存在 $F(0)=G(0)=1$，也就是所有点都不选的时候认为所有边都不选也是一种方案。

然后考虑答案，不难想到，对于点 $i$ 的答案 $an{s}_i$，令 $S=2^n-1$，也就是全集，显然有：

$$an{s}_i=\sum _{T\subseteq S}F(T)\times G(S\oplus T)\times [T\wedge 2^{i-1}]\times [T\wedge 1]$$

然后这个求解的复杂度为 $O(n{2}^n)$。

最终复杂度为 $O((m+n)2^n+3^n)$，卡的比较满，但是有三秒，显然可以通过。

Tips：对于枚举子集的过程应该不用多说，令 $Smx$ 为全集，一般为 $Smx=2^n-1$，然后枚举的过程就是 for(int S = Smx; S; S = (S - 1) & Smx)，具体证明这里不再赘述，可以网上直接搜一下。

Tips：然后关于前面说的枚举子集和子集的子集的复杂度，这个东西用组合数写一下不难证明，总之枚举 $2^n$ 状态的子集是 $O(3^n)$ 的，枚举子集套娃的复杂度可以证明枚举 $k$ 次子集的复杂度是 $(k+1{)}^n$，本题即为 $O(3^n)$。

Code

#define _USE_MATH_DEFINES
#include <bits/stdc++.h>

#define PI M_PI
#define E M_E
#define npt nullptr
#define SON i->to
#define OPNEW void* operator new(size_t)
#define ROPNEW(arr) void* Edge::operator new(size_t){static Edge* P = arr; return P++;}

using namespace std;

mt19937 rnd(random_device{}());
int rndd(int l, int r){return rnd() % (r - l + 1) + l;}
bool rnddd(int x){return rndd(1, 100) <= x;}

typedef unsigned int uint;
typedef unsigned long long unll;
typedef long long ll;
typedef long double ld;

#define MOD (ll)(998244353ll)
#define MAX_STATUS (150000)
#define EXIST(x) (S & (1 << ((x) - 1)))

template < typename T = int >
inline T read(void);

int N, M;
struct Edge{
    Edge* nxt;
    int to;
    OPNEW;
}ed[2100];
ROPNEW(ed);
Edge* head[20];
ll F[MAX_STATUS], G[MAX_STATUS];
ll pow2[500];
ll ans[20];

int main(){
    pow2[0] = 1;
    for(int i = 1; i <= 300; ++i)pow2[i] = pow2[i - 1] * 2 % MOD;
    N = read(), M = read();
    const int Smx = (1 << N) - 1;
    for(int i = 1; i <= M; ++i){
        int s = read(), t = read();
        head[s] = new Edge{head[s], t};
    }F[0] = G[0] = 1;
    for(int S = Smx; S; S = (S - 1) & Smx){
        int cnt(0);
        for(int p = 1; p <= N; ++p)
            if(EXIST(p))
                for(auto i = head[p]; i; i = i->nxt)
                    if(EXIST(SON))++cnt;
        G[S] = pow2[cnt];
    }
    for(int S = 1; S <= Smx; ++S){
        for(int T = (S - 1) & S; T; T = (T - 1) & S)
            if(T & 1)
                (F[S] += F[T] * G[S ^ T] % MOD) %= MOD;
        F[S] = (G[S] - F[S] + MOD) % MOD;
    }
    for(int i = 2; i <= N; ++i)
        for(int S = Smx; S; S = (S - 1) & Smx)
            if(EXIST(i) && EXIST(1))(ans[i] += F[S] * G[S ^ Smx] % MOD) %= MOD;
    for(int i = 2; i <= N; ++i)printf("%lld\n", ans[i]);
    // for(int S = Smx; S; S = (S - 1) & Smx)
    //     cout << "G[" << bitset < 6 >(S) << "] = " << G[S] << ", F = " << F[S] << endl;
    fprintf(stderr, "Time: %.6lf\n", (double)clock() / CLOCKS_PER_SEC);
    return 0;
}

template < typename T >
inline T read(void){
    T ret(0);
    int flag(1);
    char c = getchar();
    while(c != '-' && !isdigit(c))c = getchar();
    if(c == '-')flag = -1, c = getchar();
    while(isdigit(c)){
        ret *= 10;
        ret += int(c - '0');
        c = getchar();
    }
    ret *= flag;
    return ret;
}

UPD

update-2022_12_05 初稿