Solution -「UR #21」「UOJ #632」挑战最大团

\(\mathcal{Description}\)

  Link.

  对于简单无向图 \(G=(V,E)\)，定义它是“优美”的，当且仅当

\[\forall\{a,b,c,d\}\sube V,((a,b),(b,c),(c,d)\in E)\Rightarrow(a,c)\in E\lor(b,d)\in E\lor(a,d)\in E
\]

  给定一个“优美”的简单无向图 \(G\)，对于所有 \(i\in[1,n]\)，求有多少个 \(S\sube V\)，\(|S|=i\) 且 \(S\) 的导出子图是完全图。

\(\mathcal{Solution}\)

  直接做铁铁的 NPC，必须从“优美”的性质入手分析。

  性质一，\(G\) 的直径不超过 \(2\)。由定义显然。

  性质二，记 \(G\) 的补图为 \(\overline{G}\)，则 \(G\) 与 \(\overline{G}\) 不同时连通。证明如下：

  归纳，当点集 \(|V|=2\) 时，显然成立。若当 \(|V|<n\) 时命题成立，并假设当 \(|V|=n\) 时命题不成立：

  取任意 \(u\in V\)，由于命题不成立，故在 \(G\) 或是 \(\overline{G}\) 中，\(u\) 都至少有一条连入点集 \(V\setminus\{u\}\) 的边。设点集 \(V\setminus\{u\}\) 的导出子图为 \(G'\)，补图为 \(\overline{G'}\)，由于 \(|V|\setminus\{u\}=n-1\)，由归纳，\(G'\) 与 \(\overline{G'}\) 不同时连通。

  不妨设 \(G'\) 不连通，则令其极大连通分量为 \(G_1,G_2,\cdots,G_k~(k>1)\)。由于 \(u\) 在 \(\overline{G}\) 中右边，所以必然存在 \(t\in G_i\)，使得 \((u,t)\not\in E\)。接着研究这个 \(G_i\)，设其点集为 \(V_i\)，并令 \(S=\{v\in V_i~|~(u,v)\in E\},T=V_i\setminus S\)。由于假设有 \(G\) 连通，所以 \(|S|,|T|>0\)。任取 \(v\in S\)，因为 \(G_i\) 连通，故存在 \(w\in T\)，使得 \((v,w)\in E\)，最后，再取任意 \(x\in G_j~(j\not=i)\) 使得 \((u,x)\in E\)。考虑点集 \(\{x,u,v,w\}\)：

• \((x,u),(u,v),(v,w)\in E\)；
• \((x,v),(u,w),(x,w)\not\in E\)。

故该图不合条件，假设不成立，原命题成立。

  利用“不连通”带来的子问题结构，我们分别考虑原问题在原图与补图的体现：

• 对于原图，假设其由 \(G_1,G_2,\cdots,G_k~(k>1)\) 组成，设 \(F(G)\) 为图 \(G\) 的答案 OGF，显然有

  \[F(G)=\sum_{i=1}^kF(G_i)
  \]

• 对于补图，假设其由 \(\overline{G_1},\overline{G_2},\cdots,\overline{G_k}~(k>1)\) 组成，设 \(\overline{F}(\overline{G})\) 为图 \(\overline{G}\) 中独立集数量关于其大小的 OGF，就有

  \[\overline{F}(\overline{G})=\prod_{i=1}^k\overline{F}(\overline{G_i})
  \]

  而显然 \(F(G)=\overline{F}(\overline{G})\)，所以我们确实可以分治求解。

  但是，本题的难点在于构造分治结构，即确定当前层是按原图的连通块划分还是补图的连通块划分。一种优秀的策略是：选择 \(G\) 中度数最小的点 \(x\) 和度数最大（即 \(\overline{G}\) 中度数最小）的点 \(y\)，以 \(x\) 为源点在 \(G\) 中，\(y\) 为源点在 \(\overline{G}\) 中分别 BFS：先扩展一层，然后交替扩展第二层（最多两层）直到能够判断某点所在连通块 是/不是 整个图。此后，利用不连通的一个点 BFS 得到的标记数组进行连通块划分，递归建图。

  考虑复杂度，瓶颈在于第二层搜索，设 \(x,y\) 的度数大小分别是 \(d_x,d_y\)，复杂度上界即是 \(\mathcal O(d_xm+d_ym)\)，其中 \(m\) 为当前图的点集大小。记被分离的连通块大小为 \(s\)，那么这一上界必然不超过 \(\mathcal O(sm)\)。为方便复杂度分析，设留下部分大小为 \(t\)，有 \(s\le t\)，故 \(sm=s^2+st=\mathcal O(st)\)。考虑分治树所描述的事件：初始时有 \(n\) 个点，每次将剩下的点分为 \(x,y\) 两部分，代价为 \(xy\)，再递归处理 \(x\) 和 \(y\)。则树上每两片叶子在 LCA 处贡献复杂度一次，总复杂度 \(\mathcal O(n^2)\)。

\(\mathcal{Code}\)

/* Clearink */

#include <cstdio>
#include <vector>

#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 )

typedef std::pair<int, int> PII;
#define fi first
#define se second
#define getv( c ) ( '0' <= c && c <= '9' ? c ^ '0' : 10 + c - 'A' )

const int MAXN = 8e3, MOD = 998244353;
int n, node;
bool e[MAXN + 5][MAXN + 5], side[MAXN * 2 + 5];
std::vector<int> son[MAXN * 2 + 5];

inline int imin( const int a, const int b ) { return a < b ? a : b; }
inline int imax( const int a, const int b ) { return a < b ? b : a; }
inline void addeq( int& a, const int b ) { ( a += b ) >= MOD && ( a -= MOD ); }
inline int mul( const long long a, const int b ) { return int( a * b % MOD ); }

inline int build( const std::vector<PII>& vec, const bool curs ) {
	int o = ++node;
	if ( vec.size() == 1 ) return side[o] = curs, o;

	static int vis[2][MAXN + 5], que[2][MAXN + 5];

	int n = int( vec.size() ), s[2] = {};
	rep ( i, 1, n - 1 ) {
		if ( vec[i].se < vec[s[0]].se ) s[0] = i;
		if ( vec[i].se > vec[s[1]].se ) s[1] = i;
	}
	s[0] = vec[s[0]].fi, s[1] = vec[s[1]].fi;
	vis[0][s[0]] = vis[1][s[1]] = true;

	int sz[2] = {};
	rep ( sd, 0, 1 ) for ( PII u: vec ) {
		if ( !vis[sd][u.fi] && e[s[sd]][u.fi] ^ curs ^ sd ) {
			vis[sd][que[sd][++sz[sd]] = u.fi] = true;
		}
	}

	int ex[2] = { sz[0], sz[1] };
	bool divs;
	rep ( i, 0, imax( sz[0], sz[1] ) ) {
		if ( i ) rep ( sd, 0, 1 ) if ( i <= sz[sd] ) {
			int u = que[sd][i];
			for ( PII v: vec ) {
				if ( !vis[sd][v.fi] && e[u][v.fi] ^ curs ^ sd ) {
					vis[sd][que[sd][++ex[sd]] = v.fi] = true;
				}
			}
		}

		if ( i == imin( sz[0], sz[1] ) ) {
			if ( ex[0] == n ) divs = curs;
			else if ( ex[1] == n ) divs = !curs;
			else { divs = curs ^ ( sz[0] < sz[1] ); break; }
		}
	}

	side[o] = divs;
	std::vector<PII> sub[2];
	if ( divs == curs ) {
		for ( PII u: vec ) {
			sub[!vis[1][u.fi]].push_back( { u.fi, n - u.se - 1 } );
			vis[0][u.fi] = vis[1][u.fi] = false;
		}
		for ( PII& u: sub[0] ) for ( PII& v: sub[1] ) {
			if ( e[u.fi][v.fi] ^ curs ^ 1 ) {
				--u.se, --v.se;
			}
		}
	} else {
		for ( PII u: vec ) {
			sub[!vis[0][u.fi]].push_back( u );
			vis[0][u.fi] = vis[1][u.fi] = false;
		}
	}
	int lc = build( sub[0], !divs ), rc = build( sub[1], !divs );
	if ( side[rc] == divs ) son[o] = son[rc];
	else son[o].push_back( rc );
	son[o].push_back( lc );
	return o;
}

int f[MAXN * 2 + 5][MAXN + 5], siz[MAXN + 5];

inline void solve( const int u ) {
	static int tmp[MAXN + 5];

	if ( son[u].empty() ) return void( f[u][0] = f[u][1] = siz[u] = 1 );

	f[u][0] = 1;
	for ( int v: son[u] ) {
		solve( v );
		if ( !side[u] ) { // IG merge.
			rep ( i, 0, siz[u] ) rep ( j, 0, siz[v] ) {
				addeq( tmp[i + j], mul( f[u][i], f[v][j] ) );
			}
			rep ( i, 0, siz[u] += siz[v] ) f[u][i] = tmp[i], tmp[i] = 0;
		} else { // G merge.
			rep ( i, 1, siz[u] = imax( siz[u], siz[v] ) ) {
				addeq( f[u][i], f[v][i] );
			}
		}
	}
}

int main() {
	scanf( "%d", &n );
	rep ( i, 1, n - 1 ) {
		static char str[MAXN + 5];
		scanf( "%s", str );
		rep ( j, 0, n - i - 1 ) {
			e[i][i + j + 1] = e[i + j + 1][i] =
				getv( str[j >> 2] ) >> ( j & 3 ) & 1;
		}
	}
	std::vector<PII> oriv; oriv.resize( n );
	rep ( i, 1, n ) {
		int d = 0;
		rep ( j, 1, n ) d += e[i][j];
		oriv[i - 1] = { i, d };
	}

	int rt = build( oriv, false );
	solve( rt );

	rep ( i, 1, n ) printf( "%d%c", f[rt][i], i < n ? ' ' : '\n' );
	return 0;
}