最小生成树Prim&Kruskal算法

题目链接：1258—Agri-Net

Description

Farmer John has been elected mayor of his town! One of his campaign promises was to bring internet connectivity to all farms in the area. He needs your help, of course. Farmer John ordered a high speed connection for his farm and is going to share his connectivity with the other farmers. To minimize cost, he wants to lay the minimum amount of optical fiber to connect his farm to all the other farms.
Given a list of how much fiber it takes to connect each pair of farms, you must find the minimum amount of fiber needed to connect them all together. Each farm must connect to some other farm such that a packet can flow from any one farm to any other farm.
The distance between any two farms will not exceed 100,000.

Input

The input includes several cases. For each case, the first line contains the number of farms, N (3 <= N <= 100). The following lines contain the N x N conectivity matrix, where each element shows the distance from on farm to another. Logically, they are N lines of N space-separated integers. Physically, they are limited in length to 80 characters, so some lines continue onto others. Of course, the diagonal will be 0, since the distance from farm i to itself is not interesting for this problem.
Output

For each case, output a single integer length that is the sum of the minimum length of fiber required to connect the entire set of farms.
Sample Input

4
0 4 9 21
4 0 8 17
9 8 0 16
21 17 16 0
Sample Output

28
Source

USACO 102

–
1.prim算法

#include <set>
#include <queue>
#include <vector>
#include <iostream>
#include <algorithm> 
using namespace std;
const int MAXN = 110;
const int INF = 0x3f3f3f3f; //初始化为最大值 
int cost[MAXN][MAXN];	
bool visited[MAXN];	//顶点是否已经进入S集合 
int mincost[MAXN]; 	//从集合S到未被选中集合的最小权值 
int n;	//顶点数 
int Prim(){
	for(int i=0; i<n; i++){
		mincost[i] = INF;
		visited[i] = false;
	}
	//从0开始prim算法 
	mincost[0] = 0;
	int res = 0;
	while(true){
		int v = -1;
		for(int i=0; i<n; i++){
			//从当前集合到未被选中集合 找一条权值最小的边 
			if(!visited[i]&&(v==-1||mincost[i]<mincost[v])){
				v = i;
			}
		} 
		if(v==-1)break;
		visited[v] = true;
		res += mincost[v];
		//更新权值，有Dijskra的意思 
		for(int i=0; i<n; i++){
			mincost[i] = min(mincost[i],cost[v][i]);
		}
	}
	return res;
}
int main(){
	while(cin>>n){
		for(int i=0; i<n; i++){
			for(int j=0; j<n; j++){
				cin>>cost[i][j];
			}
		}
		cout<<Prim()<<endl;
	}
    return 0;
}

2.Kruskal算法

#include <set>
#include <queue>
#include <vector>
#include <iostream>
#include <algorithm> 
using namespace std;
const int MAXN = 110;
struct edge{
	//边的起点顶点、终点顶点、边的权值 
	int u, v, w;
};
edge e[MAXN];	//结构体边数组 
int n; // 顶点数


int f[MAXN];	//并查集父节点数组 

//重载结构体数组，按边权从小到大排序 
bool cmp(const edge& a, const edge& b){
	return a.w < b.w;
} 
//并查集 ---- 用于判断两条边是否连接的定点同属一个集合 
void init(){
	for(int i=1; i<=n; i++)
		f[i] = i;
} 
int find(int i){
	if(f[i]!=i){
		f[i] = find(f[i]);
	}
	return f[i];
}

bool merge(int a, int b){
	a = find(a);
	b = find(b);
	if(a != b){
		f[a] = b;
		return true;
	}else{
		return false;
	}
}
int Kruskal(int edgenum){
	init();
	int cur_edgenum = 0;
	int res = 0;
	sort(e, e+edgenum, cmp);
	for(int i=0; i<edgenum; i++){
		//加入的边不能使树产生回路 
		if(merge(e[i].u, e[i].v)){
			res += e[i].w;
			//边数 等于 顶点数 - 1 算法结束 
			if(++cur_edgenum == n-1){
				return res;
			}
		}
	}
	return cur_edgenum;
}
int main(){
	int i, j, cost;
	cin>>n;
	int edgenum = 0; //边数 
	for(i=1; i<=n; i++){
		for(j=1; j<=n; j++){
			cin>>cost;			
			//屏蔽题目中的权为0的自环 
			if(i != j){	
				e[edgenum].u = i;
				e[edgenum].v = j;
				e[edgenum++].w = cost; 
			}
		}
	}
	cout << Kruskal(edgenum) << endl;
    return 0;
}

