一些blog看我的好迷,假解释看哭我了,这是我自己的理解,一道题看1天.菜哭
HDU 4408
无向图的最小生成树计数原理
- 就是在kruskal处理边的时候不断地找到联通块(由多个同长度的边组成的联通块),取任意一条都满足最小生成树,取不同的相同长度的边就是不同的最小生成树
- 在遇到排好序的相同长度的边时,(看作一个阶段).已经使得边满足最小的概念,求出生成树的个数.
变量含义
vis[]
代表每一个阶段相同长度的边上的所有点(所有联通块上的点)vector<int> e[]
存的是每一阶段的每个联通块内的所有点,通过U[]
来得到联通块内的点
每一个阶段相同长度的边 可能组成多个单独的联通块,不是默认想到的1个联通块
G[][]
存的是邻接矩阵(也是度数矩阵),此题2个点之间有重边,所以邻接矩阵不是原来的无重边的1或0
2并查集维护的内容
pre[]
和U[]
维护的都是每个点的所在的联通块的根节点
- 但是在连续读取的相同的边时候.
pre[]
仍是上阶段的联通块连接状态.用来查询当前读入的点是否在同一个联通块. - 而
U[]
当前阶段读入第一条相同长度的边开始之前.他和pre[]
保存的并查集种类是相同的.但是开始读入相同长度的边后通过U[]
来更新点的所属联通块的状态. - 当处理完一个阶段后.同步
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;
}