最小生成树算法--kruskal/Prim

一、kruskal算法

此算法可以称为“加边法”，初始最小生成树边数为0，每迭代一次就选择一条满足条件的最小代价边，加入到最小生成树的边集合里。

1. 把图中的所有边按代价从小到大排序；
2. 把图中的n个顶点看成独立的n棵树组成的森林；
3. 按权值从小到大选择边，所选的边连接的两个顶点vi,vj，vi,vj属于两颗不同的树（一棵树上的两条个顶点相连的话就形成环了），则成为最小生成树的一条边，并将这两颗树合并作为一颗树；
4. 重复(3),直到所有顶点都在一颗树内或者有n-1条边为止。

//****kruskal*******
class Solution {
private:
    vector<int> father;
    int setCount=0;

    struct Edge{
        int a,b,w;
        bool operator< (const Edge& e){
            return w<e.w;
        }
    };

public:
    int minCostConnectPoints(vector<vector<int>>& points) {
        vector<Edge> connections;
        int n=points.size();
        for(int i=0;i<n;i++){
            for(int j=i+1;j<n;j++){
                connections.push_back({i,j,
                    abs(points[i][0]-points[j][0])+abs(points[i][1]-points[j][1])});
            }
        }

        setCount = n;
        father = vector<int>(n,0);
        for(int i=0;i<n;i++){
            father[i]=i;
        }

        int cost=0;
        sort(connections.begin(),connections.end());

//取曼哈顿距离最小的连接，如果这两点本没有连接，那么连接这条边
        for(auto& conn : connections){
            int pa = find(conn.a);
            int pb = find(conn.b);
            if(pa!=pb){
                merge(conn.a,conn.b);
                cost += conn.w;
            }
            if(setCount==1)
                break;
        }
        return cost;
    }

    int find(int i){
        if(father[i]!=i){
            father[i] = find(father[i]);
        }
        return father[i];
    }

    void merge(int i, int j){
        int iRoot = find(i);
        int jRoot = find(j);
        if(iRoot!=jRoot){
            father[iRoot] = jRoot;
            setCount--;
        }
    }
};

二、Prim算法

此算法可以称为“加点法”，每次迭代选择代价最小的边对应的点，加入到最小生成树中。算法从某一个顶点s开始，逐渐长大覆盖整个连通网的所有顶点。

1. 图中所有顶点被分为访问过和未访问过的顶点（可以用bool数组来表示）；
2. 保存未访问过的顶点到访问过的顶点中的变得代价，选择代价最小的边加入最小生成树中，并将新加入的点标记为已访问过；
3. 重复上述步骤，直到有n-1条边或有n个顶点。

//*******Prim
class Solution{
public:
    struct cmp{
        bool operator()(const pair<int,int>& a,const pair<int,int>& b){
            return a.second>b.second;
        }
    };
    int minCostConnectPoints(vector<vector<int>>& points){
        int n=points.size();
        if(n<2) return 0;
//邻接矩阵
        vector<vector<int>> edges(n,vector<int>(n,0));
        for(int i=0;i<n;i++){
            for(int j=i+1;j<n;j++){
                int w = abs(points[i][0]-points[j][0])+abs(points[i][1]-points[j][1]);
                edges[i][j]=w;
                edges[j][i]=w;
            }
        }
        bool visit[n];
        memset(visit,0,sizeof(visit));

//用优先队列可以取未访问过的最近点（需要判断在该点不在树上）
        priority_queue<pair<int,int>,vector<pair<int,int>>,cmp> q;
        visit[0] = true;
        for(int i=1;i<edges[0].size();i++){
            q.push({i,edges[0][i]});
        }
        //cout<<q.top().second<<endl;
        int to, distance, cost=0, edgeCount=0; 
        while(!q.empty()){
            to = q.top().first;
            distance = q.top().second;
            q.pop();
            if(!visit[to]){
                //cout<<to<<" "<<distance<<endl;
                visit[to] = true;
                cost += distance;
                edgeCount++;
            }
            if(edgeCount==n-1)
                break;
            for(int i=0;i<edges[to].size();i++){
                if(!visit[i])
                    q.push({i,edges[to][i]});
            }
        }

        return cost;
    }
};

参考文献
https://leetcode-cn.com/problems/min-cost-to-connect-all-points/solution/c-kruskalprimsuan-fa-jie-da-by-yizhe-shi/