一些blog看我的好迷,假解释看哭我了,这是我自己的理解,一道题看1天.菜哭
HDU 4408

无向图的最小生成树计数原理

• 就是在kruskal处理边的时候不断地找到联通块(由多个同长度的边组成的联通块),取任意一条都满足最小生成树,取不同的相同长度的边就是不同的最小生成树
• 在遇到排好序的相同长度的边时,(看作一个阶段).已经使得边满足最小的概念,求出生成树的个数.

变量含义

• vis[]代表每一个阶段相同长度的边上的所有点(所有联通块上的点)
• vector<int> e[]存的是每一阶段的每个联通块内的所有点,通过U[]来得到联通块内的点

  每一个阶段相同长度的边 可能组成多个单独的联通块,不是默认想到的1个联通块

• G[][]存的是邻接矩阵(也是度数矩阵),此题2个点之间有重边,所以邻接矩阵不是原来的无重边的1或0

  2并查集维护的内容

---

• pre[] 和 U[]维护的都是每个点的所在的联通块的根节点

1. 但是在连续读取的相同的边时候.pre[]仍是上阶段的联通块连接状态.用来查询当前读入的点是否在同一个联通块.
2. 而U[]当前阶段读入第一条相同长度的边开始之前.他和pre[]保存的并查集种类是相同的.但是开始读入相同长度的边后通过U[]来更新点的所属联通块的状态.
3. 当处理完一个阶段后.同步pre[]和U[]

• 每一阶段都将该阶段:的每个联通块的节点信息更新到pre[]上,这样pre[]就保存了下一阶段要用的信息,然后同步pre[] 和 U[]

---

#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;
}