当前位置：首页 > news >正文

笔记：代码随想录算法训练营day63:prim算法精讲、kruskal算法精讲

news 来源：原创 2025/6/8 12:45:16

学习资料：代码随想录

prim算法精讲

卡码网：53. 寻宝

无向有权图，最小生成树是所有节点的最小连通子图，即：以最小的成本（边的权值）将图中所有节点链接到一起。

比较绕的一点是加入的是边，但是是主要操作的是节点

三部曲：

选距离生成树最近节点（一开始一般就选第一个节点）；

将节点加入最小生成树，对于该求最小权值和的题，该步就是记录一下该节点已经加入生成树

更新非生成树节点到最小生成树的距离，要重点理解更新这个词，有点动态规划的意思，因为这个距离的数组的变化是由且仅由刚添加的这个节点引起的

#include <iostream>
#include <vector>
#include <climits>
using namespace std;
 
int main(){
    int v,e;
    cin>>v>>e;
    vector<vector<int>> pointTOpoint(v+1,vector<int>(v+1,10001));
    int x,y,val;
    for(int i=0;i<e;i++){
        cin>>x>>y>>val;
        pointTOpoint[x][y]=val;
        pointTOpoint[y][x]=val;
    }
 
    vector<int> minDistance(v+1,10001);   //用于记录节点到最小生成树距离的
    vector<bool> addedPoint(v+1,false);   //记录机电是否已经在最小生成树里
 
    for(int i=1;i<v;i++){                 //v个点用v-1条边就够了
        int cur=-1;
        int mindisNow=INT_MAX;
        for(int j=1;j<=v;j++){
            if(!addedPoint[j]&&minDistance[j]<mindisNow){
                cur=j;
                mindisNow=minDistance[j];
            }
        }
        addedPoint[cur]=true;
        //没次增加一条边，都更新minDistance
        for(int j=1;j<=v;j++){
            if(!addedPoint[j]&&minDistance[j]>pointTOpoint[cur][j]){
                minDistance[j]=pointTOpoint[cur][j];
            }
        }
    } 
    int result =0;
    for(int i=2;i<=v;i++){
        result+=minDistance[i];
    }
    cout<<result;
}

kruskal算法精讲

卡码网：53. 寻宝

先把边按权值排个队，之后借用并查集，判断是否有环，将边按权值从小到大添加

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
 
struct edges{
    int left,right,value;
};
 
int n=10001;
vector<int> father(n,-1);
 
void init(){
    for(int i=0;i<n;i++){
        father[i]=i;
    }
}
 
int find(int u){
    return u==father[u]?u:father[u]=find(father[u]);
}
bool isSame(int u,int v){
    u=find(u);
    v=find(v);
    return u==v;
}
void join(int u,int v){
    u=find(u);
    v=find(v);
    if(u==v) return;
    father[v]=u;
}
 
int main(){
    int v,e;
    cin>>v>>e;
    int v1,v2,val;
    vector<edges> bian;
    while(e--){
        cin>>v1>>v2>>val;
        bian.push_back({v1,v2,val});
    }
 
    sort(bian.begin(),bian.end(),[](const edges& a,const edges& b){   //内联lambda表达式作为sort的比较函数
        return a.value<b.value;
    });
    int result=0;
    init();
    for(int i=0;i<bian.size();i++){       //这里不能为<e,因为e在while循环中值已经被修改
        if(isSame(bian[i].left,bian[i].right)) continue;
        join(bian[i].left,bian[i].right);
        result+=bian[i].value;
    }
    cout<<result;
}

Prim 算法时间复杂度为 O(n^2)，其中 n 为节点数量，它的运行效率和图中边树无关，适用稠密图。

Kruskal算法时间复杂度为 nlogn（大头在快排），其中n 为边的数量，适用稀疏图。