生成树是对图遍历访问的一条无回路的遍历路径称为图的生成树,最小生成树是对带有权值的图,生成树路径中权值总和最小的路径,称为最小生成树.
以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算法是基于边选取,但在判断回路时较麻烦,需要用并查集进行回路判断。基于边处理,适用于边稀疏的图。