Solution -「CF 1480G」Clusterization Counting

$\mathcal{Description}$

  Link.

  给定一个 $n$ 阶完全图，边权为 $1\sim\frac{n(n-1)}2$ 的排列。称一种将点集划分为 $k$ 组的方案合法，当且仅当对于每个组，与其他组相连的边均大于组内的边。对于 $k\in[1,n]$，求合法的划分方案数，对 $998244353$ 取模。

  $n\le1500$。

$\mathcal{Solution}$

  按边权从小到大加入边，发现原图中某个团可以成为一组，当且仅当存在加边过程中的某个时刻，该团 $(a)$ 已存在（$m$ 个点间已有 $\frac{m(m-1)}2$ 条边），$(b)$ 不与其他任何结点邻接。考虑加边过程中维护一个并查集和链表，对于边 $(u,v)$，令其并查集的根为 $x,y$，若 $x=y$ 则跳过；否则把 $y$ 的链表接在 $x$ 的一端，最后 $y\leftarrow x$。不难发现一个团满足 $(b)$ 等价于它的结点是链表上连续的一段区间。

  接下来判断条件 $(a)$，重新加一次边，并查集维护连通块内边数和链表上最左右端的位置，一次合并发现成团就连一条边 $(l,r)$，表示区间 $[l,r]$ 内的结点独立成组合法。注意到合法团的点集要不不交，要不包含，所以至多有 $2n-1$ 个合法团（此时合法团的包含关系构成完全二叉树）。

  最后就 DP 了，$f(i,j)$ 表示前 $i$ 个位置分成 $j$ 段的方案数，利用判断 $(a)$ 时连出的边转移即可。总复杂度 $\mathcal O(n^2)$。

$\mathcal{Code}$

#include <cstdio>
#include <vector>
#include <assert.h>

inline int rint () {
	int x = 0; char s = getchar ();
	for ( ; s < '0' || '9' < s; s = getchar () );
	for ( ; '0' <= s && s <= '9'; s = getchar () ) x = x * 10 + ( s ^ '0' );
	return x;
}

inline void wint ( const int x ) {
	if ( 9 < x ) wint ( x / 10 );
	putchar ( x % 10 ^ '0' );
}

const int MAXN = 1500, MAXE = MAXN * ( MAXN - 1 ) >> 1, MOD = 998244353;
int n, e, fa[MAXN + 5], fir[MAXN + 5], las[MAXN + 5], nxt[MAXN + 5];
int siz[MAXN + 5], ecnt[MAXN + 5], id[MAXN + 5], f[MAXN + 5][MAXN + 5];
bool nbeg[MAXN + 5];
std::vector<int> trans[MAXN + 5];
std::pair<int, int> ref[MAXE + 5];

inline void addeq ( int& a, const int b ) {
	( a += b ) < MOD ? 0 : a -= MOD;
}

inline int find ( const int x ) {
	return x ^ fa[x] ? fa[x] = find ( fa[x] ) : x;
}

inline void kLink ( int x, int y ) {
	if ( ( x = find ( x ) ) ^ ( y = find ( y ) ) ) {
		fa[y] = x, fir[x] = fir[y], siz[x] += siz[y], ecnt[x] += ecnt[y];
	}
	if ( ++ ecnt[x] == siz[x] * ( siz[x] - 1 ) >> 1 ) {
		trans[las[x]].push_back ( fir[x] );
	}
}

int main () {
	n = rint (), e = n * ( n - 1 ) >> 1;
	for ( int i = 1; i <= n; ++ i ) {
		fa[i] = fir[i] = las[i] = i;
		for ( int j = 1; j <= n; ++ j ) {
			int id = rint ();
			if ( i < j ) ref[id] = { i, j }; 
		}
	}
	for ( int i = 1; i <= e; ++ i ) {
		int u = find ( ref[i].first ), v = find ( ref[i].second );
		if ( u == v ) continue;
		nxt[las[u]] = fir[v], las[u] = las[v];
		las[v] = fir[v] = -1, fa[v] = u;
	}
	int cnt = 0;
	for ( int i = 1; i <= n; ++ i ) nbeg[nxt[i]] = true;
	for ( int i = 1; i <= n; ++ i ) if ( !nbeg[i] ) id[cnt = 1] = i;
	assert ( cnt );
	for ( int p = id[1]; cnt ++ < n; ) id[cnt] = p = nxt[p];
	for ( int i = 1; i <= n; ++ i ) {
		fa[i] = fir[id[i]] = las[id[i]] = i;
		ecnt[i] = 0, siz[i] = 1;
		trans[i].push_back ( i );
	}
	for ( int i = 1; i <= e; ++ i ) kLink ( ref[i].first, ref[i].second );	
	f[0][0] = 1;
	for ( int i = 0; i < n; ++ i ) {
		for ( int j = 0, cur; j <= i; ++ j ) {
			if ( !( cur = f[i][j] ) ) continue;
			for ( int k: trans[i + 1] ) {
				addeq ( f[k][j + 1], cur );
			}
		}
	}
	for ( int i = 1; i <= n; ++ i ) {
		wint ( f[n][i] );
		putchar ( i ^ n ? ' ' : '\n' );
	}
	return 0;
}

$\mathcal{Details}$

  还有一种转化成 Kruskal 重构树上 DP 的方法可以去 % 一下 @crashed 的博客。

  这个算法居然比她的慢几倍 qwq。