生成树计数--矩阵树定理（Matrix-Tree定理）
在信息学竞赛中，有关生成树的最优化问题如最小生成树等是我们经常遇到的，而对生成树的计数及其相关问题则少有涉及。事实上，生成树的计数是十分有意义的，在许多方面都有着广泛的应用。本文从一道信息学竞赛中出现的例题谈起，首先介绍了一种指数级的动态规划算法，然后介绍了行列式的基本概念、性质，并在此基础上引入Matrix-Tree定理，同时通过与一道数学问题的对比，揭示了该定理所包含的数学思想。最后通过几道例题介绍了生成树的计数在信息学竞赛中的应用，并进行总结。
关键字
生成树的计数 Matrix-Tree定理
问题的提出
[例一]高速公路（SPOJ p104 Highways）
一个有n座城市的组成国家，城市1至n编号，其中一些城市之间可以修建高速公路。现在，需要有选择的修建一些高速公路，从而组成一个交通网络。你的任务是计算有多少种方案，使得任意两座城市之间恰好只有一条路径？
数据规模：1≤n≤12。
[分析]
我们可以将问题转化到成图论模型。因为任意两点之间恰好只有一条路径，所以我们知道最后得到的是原图的一颗生成树。因此，我们的问题就变成了，给定一个无向图G，求它生成树的个数t(G)。这应该怎么做呢？
经过分析，我们可以得到一个时间复杂度为O(3n*n2)的动态规划算法，因为原题的规模较小，可以满足要求。但是，当n再大一些就不行了，有没有更优秀的算法呢？答案是肯定的。在介绍算法之前，首先让我们来学习一些基本的预备知识。
新的方法
介绍
下面我们介绍一种新的方法——Matrix-Tree定理(Kirchhoff矩阵-树定理)。Matrix-Tree定理是解决生成树计数问题最有力的武器之一。它首先于1847年被Kirchhoff证明。在介绍定理之前，我们首先明确几个概念：
1、G的度数矩阵D[G]是一个n*n的矩阵，并且满足：当i≠j时,dij=0；当i=j时，dij等于vi的度数。
2、G的邻接矩阵A[G]也是一个n*n的矩阵， 并且满足：如果vi、vj之间有边直接相连，则aij=1，否则为0。
我们定义G的Kirchhoff矩阵(也称为拉普拉斯算子)C[G]为C[G]=D[G]-A[G]，则Matrix-Tree定理可以描述为：G的所有不同的生成树的个数等于其Kirchhoff矩阵C[G]任何一个n-1阶主子式的行列式的绝对值。所谓n-1阶主子式，就是对于r(1≤r≤n)，将C[G]的第r行、第r列同时去掉后得到的新矩阵，用Cr[G]表示。
其实就是一个模板而已
<pre name="code" class="cpp">#include<iostream>
#include<math.h>
#include<stdio.h>
#include<string.h>
using namespace std;
#define zero(x) ((x>0? x:-x)<1e-15)
int const MAXN = 100;
double a[MAXN][MAXN];
double b[MAXN][MAXN];
int g[53][53];
int n,m;
double det(double a[MAXN][MAXN],int n) {
int i, j, k, sign = 0;
double ret = 1, t;
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
b[i][j] = a[i][j];
for (i = 0; i < n; i++) {
if (zero(b[i][i])) {
for (j = i + 1; j < n; j++)
if (!zero(b[j][i]))
break;
if (j == n)
return 0;
for (k = i; k < n; k++)
t = b[i][k], b[i][k] = b[j][k], b[j][k] = t;
sign++;
}
ret *= b[i][i];
for (k = i + 1; k < n; k++)
b[i][k] /= b[i][i];
for (j = i + 1; j < n; j++)
for (k = i + 1; k < n; k++)
b[j][k] -= b[j][i] * b[i][k];
}
if (sign & 1)
ret = -ret;
return ret;
}
void build(){
while (m--) {
int a, b;
scanf("%d%d", &a, &b);
g[a-1][b-1]=g[b-1][a-1]=1;
}
}
int main() {
int cas;
scanf("%d", &cas);
while (cas--) {
scanf("%d%d", &n, &m);
memset(g,0,sizeof(g));
build();
memset(a,0,sizeof(a));
for (int i=0;i<n;i++) {
int d=0;
for (int j=0;j<n;j++)
if (g[i][j])
d++;
a[i][i]=d;
}
for (int i=0;i<n;i++)
for (int j=0;j<n;j++)
if (g[i][j])
a[i][j]=-1;
double ans = det(a, n-1);
printf("%0.0lf\n", ans);
}
return 0;
} 最小生成树计数
/*
*算法引入：
*给定一个含有N个结点M条边的无向图,求它最小生成树的个数t(G);
*
*算法思想：
*抛开“最小”的限制不看,如果只要求求出所有生成树的个数,是可以利用Matrix-Tree定理解决的;
*Matrix-Tree定理此定理利用图的Kirchhoff矩阵,可以在O(N3)时间内求出生成树的个数;
*
*kruskal算法：
*将图G={V,E}中的所有边按照长度由小到大进行排序,等长的边可以按照任意顺序;
*初始化图G’为{V,Ø},从前向后扫描排序后的边,如果扫描到的边e在G’中连接了两个相异的连通块,则将它插入G’中;
*最后得到的图G’就是图G的最小生成树;
*
*由于kruskal按照任意顺序对等长的边进行排序,则应该将所有长度为L0的边的处理当作一个阶段来整体看待;
*令kruskal处理完这一个阶段后得到的图为G0,如果按照不同的顺序对等长的边进行排序,得到的G0也是不同;
*虽然G0可以随排序方式的不同而不同,但它们的连通性都是一样的,都和F0的连通性相同(F0表示插入所有长度为L0的边后形成的图);
*
*在kruskal算法中的任意时刻,并不需要关注G’的具体形态,而只要关注各个点的连通性如何(一般是用并查集表示);
*所以只要在扫描进行完第一阶段后点的连通性和F0相同,且是通过最小代价到达这一状态的,接下去都能找到最小生成树;
*
*经过上面的分析,可以看出第一个阶段和后面的工作是完全独立的;
*第一阶段需要完成的任务是使G0的连通性和F0一样,且只能使用最小的代价;
*计算出这一阶段的方案数,再乘上完成后续事情的方案数,就是最终答案;
*
*由于在第一个阶段中,选出的边数是一定的,所有边的长又都为L0;
*所以无论第一个阶段如何进行代价都是一样的,那么只需要计算方案数就行了;
*此时Matrix-Tree定理就可以派上用场了,只需对F0中的每一个连通块求生成树个数再相乘即可;
*
*Matrix-Tree定理:
*G的所有不同的生成树的个数等于其Kirchhoff矩阵C[G]任何一个n-1阶主子式的行列式的绝对值；
*n-1阶主子式就是对于r(1≤r≤n),将C[G]的第r行,第r列同时去掉后得到的新矩阵,用Cr[G]表示;
*
*算法举例：
*HDU4408(Minimum Spanning Tree)
*
*题目地址：
*http://acm.hdu.edu.cn/showproblem.php?pid=4408
*
*题目大意：
*给定一个含有N个结点M条边的无向图,求它最小生成树的个数,所得结果对p取模;
**/
#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<queue>
#include<algorithm>
#include<vector>
using namespace std;
const int N=111;
const int M=1111;
typedef __int64 LL;
struct Edges
{
int a,b,c;
bool operator<(const Edges & x)const
{
return c<x.c;
}
} edge[M];
int n,m;
int mod;
LL f[N],U[N],vist[N];//f,U都是并查集，U是每组边临时使用
LL G[N][N],C[N][N];//G顶点之间的关系，C为生成树计数用的Kirchhoff矩阵
vector<int>V[N];//记录每个连通分量
int Find(int x,LL f[])
{
if(x==f[x])
return x;
else
return Find(f[x],f);
}
LL det(LL a[][N],int n)//生成树计数:Matrix-Tree定理
{
for(int i=0; i<n; i++)
for(int j=0; j<n; j++)
a[i][j]%=mod;
int ret=1;
for(int i=1; i<n; i++)
{
for(int j=i+1; j<n; j++)
while(a[j][i])
{
int t=a[i][i]/a[j][i];
for(int k=i; k<n; k++)
a[i][k]=(a[i][k]-a[j][k]*t)%mod;
for(int k=i; k<n; k++)
swap(a[i][k],a[j][k]);
ret=-ret;
}
if(a[i][i]==0)
return 0;
ret=ret*a[i][i]%mod;
}
return (ret+mod)%mod;
}
void Solve()
{
sort(edge,edge+m);//按权值排序
for(int i=1; i<=n; i++)//初始化并查集
{
f[i]=i;
vist[i]=0;
}
LL Edge=-1;//记录相同的权值的边
LL ans=1;
for(int k=0; k<=m; k++)
{
if(edge[k].c!=Edge||k==m)//一组相等的边,即权值都为Edge的边加完
{
for(int i=1; i<=n; i++)
{
if(vist[i])
{
LL u=Find(i,U);
V[u].push_back(i);
vist[i]=0;
}
}
for(int i=1; i<=n; i++) //枚举每个连通分量
{
if(V[i].size()>1)
{
for(int a=1; a<=n; a++)
for(int b=1; b<=n; b++)
C[a][b]=0;
int len=V[i].size();
for(int a=0; a<len; a++) //构建Kirchhoff矩阵C
for(int b=a+1; b<len; b++)
{
int a1=V[i][a];
int b1=V[i][b];
C[a][b]=(C[b][a]-=G[a1][b1]);
C[a][a]+=G[a1][b1];//连通分量的度
C[b][b]+=G[a1][b1];
}
LL ret=(LL)det(C,len);
ans=(ans*ret)%mod;//对V中的每一个连通块求生成树个数再相乘
for(int a=0; a<len; a++)
f[V[i][a]]=i;
}
}
for(int i=1; i<=n; i++)
{
U[i]=f[i]=Find(i,f);
V[i].clear();
}
if(k==m)
break;
Edge=edge[k].c;
}
int a=edge[k].a;
int b=edge[k].b;
int a1=Find(a,f);
int b1=Find(b,f);
if(a1==b1)
continue;
vist[a1]=vist[b1]=1;
U[Find(a1,U)]=Find(b1,U);//并查集操作
G[a1][b1]++;
G[b1][a1]++;
}
int flag=0;
for(int i=2; i<=n&&!flag; i++)
if(U[i]!=U[i-1])
flag=1;
if(m==0)
flag=1;
printf("%I64d\n",flag?0:ans%mod);
}
int main()
{
//freopen("C:\\Users\\Administrator\\Desktop\\kd.txt","r",stdin);
while(scanf("%d%d%d",&n,&m,&mod),n+m+mod)
{
memset(G,0,sizeof(G));
for(int i=1; i<=n; i++)
V[i].clear();
for(int i=0; i<m; i++)
scanf("%d%d%d",&edge[i].a,&edge[i].b,&edge[i].c);
Solve();
}
return 0;
}