2021-01-31

今天课上学习了最小生成树有关内容。它的本质是生成一个包括所有节点在内，但是每个点都连接起来的连通图，连通图的路径是n-1条。它有两种算法。
一种是Kruskal算法，它的思想是每次选择权值最小的一条边，将这条路径的两个节点连接起来形成一个集合，然后如果之后查找到路径上两个不同集合节点，就重复上述操作，直到找到n-1条边，退出查找。放到例题。

省政府“畅通工程”的目标是使全省任何两个村庄间都可以实现公路交通（但不一定有直接的公路相连，只要能间接通过公路可达即可）。经过调查评估，得到的统计表中列出了有可能建设公路的若干条道路的成本。现请你编写程序，计算出全省畅通需要的最低成本。

Input
测试输入包含若干测试用例。每个测试用例的第1行给出评估的道路条数 N、村庄数目M ( < 100 )；随后的 N
行对应村庄间道路的成本，每行给出一对正整数，分别是两个村庄的编号，以及此两村庄间道路的成本（也是正整数）。为简单起见，村庄从1到M编号。当N为0时，全部输入结束，相应的结果不要输出。

Output
对每个测试用例，在1行里输出全省畅通需要的最低成本。若统计数据不足以保证畅通，则输出“?”。

Sample Input
3 3
1 2 1
1 3 2
2 3 4
1 3
2 3 2
0 100

Sample Output
3
?

#include <stdio.h>
#include <iostream>
#include <string.h>
#include <algorithm>
using namespace std;
const int MAXN=1e2+10;
struct ii {
	int u;
	int v;
	int w;
} geti[MAXN];
bool cmp(ii x,ii y) {
	return x.w<y.w;
}

int pre[MAXN],n,m;
void restart() {
	for(int i=1; i<=n; i++) {
		pre[i]=i;
	}
}
int find1(int x) {
	while(pre[x]!=x) {
		x=pre[x];
	}
	return x;
}
void merge1(int u,int v) {
	int t1=find1(u);
	int t2=find1(v);
	if(t1!=t2) pre[t2]=t1;
}
int main() {
	while(~scanf("%d %d",&m,&n)&&m) {
		restart();
		int res=0,sum=0; 	
		for(int i=1; i<=m; i++) {
			scanf("%d %d %d",&geti[i].u,&geti[i].v,&geti[i].w);
		}
		sort(geti+1,geti+1+m,cmp);
		for(int i=1; i<=m; i++) {
			if(find1(geti[i].u)!=find1(geti[i].v)) {
				res+=geti[i].w;
				sum++;
				merge1(geti[i].u,geti[i].v);
			}
			if(sum==n-1)break;
		}
		if(sum==n-1)printf("%d\n",res);
		else puts("?");
		//for(int i=1;i<=m;i++){
		//	cout<<geti[i].w<<endl;
		//}
	}
}

而另一种算法则是Prim，它的思想则是从一个顶点开始，选择一条权值最小的边加入到树图中，并且更新这个点到其他点的权值（路程），直到有n-1条边为止。
题目还是上面的题目。

#include<bits/stdc++.h>
using namespace std;
const int maxn = 110;
#define inf 0x3f3f3f3f
int n, m, G[maxn][maxn], vis[maxn], d[maxn];
void Prim(int n, int m) {
    memset(vis, 0, sizeof(vis));
    int index = 1;       // 当前加入到小树的顶点
    int res = 0;         //  存放结果
    vis[index] = 1;
    for(int i = 1; i <= n; i++)    // 更新这个点到其他点的距离  
        d[i] = G[index][i];
    for(int i = 1; i < n; i++) {           // 执行 n - 1 次， 找剩下的n - 1 个点
        int minn = inf;
        for(int j = 1; j <= n; j++) {        // 找出未加入小树且 d 最小的点
            if(!vis[j] && d[j] < minn) {
                minn = d[j];
                index = j;
            }
        }
        if(minn == inf) {             // 如果没有找到， 说明不存在最小生成树
            puts("?");
            return ;
        }
        res += minn;          // 累加答案
        vis[index] = 1;       // 将这个点加入最小生成树中
        for(int j = 1; j <= n; j++) {                // 更新这个点加入后，当前这棵小树到未加入的点的最近距离
            if(!vis[j] && d[j] > G[index][j])  d[j] = G[index][j];
        }
    }
    printf("%d\n", res);
}
int main() {
    while(~scanf("%d%d", &m, &n)) {
        if(m == 0) break;
        for(int i = 1; i <= n; i++) {       // 邻接矩阵的初始化
            for(int j = 1; j <= n; j++) {
                if(i == j) G[i][j] = 0;
                else G[i][j] = inf;
            }
        }
        for(int i = 1, u, v, w; i <= m; i++) {
            scanf("%d%d%d", &u, &v, &w);
            G[u][v] = G[v][u] = min(w, G[u][v]);        // 消除重边的影响
        }
        Prim(n, m);
    }
    return 0;
}