无向图最小生成树计数模板 -- Minimum Spanning Tree HDU - 4408

思想：
最小生成树计数用到了Matrix-Tree定理和贪心、分块思想，Matrix-Tree定理用来求出每个分块的每个联通块的方案数，分块是指按权值给边划分区块。我们把边从小到大排序，按边权分块，求出每次分块内还没有加入大联通块的分块内小联通块的联通方案数，直到最最小生成树上的点全部联通，小生成树方案数等于每次小联通块方案数的乘积

关于分块：
因为我们求得是最小生成树有多少种的组成方案。最小生成树的总权值是一个定值，不会有比原最小生成树更小的边权，也不能把比生成树中大的权边来作为替换边（那样总权值就不最小了），所以只能是权值相等的边相互替换。关于分块我们要引进 vis[] 数组和vector数组edge[]， vis[]每次标记一个分块的所有点。edge[]记录每次分块的联通块。

如何贪心：
我们就把边按权值从小到大排列，按边权分块。我们每次去边加到生成树里就保证了生成树最小。

如何判断树的连通性：
（无向图显而易见用并查集来判断）这里用pre[] 和U[]作为并查集数组来判断树的联通性，U[]、pre[]维护一个联通块的根节点，U[]记录本分块的联通状况（虽然U[]保留有之前分块的数据，但我们用vis[]标记了本次区块的所有点），pre[]记录之前所有分块的总联通状况，可以通过pre[]判断两点之前是否已联通，之前已经联通的则不需要在加这条边了（因为贪心思路，这条边比之前的边权更大）

Matrix-Tree定理计数

Minimum Spanning Tree HDU - 4408

模板代码来自_llc dalao
模板code：

#include <iostream>
#include <algorithm>
#include <string.h>
#include <vector>
using namespace std;
const int maxn = 105;
#define ll long long 
struct edge {
	int u, v, w;
	bool operator<(const edge& temp)const {
		return w < temp.w;
	}
} edges[1005];

ll B[maxn][maxn], G[maxn][maxn];
int n, m, mod;
int pre[maxn], U[maxn];
bool vis[maxn];
vector<int> e[maxn];

ll determina(int n) {
	ll res = 1;
	for (int i = 1; i <= n; i++) {
		if (!B[i][i]) { //若果对角线元素为0,把此行都一都移到下一行去
			bool flag = false;
			for (int j = i + 1; j <= n; j++) { //从i+1行开始找i列中的第一个不为0的元素，与现在的行交换
				if (B[j][i]) {//找到了该列不为0的元素,
					flag = 1; //标记,交换
					for (int k = i; k <= n; k++) swap(B[i][k], B[j][k]);
					res = -res;// 换行系数变为负数
					break; //退出.
				}
			}
			if (!flag) return 0; //这一行全部为0,行列式值为0
		}
		for (int j = i + 1; j <= n; j++) {
			while (B[j][i]) { //从下面的行找一个不为0的元素与第i行进行消元
				ll t = B[i][i] / B[j][i];
				for (int k = i; k <= n; k++) {
					B[i][k] = (B[i][k] - t * B[j][k]) % mod;
					swap(B[i][k], B[j][k]);//消元后,把0的行换到下面来。
				}
				res = -res;
			}
		}
		res *= B[i][i];//对角线元素相乘
		res %= mod;
	}
	return (res + mod) % mod;
}

int find(int x, int* p) {
	if (x == p[x]) return x;
	else return p[x] = find(p[x], p);
}
void kruskal() {
	sort(edges, edges + m);
	for (int i = 1; i <= n; i++) pre[i] = i; memset(vis, 0, sizeof vis);
	ll tempedge = -1;
	ll ans = 1;
	for (int k = 0; k <= m; k++) { //k==m为了最后一步
		if (edges[k].w != tempedge || k == m) { //开启下一阶段之气那处理上一阶段的边
			for (int i = 1; i <= n; i++) {
				if (vis[i]) {
					int u = find(i, U);
					e[u].push_back(i); //记录联通块中所有的顶点
					vis[i] = 0; //取消该点的标记,说明仍未访问到.
				}
			}
			for (int i = 1; i <= n; i++) { //遍历每一个点,找到每一个连通分量
				if (e[i].size() > 1) { //连通分量只有>=3才有意义,2个点只有1种生成树
					memset(B, 0, sizeof B);
					int len = e[i].size(); //除去联通点的顶点的顶点个数,
					for (int a = 0; a < len; a++) //求出基尔霍夫矩阵
						for (int b = a + 1; b < len; b++) {
							int a1 = e[i][a], b1 = e[i][b]; //联通块中的2个不同顶点
							B[a][b] = (B[b][a] -= G[a1][b1]);
							B[a][a] += G[a1][b1];
							B[b][b] += G[a1][b1];
						}
					ll res = determina(len - 1);
					ans = (ans * res) % mod;
					for (int a = 0; a < len; a++) pre[e[i][a]] = i;
				}
			}
			for (int i = 1; i <= n; i++) {
				U[i] = find(i, pre);
				e[i].clear();
			}
			if (k == m) break;
			tempedge = edges[k].w;
		}
		int a = edges[k].u, b = edges[k].v;
		int a1 = find(a, pre), b1 = find(b, pre);
		if (a1 == b1) continue;
		vis[a1] = vis[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) //边=0
		flag = 1;
	printf("%lld\n", flag ? 0 : ans % mod);
	return;
}
int main() {
	//		freopen("a.txt","r",stdin);
	while (scanf("%d%d%d", &n, &m, &mod) && (n + m + mod)) {
		memset(G, 0, sizeof G);
		for (int i = 0; i < m; i++) scanf("%d%d%d", &edges[i].u, &edges[i].v, &edges[i].w);
		kruskal();
		for (int i = 1; i <= n; i++) e[i].clear();
	}
	return 0;
}