两种求最小生成树算法的比较：

算法	时间复杂度	使用
prim	O（n2）(n为图的顶点数)	适合稠密图
kruskal	O（eloge）（e为图的边数目）	适合稀疏图

补一道题

1584. 连接所有点的最小费用

给你一个points 数组，表示 2D 平面上的一些点，其中 points[i] = [xi, yi] 。

连接点 [xi, yi] 和点 [xj, yj] 的费用为它们之间的 曼哈顿距离 ：|xi- xj| + |yi - yj| ，其中 |val| 表示 val 的绝对值。

请你返回将所有点连接的最小总费用。只有任意两点之间 有且仅有 一条简单路径时，才认为所有点都已连接。

示例 1：

输入：points = [[0,0],[2,2],[3,10],[5,2],[7,0]]
输出：20
解释：

我们可以按照上图所示连接所有点得到最小总费用，总费用为 20 。
注意到任意两个点之间只有唯一一条路径互相到达。

示例 2：

输入：points = [[3,12],[-2,5],[-4,1]]
输出：18

示例 3：

输入：points = [[0,0],[1,1],[1,0],[-1,1]]
输出：4

示例 4：

输入：points = [[-1000000,-1000000],[1000000,1000000]]
输出：4000000

示例 5：

输入：points = [[0,0]]
输出：0

提示：

• 1 <= points.length <= 1000
• -106 <= xi, yi <= 106
• 所有点 (xi, yi) 两两不同。

Kruskal算法：

class Solution { 
public:
    typedef struct edge{
        int a, b, w; 
        edge(int s,int p,int c):a(s),b(p),w(c){}
        bool operator <(const edge& g){return w < g.w;}
    }e;
    int Find(int n){
        if(f[n]==n) return n;
        f[n]=Find(f[n]);
        return f[n];
    }
    vector<int> f;
    vector<e> edges;
    int minCostConnectPoints(vector<vector<int>>& points) {
        for(int i=0;i<points.size();i++) f.push_back(i);
        int n = points.size();  
        for(int i = 0; i < n-1; i++){
            for(int j = i+1; j < n; j++){
               edges.push_back(edge(i,j,abs(points[i][0]-points[j][0])+abs(points[i][1]-points[j][1])));
            }
        }
        sort(edges.begin(), edges.end());
        /*
        for(auto x : edges){
            cout << x.a <<" " << x.b <<" " << x.w <<endl;
        }*/
        int ans = 0, cnt = 0;
        for(int i = 0; i < edges.size(); i++){
            int p1 = edges[i].a, p2 = edges[i].b;
            int r1 = Find(p1), r2 = Find(p2);
            if(r1 != r2){
                //cout << p1 << " " << p2 << " " << edges[i].w <<endl;
                ans += edges[i].w;
                f[r1] = r2;
                cnt++;
            }
            if(cnt == n-1) break;
        }
        return ans;
    }
};

Prim

class Solution {
public:
    int prim(int n, vector<vector<int>>& nums) {
		vector<int> dis(n, INT_MAX);
        dis[0] = 0;
        int ans = 0;
        int from = 0;
        vector<bool> isVisited(n, false);
        //逐次添加 n 个结点
        for(int i = 0; i < n; i ++){
            int minDis = INT_MAX;
            //找出未访问过的最近结点
            for(int i = 0; i < n; i ++){
                if(!isVisited[i] && dis[i] < minDis){
                    minDis = dis[i];
                    from = i;
                }
            }
            //标记为访问过
            isVisited[from] = true;
            ans += dis[from];
            //更新其他结点的距离
            for(int i = 0; i < n; i ++){
                if(!isVisited[i] && nums[from][i] < dis[i]){
                    dis[i] = nums[from][i];
                }
            }
        }
        return ans;
    }

    int minCostConnectPoints(vector<vector<int>>& points) {
        int n = points.size();
        if(n <= 1) return 0;
        vector<vector<int>> nums(n, vector<int>(n, 0));//记录两个点之间的权重
        for(int i = 0; i < n; i ++){
            for(int j = 0; j < n; j ++){
                int dis = abs(points[i][0] - points[j][0]) + abs(points[i][1] - points[j][1]); 
                nums[i][j] = dis;
            }
        }
        return prim(n, nums);
    }
};