最小生成树Prim和Kruskal算法

生成树是对图遍历访问的一条无回路的遍历路径称为图的生成树，最小生成树是对带有权值的图,生成树路径中权值总和最小的路径,称为最小生成树.

以leetcode 5513. 连接所有点的最小费用为例

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

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

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

示例：

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

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

此题是模板题，直接使用Prim算法或Kruskal算法即可求解；

Prim算法：

class Solution {
    int[] pre;
    public int minCostConnectPoints(int[][] points) {
        int ans=0;
        if(points.length==1) return ans;
        PriorityQueue<int[]> pq=new PriorityQueue<int[]>((e1,e2)->{
                return e1[1] - e2[1];
        });
        Set<Integer> vis=new HashSet<Integer>();
        pq.add(new int[2]);
        while(vis.size()<points.length){
            int[] head=pq.poll();
            if(!vis.contains(head[0])){
                vis.add(head[0]);
                ans+=head[1];
                for(int i=0;i<points.length;++i){
                    if(!vis.contains(i)){
                        pq.add(new int[]{i,Math.abs(points[i][0]-points[head[0]][0])+Math.abs(points[i][1]-points[head[0]][1])});
                    }
                }
            }
        }
        return ans;
    }
}

 

Prim算法一般复杂度为O(N^2)，基于点处理，直接可以通过vis标记是否访问排除回路，在对边排序时可以使用优先队列进行堆优化O(mlogn)，另外在内层for循环中，可以用邻接表进行存储。因为是基于点处理，所以适用于边稠密的图，此题是全连接的图所以属于边密集型。

Kruskal（大佬）代码：

#include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <vector>

using namespace std;

// BEGIN NO SAD
#define all(x) x.begin(), x.end()
#define sz(x) (int)(x).size()
#define f first
#define s second
typedef vector<int> vi;
typedef long long ll;
typedef pair<int, int> pii;
// END NO SAD
// REMEMBER CLEAR GLOBAL STATE
// REMEMBER READ THE PROBLEM STATEMENT AND DON'T SOLVE A DIFFERENT PROBLEM
// remember hidden T factor of 1e2
// read the bounds for stupid cases
// did you restart your editor
int par[1005];
int find(int x) {
  return par[x] == x ? x : (par[x] = find(par[x]));
}
bool merge(int x, int y) {
  x = find(x);
  y = find(y);
  if(x == y) return false;
  par[x] = y;
  return true;
}
class Solution {
public:
    int minCostConnectPoints(vector<vector<int>>& points) {
        int ret = 0;
        int n = sz(points);
        int need = n-1;
        vector<pair<int, pii>> edges;
        for(int i = 0; i < n; i++) par[i] = i;
        for(int i = 0; i < n; i++) for(int j = 0; j < i; j++) edges.emplace_back(abs(points[i][0] - points[j][0]) + abs(points[i][1] - points[j][1]), pii(i, j));
        sort(all(edges));
        for(auto& out: edges) {
          if(merge(out.s.f, out.s.s)) {
            ret += out.f;
            if(--need == 0) break;
          }
        }
        return ret;
    }
};

Kruskal算法是基于边选取，但在判断回路时较麻烦，需要用并查集进行回路判断。基于边处理，适用于边稀疏的图。