leetcode1584. 连接所有点的最小费用最小生成树

原创于 2023-06-14 19:30:00 发布 · 106 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#图论 #算法

笔记专栏收录该内容

122 篇文章

订阅专栏

该代码实现了一个C++程序，通过并查集数据结构解决LeetCode上的一个问题，即找出连接所有给定点的最小总费用。程序首先计算所有点对之间的曼哈顿距离，然后按距离排序，依次尝试合并未连接的点，避免形成回路，最终得出最小总成本。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

/******************************************************************************
链接：https://leetcode.cn/problems/min-cost-to-connect-all-points
给你一个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

*******************************************************************************/
#include <iostream>
#include <vector>
#include <algorithm> // std::sort
using namespace std;

//
struct Edge {
    int start; // 顶点1
    int end;   // 顶点2
    int len;   // 长度
};

class BCJ{
public:
    BCJ(int n){
        for(int i=0;i<n;i++){
            fa.push_back(i);
        }
    };
    vector<int> fa;//并查集矩阵
    int find(int val){
        if (fa[val] == val){//当前为祖先节点，直接返回
            return val;
        }else{
            return find(fa[val]);//否则寻找父节点的祖先节点
        }
        return 0;
    }
    
    void merge(int x,int y){//在并查集中合并节点
        int fa_x = find(x);
        int fa_y = find(y);
        fa[fa_x] = fa_y; 
    }
    
};

    




int main()
{
    cout<<"Hello World";
    vector<vector<int>> points = {{0,0},{2,2},{3,10},{5,2},{7,0}};
    int num_points = points.size();
    BCJ *bcj = new BCJ(num_points);
    cout<<num_points;
    //所以任意两个点之间都可能链接，要把num_points*num_points个edge以及对应的长度计算出来
    //在算法中需要将边排序，然后遍历排序后的边，判断[i,j]边是否构成回路
    //如果构成回路就不加到总和中，直到遍历完所有的边

    vector<Edge> edges;
    for (int i = 0; i < num_points; i++) {
        for (int j = i + 1; j < num_points; j++) {
            Edge edge = {i, j, abs(points[i][0] - points[j][0]) + abs(points[i][1] - points[j][1])};
            edges.emplace_back(edge);
        }
    }
    
    //排序
    sort(edges.begin(), edges.end(), [](const auto& a, const auto& b) {return a.len < b.len;});
    int res,IsIncircle;
    // 连通分量合并
    for (auto& e : edges) {
        IsIncircle  = bcj->find(e.start) == bcj->find(e.end);
        if (IsIncircle==0) {bcj->merge(e.start, e.end);res+=e.len;cout<< res<<endl;}
    }
    return 0;
}

leetcode上的代码

struct Edge {
    int start; // 顶点1
    int end;   // 顶点2
    int len;   // 长度
};

class BCJ{
public:
    BCJ(int n){
        for(int i=0;i<n;i++){
            fa.push_back(i);
        }
    };
    vector<int> fa;//并查集矩阵
    int find(int val){
        if (fa[val] == val){//当前为祖先节点，直接返回
            return val;
        }else{
            return find(fa[val]);//否则寻找父节点的祖先节点
        }
        return 0;
    }
    
    void merge(int x,int y){//在并查集中合并节点
        int fa_x = find(x);
        int fa_y = find(y);
        fa[fa_x] = fa_y; 
    }
    
};


class Solution {
public:
    int minCostConnectPoints(vector<vector<int>>& points) {

    int num_points = points.size();
    BCJ *bcj = new BCJ(num_points);
    cout<<num_points;
    //所以任意两个点之间都可能链接，要把num_points*num_points个edge以及对应的长度计算出来
    //在算法中需要将边排序，然后遍历排序后的边，判断[i,j]边是否构成回路
    //如果构成回路就不加到总和中，直到遍历完所有的边

    vector<Edge> edges;
    for (int i = 0; i < num_points; i++) {
        for (int j = i + 1; j < num_points; j++) {
            Edge edge = {i, j, abs(points[i][0] - points[j][0]) + abs(points[i][1] - points[j][1])};
            edges.emplace_back(edge);
        }
    }
    
    //排序
    sort(edges.begin(), edges.end(), [](const auto& a, const auto& b) {return a.len < b.len;});
    int res=0;//这个OJ平台默认值不是0
    // 连通分量合并
    for (auto& e : edges) {
        if (bcj->find(e.start) != bcj->find(e.end)) {bcj->merge(e.start, e.end);res+=e.len;cout<< res<<endl;}
    }
    return res;

    }
};