noi.ac #31 MST / 记忆碎片 社论

MST / 记忆碎片

一个 $n$ 个点的有标号带权无向图 $G$，边权均为介于 $\left[1,\dfrac{n(n-1)}2\right]$ 间的整数 . 给定 MST 上所有边的边权，问原图有多少种本质不同方案，答案对 $10^9+7$ 取模 .

两个方案本质不同当且仅当有一条边边权不同 .

$n\le 40$ .

考虑 Kruskal 求 MST 的过程，我们把树边一条一条加进去，在加下一条之前先把权值在的边都连上，并保证图的连通性不变 .

令 $dp_{i,S}$ 表示添加了 $i$ 条树边目前连通状态为 $S$ 的方案数，不难发现 $S$ 只需要记录一下某个大小的连通块有多少，此外还需要记一下空位数要不然难转移 .

加一条树边的过程就相当于合并两个连通块，我们只需要处理出有哪些本质不同的转移点，这个可以直接暴搜 .

DFS 暴搜就行，不需要 Delov 的高端 BFS，因为我不会 bitset 所以就直接拿数组记录的，然后搜完之后对状态 Hash 一下，用一个 std :: map 记录一下下一个转移点即可 .

转移点处理好了转移过程就分树边和非树边讨论一下转移即可：

• 树边：相当于合并连通块，设目前要合并 $\textsf A,\textsf B$，对应分别有 $c_{\sf A},c_{\sf B}$ 个，大小为 $s_{\sf A},s_{\sf B}$，则：
  $$dp_{i,S}=dp_{i-1,S'}\cdot c_{\sf A}c_{\sf B}s_{\sf A}s_{\sf B}$$

• 非树边：根据基础组合数学可以发现答案就是空位下降幂 .

不同大小的连通块只会有 $\sqrt n$ 个，枚举两个连通块复杂度是 $O(n)$ 的。而需要进行枚举的转移也只有 $n-1$次，又已经加了一些树边之后，图的连通性状态数可以由整数划分表出，所以复杂度大概是 $O(n^2\cdot\operatorname{partition}(n))$ 的，其中 $\operatorname{partition}$ 是分拆数，$\operatorname{partition}(40)=37338$ 十分能过啊 .

或者科学一点可以分析一下分拆数渐进式（声明：我不会），可以看一下《Analytic Combinatorics》.

using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef double db;
typedef pair<int, int> pii;
const int N = 45, _M_ = 37339, base = 1331, P = 1e9+7;
int n, m, a[N], siz[N], fac[N*N], ifac[N*N], Bx[N], id[N][N], ans;
inline int qpow(int a, int n)
{
	int ans = 1;
	while (n)
	{
		if (n & 1) ans = 1ll * ans * a % P;
		a = 1ll * a * a % P; n >>= 1;
	} return ans;
}
inline void initfac(int n)
{
	fac[0] = 1;
	for (int i=1; i<=n; i++) fac[i] = 1ll * i * fac[i-1] % P;
	ifac[n] = qpow(fac[n], P-2);
	for (int i=n-1; i>=0; i--) ifac[i] = 1ll * ifac[i+1] * (i+1) % P;
}
inline int A(int n, int m){return n<m ? 0 : 1ll * fac[n] * ifac[n-m] % P;}
int now, tt[N], B[N], v[N][_M_][N], e[N][_M_], dp[N][_M_];
unordered_map<ull, int> M[N];
void dfs(int b, int st, int lst)
{
	if (lst * (now - st + 1) > b) return ;
	if (st > now)
	{
		ull hash = 0;
		for (int i=1; i<st; i++) hash = hash * base + B[i];
		M[now][hash] = ++tt[now];
		for (int i=1; i<st; i++)
		{
			v[now][tt[now]][i] = B[i];
			e[now][tt[now]] += 1ll * B[i] * (B[i]-1) / 2;
		}
		return ;
	}
	if (st == now){B[st] = b; dfs(0, st+1, 0); return ;}
	for (int i=lst; i<=b; i++){B[st] = i; dfs(b-i, st+1, i);}
}
int main()
{
	scanf("%d", &n); initfac(a[1] = n*(n-1)/2);
	for (int i=n; i>1; i--) scanf("%d", a+i);
	for (int i=1; i<=n; i++){now = i; dfs(n, 1, 1);}
	dp[n][1] = 1;
	for (int i=n; i>1; i--)
		for (int s=1; s<=tt[i]; s++)
		{
			dp[i][s] = 1ll * dp[i][s] * A(e[i][s]-a[i+1], a[i]-a[i+1]-1) % P;
			memset(id, 0, sizeof id);
			for (int j=1; j<=i; j++) B[j] = v[i][s][j];
			for (int u=1; u<=i; u++)
				for (int v=u+1; v<=i; v++)
				{
					if (!id[B[u]][B[v]])
					{
						int top = 0;
						for (int p=1; p<=i; p++)
							if ((p != u) && (p != v)) Bx[++top] = B[p];
						Bx[++top] = B[u] + B[v];
						for (int p=top-1; p; p--) // a part of insertion sort
							if (Bx[p] > Bx[p+1]) swap(Bx[p], Bx[p+1]);
							else break;
						ull hash = 0;
						for (int p=1; p<=top; p++) hash = hash * base + Bx[p];
						id[B[u]][B[v]] = M[i-1][hash];
					}
					(dp[i-1][id[B[u]][B[v]]] += 1ll * dp[i][s] * B[u] % P * B[v] % P) %= P;
				}
		}
	printf("%d\n", dp[1][1] = 1ll * dp[1][1] * A(e[1][1] - a[2], a[1] - a[2] - 1) % P);
	return 0;
}

好像目前 hszxoj 里 T1 T4 我都是最优解（时间），谁来写一份高效的代码啊？话说直接贺我代码的都没我跑得快