1584. Min Cost to Connect All Points

仅供自己学习

 

思路：

按照题目意思，规约为要获得一棵最小生成树。只是边权变成了曼哈顿距离。那么就有两种MST的方法

第一种就是prim算法：

基本的prim算法就是维护两个数据结构，第一个是最小生成树集合MST，和其他每个点到最小生成树的最短距离的数组lowcost。

一开始我们就建立一个邻接矩阵存放点与点之间的曼哈顿距离，在建立上述两个集合，最小生成树集合的数组初始化全为-1，当加入一个节点就把该节点的位置的-1改为0，其他点到最小生成树的最短距离的数组初始化全为INT_MAX。

然后把start点加入最小生成树集合，并更新上述两个数组。其他点到最小生成树集合的最短距离是每个点直连的距离不能选有中间节点的路径，尽管这样做距离会更小。

然后在把其余的点加进来，每次加的都是当前距离最小生成树距离最短的点，我们遍历lowcost获得最小的距离，然后把该点加入进MST并记录这个点的距离和下标，然后总距离加上这个距离。然后更新lowcost这个集合，如果该节点未加入进MST并且当前lowcost大于其他节点到达新加入节点的距离，那么就替换成最小的。

 

代码：

class Solution {
public:
    int prim(vector<vector<int>>& points,int start) {
        int size=points.size();
        int res=0;
        vector<int> MST(size,-1);
        vector<int> lowcost(size,INT_MAX);
        vector<vector<int>> g(size, vector<int>(size));
        for(int i=0;i<size;++i){
            for(int j=i+1;j<size;++j){   //构建无向图，每个节点之间赋值曼哈顿距离。j=i+1减少重复赋值
                int cost=abs(points[i][0]-points[j][0])+abs(points[i][1]-points[j][1]);
                g[i][j]=cost;
                g[j][i]=cost;
            }
        }

        MST[start]=0;  //加入start节点并且更新两个数组
        for(int i=0;i<size;++i){
            if(i==start) continue;
            lowcost[i]=g[i][start];
        }

        for(int i=1;i<size;++i){//加入其他节点做的处理
            int min_idx=-1;
            int min_cost=INT_MAX;
            for(int j=0;j<size;j++){
                if(MST[j]==0) continue;
                if(lowcost[j]<min_cost){
                    min_idx=j;
                    min_cost=lowcost[j];
                }
            }

            MST[min_idx]=0;
            lowcost[min_idx]=-1;
            res+=min_cost;

            for(int j=0;j<size;j++){
                if(MST[j]==-1&&g[j][min_idx]<lowcost[j]){
                    lowcost[j]=g[j][min_idx];
                }
            }
        }
        return res;
    }
    int minCostConnectPoints(vector<vector<int>>& points){
        return prim(points,0);
    }
};

 

prim算法是可以用堆进行优化，节省寻找最短距离的时间。

这次用邻接链表存储无向图，但不在存储距离。堆的元素按照（距离，下标）来建立，这样才能按照距离从小到大的排序。

刚开始是一样的步骤，只是建立了堆后，加入（0，start）后 进入while循环，循环条件为堆不为空。每次取出栈顶元素，默认是最短距离，判断是否已经加入MST集合，没有就加入，并且res加上这个最短距离，记录这个点的下标。遍历该点的邻接链表，并计算邻接链表里的节点到该点的曼哈顿距离，判断如果遍历到的节点没有加入到MST并且新的曼哈顿距离小于原lowcost里存储的距离，那么就更新lowcost。然后将该点和距离加入进堆里。

 

代码；

class Solution {
public:
    int prim(vector<vector<int>>& points,int start) {
        int size=points.size();
        if(size==0) return 0;
        int res=0;
        vector<int> MST(size,-1);
        vector<int> lowcost(size,INT_MAX);
        vector<vector<int>> g
        for(int i=0;i<size;++i){
            for(int j=i+1;j<size;++j){  //建立邻接链表
                if(i==j) continue;
                g[i].push_back(j);
                g[j].push_back(i);
            }
        }
        priority_queue<pair<int,int>,vector<pair<int,int>>,greater<>> pq;
        pq.push(start);
        while(!pq.empty()){
            auto [dis,idx]=pq.top(); pq.pop();
            if(MST[idx]==0)continue;
            MST[idx]=0;
            res+=dis;
            for(int j=0;j<size;j++){
                int neighbor=g[idx][j];
                int absdis=abs(points[idx][0]-points[j][0])+abs(points[idx][1]-points[j][1]);
                if(MST[j]==-1&&absdis<lowcost[j]){
                    lowcost[j]=absdis;
                    pq.push(make_pair(absdis,j));
                }
            }
        }
        return res;
    }
    int minCostConnectPoints(vector<vector<int>>& points){
        return prim(points,0);
    }
};

 

kruskal算法和prim算法区别在于，kruskal针对边，对边进行排序，然后每次都取最小并且和含有与MST里节点不同源的两端节点的边，因为要排序和源点统计所以适用于稀疏图。而prim算法按照节点来，每次都取离MST最近的一个点的边，耗时最多的就是维护最小距离的数组和找到最小距离的点，适用于稠密图。

 

这里kruskal用查并集，所以调用查并集的模板，然后建立边，以起点终点和距离为边的属性。然后对边进行从小到大的排序，然后每次取最小距离的边，并将边的起点和终点和边长度传入查并集进行 是否同源的判断，如果同源就返回-1，换另一个边继续，如果不同源就将两个边加入进MST即两个点与MST中的其他点同源，当MST中的点与总点数相同就返回查并集中对加入了MST的边的长度的统计。

 

代码：

class Djset{
public:
    vector<int> parent;    
    vector<int> rank;
    vector<int> size;
    vector<int> len;
    int num;
    Djset(int n): parent(n),rank(n),len(n,0),size(n,1),num(n){
        for(int i=0;i<n;i++)
            parent[i]=i;
    }
    int find(int x){
        if(x!=parent[x]){
            parent[x]=find(parent[x]);
        }
        return parent[x];
    }
    int merge(int x,int y,int length){
        int rootx=find(x);
        int rooty=find(y);
        if(rootx!=rooty){
            if(rank[rootx]<rank[rooty]){ //如果rootx的深度小于rooty
                swap(rootx,rooty); //交换两个节点，此时rootx>rooty,交换的原因是后面的代码都能是默认rootx大的情况进行操作
            }
            parent[rooty]=rootx; //将rootx这个深度大于rooty的源节点作为rooty的源节点
            if(rank[rootx]==rank[rooty]) rank[rootx]+=1; //虽然rootx源节点已经为rooty的源节点，但是rank没有改变，如果进入merge函数的时候两深度相等，那么rootx的源节点作为rooty源节点后，那么深度就会增加一个节点长度。
            size[rootx] += size[rooty];
            len[rootx] += len[rooty] + length;
            if(size[rootx]==num) return len[rootx];
        }
        return -1;
    }
};

struct Edge {
    int start;
    int end;
    int len;
};

class Solution {
public:
    int minCostConnectPoints(vector<vector<int>>& points) {
        int res=0;
        int n=points.size();
        Djset ds(n);
        vector<Edge> Edges;
        for(int i=0;i<n;++i){
            for(int j=i+1;j<n;++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;
        });
        
        for(auto& e: Edges){
            res=ds.merge(e.start,e.end,e.len);
            if(res!=-1) return res;
        }
        return 0;
    }
};