Solution -「BZOJ 3812」主旋律

\(\mathcal{Description}\)

  Link.

  给定含 \(n\) 个点 \(m\) 条边的简单有向图 \(G=(V,E)\)，求 \(H=(V,E'\subseteq E)\) 的数量，使得 \(H\) 是强连通图。答案模 \((10^9+7)\)。

  \(n\le15\)。

\(\mathcal{Solution}\)

  仙气十足的状压容斥。

  令 \(f(S)\) 表示仅考虑点集 \(S\) 的导出子图时，使得 \(S\) 强连通的选边方案数，那么 \(f(V)\) 就是答案。如何划分出这个状态的阶段性？尝试容斥，设 \(\operatorname{inc}(S)\) 表示 \(S\) 导出子图的边数，首先把 \(f(S)\) 转化成「任意选边方案数 \(2^{\operatorname{inc}(S)}\)」减去「至少有两个极大强连通分量的方案数」。

  此时，后者具有阶段性：如果把极大强连通分量缩点，那么后者就是在对点数大于 \(1\) 的 DAG 计数。由 DAG 本身入手，自然想到每次考虑 DAG 上出度为 \(0\) 的点集。还是容斥计数，令 \(g(S)\) 表示在 \(S\) 的导出子图中，将 \(S\) 分为若干个互不邻接的强连通分量的带容斥系数的选边方案数。其中含奇数个强连通分量的方案容斥系数为 \(-1\)，否则为 \(+1\)。对于 \(g(S)\) 本身，钦定特殊点 \(x\in S\)，可以得到转移

\[g(S)=-\sum_{T\subseteq S,x\in T}f(T)g(S\setminus T). \]

而对于 \(f(S)\)，枚举「DAG 上至少有 \(k\) 个出度为 \(0\) 的点」以求出「至少有两个极大强连通分量的方案数」，最终得到转移

\[f(S)=2^{\operatorname{inc}(S)}+\sum_{T\subseteq S,T\not=\varnothing}2^{\operatorname{inc}(S\setminus T)+\operatorname{out}(S\setminus T,T)}g(T). \]

其中 \(\operatorname{out}(S,T)\) 表示满足 \(u\in S,v\in T\) 的有向边 \(\lang u,v\rang\) 的数量。但是特别注意，\(f(S)\) 和 \(g(S)\) 看似存在互相转移，实际上 \(f(S)\) 中的和式本身是求非法方案，所以当其中 \(T=S\) 时，应令此时 \(g(T)\) 的值为 \([g(S)+f(S)]\)（带容斥系数，本身是减，用加抵消），这样满足实际意义，且不存在互相转移了。

  最终复杂度为 \(\mathcal O(3^n+m2^n)\)，注意求 \(\operatorname{out}\) 的时空效率。

\(\mathcal{Code}\)

/*~Rainybunny~*/

#include <cstdio>
#include <unordered_map>

#define rep( i, l, r ) for ( int i = l, rep##i = r; i <= rep##i; ++i )
#define per( i, r, l ) for ( int i = r, per##i = l; i >= per##i; --i )

const int MAXN = 15, MAXM = MAXN * ( MAXN - 1 ), MOD = 1e9 + 7;
int n, m, pwr[MAXM + 5];
int inc[1 << MAXN], f[1 << MAXN], g[1 << MAXN];
int in[MAXN + 5][1 << MAXN], out[MAXN + 5][1 << MAXN];
int sout[1 << MAXN], bitw[1 << MAXN];

inline void subeq( int& a, const int b ) { ( a -= b ) < 0 && ( a += MOD ); }
inline int sub( int a, const int b ) { return ( a -= b ) < 0 ? a + MOD : a; }
inline int add( int a, const int b ) { return ( a += b ) < MOD ? a : a - MOD; }
inline void addeq( int& a, const int b ) { ( a += b ) >= MOD && ( a -= MOD ); }
inline int mul( const int a, const int b ) { return int( 1ll * a * b % MOD ); }

int main() {
	scanf( "%d %d", &n, &m ), pwr[0] = 1;
	rep ( i, 1, m ) {
		pwr[i] = add( pwr[i - 1], pwr[i - 1] );
		int s, t; scanf( "%d %d", &s, &t ), --s, --t;
		rep ( S, 0, ( 1 << n ) - 1 ) {
			inc[S] += S >> s & 1 && S >> t & 1;
			out[s][S] += S >> t & 1, in[t][S] += S >> s & 1;
		}
	}
	
	rep ( S, 1, ( 1 << n ) - 1 ) {
		if ( S > 1 ) bitw[S] = bitw[S >> 1] + 1;
		for ( int T = S & ( S - 1 ); T; T = ( T - 1 ) & S ) {
			int v = ( S ^ T ) & -( S ^ T );
			sout[T] = sout[T | v] - out[bitw[v]][S ^ T] + in[bitw[v]][T];
		}
		
		int &curf = f[S] = pwr[inc[S]], &curg = g[S];
		for ( int T = S & ( S - 1 ); T; T = ( T - 1 ) & S ) if ( T & S & -S ) {
			subeq( curg, mul( f[T], g[S ^ T] ) );
		}
		for ( int T = S; T; T = ( T - 1 ) & S ) {
			addeq( curf, mul( pwr[inc[S ^ T] + sout[S ^ T]], g[T] ) );
		}
		subeq( curg, curf );
	}
	printf( "%d\n", f[( 1 << n ) - 1] );
	return 0;
}