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

本文介绍了解决LeetCode1584题目的一种方法,通过使用Kruskal算法来找到连接所有点的最小总费用。首先计算所有点之间的曼哈顿距离作为边权,然后对边进行排序,使用并查集进行边的合并,最终得到最小生成树的总费用。

题目链接:LeetCode 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 。
注意到任意两个点之间只有唯一一条路径互相到达

   解题思路:

      典型的最小生成树,直接上kruskal

先求出两点之间的距离,当做边权,然后将每个点加入到集合中

int fa[1005];
struct Edge {
	int x, y, v;
}edges[1000005];
bool cmp(Edge a, Edge b) {
	return a.v < b.v;
}
int get(int x) {
	if(x != fa[x]) {
		fa[x] = get(fa[x]);
	}
	return fa[x];
}
bool merge(int i, int j) {
	int x = get(i);
	int y = get(j);
	if(x == y) {
		return false;
	}
    if(x > y) {
        swap(x, y);
    }
    fa[x] = y;
	return true;
}
class Solution {
public:
    int minCostConnectPoints(vector<vector<int>>& points) {
    	int n = points.size(), k = 0;
    	for(int i = 0; i < n; i++) {
    		for(int j = i+1; j < n; j++) {
    			edges[k].x = i;
    			edges[k].y = j;
    			edges[k++].v = abs(points[i][0]-points[j][0]) + abs(points[i][1]-points[j][1]); 
    		}
    	}
    	sort(edges, edges+k, cmp);
    	for(int i = 0; i < n; i++) {
    		fa[i] = i;
    	}
    	int ans = 0, cnt = n;
    	for(int i = 0; i < k && cnt > 1; i++) {
    		int x = edges[i].x, y = edges[i].y, v = edges[i].v;
    		if(merge(x, y)) {
    			ans += v;
    			cnt--;
    		}
    	}
        return ans;
    }
};

 

### 解决方案概述 对于LeetCode 1584题——连接所有最小费用,目标是在给定平面上的一组之间建立边,使得这些全部连通,并且总成本最低。此问题可以通过构建最小生成树(Minimum Spanning Tree, MST)[^2]来解决。 #### Prim's Algorithm 实现方法 Prim’s算法是一种用于求解无向图中最小生成树的有效贪心算法。该算法通过逐步扩展已有的部分生成树直到覆盖所有的顶为止,在每一步都选择当前未加入的部分中最短的边。 ```python import heapq def minCostConnectPoints(points): n = len(points) # 计算曼哈顿距离作为权重函数 def manhattan(p1, p2): return abs(p1[0]-p2[0]) + abs(p1[1]-p2[1]) visited = set() heap = [(0, 0)] # (cost, point_index) result = 0 while len(visited) < n: cost, i = heapq.heappop(heap) if i in visited: continue visited.add(i) result += cost for j in range(n): if j not in visited and j != i: heapq.heappush(heap, (manhattan(points[i], points[j]), j)) return result ``` 上述代码实现了基于优先队列优化版本的Prim’s算法。首先定义了一个辅助函数`manhattan()`用来计算两之间的曼哈顿距离;接着初始化一个小根堆存储候选节及其对应的代价;最后进入循环直至访问过所有节并累加路径长度得到最终的结果。 #### Kruskal's Algorithm 实现方式 Kruskal’s算法也是一种常用的MST算法,它按照从小到大的顺序处理各条边,只当一条边不会形成环路时才将其添加至正在形成的森林里。为了高效实现这一,可以采用Union-Find数据结构来进行动态集合操作。 ```python class UnionFind(object): def __init__(self, size): self.parent = list(range(size)) def find(self, x): if self.parent[x] != x: self.parent[x] = self.find(self.parent[x]) return self.parent[x] def union(self, u, v): rootU = self.find(u) rootV = self.find(v) if rootU == rootV: return False else: self.parent[rootU] = rootV return True def minCostConnectPoints_kruskal(points): edges = [] n = len(points) for i in range(n): for j in range(i+1, n): distance = abs(points[i][0] - points[j][0]) + \ abs(points[i][1] - points[j][1]) edges.append((distance, i, j)) uf = UnionFind(n) edges.sort() res = 0 count = 0 for dist, u, v in edges: if uf.union(u, v): res += dist count += 1 if count >= n-1: break return res ``` 这段Python程序展示了如何利用Kruskal的方法解决问题。创建了名为`edges`列表保存所有可能存在的边以及它们各自的权值(即两个端间的曼哈特尼距离),之后对其进行升序排列。随后遍历排序后的边集尝试将符合条件的新边纳入结果集中去,同时维护一个计数器确保恰好选择了\(n−1\)条独立边构成一棵完整的树形结构。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值