kruskal算法和prim算法的实现(最小/大生成树)

最小生成树有kruskal算法和prim算法，前者通过并查集判断是否有环，最后生成一棵树或者是森林。
他的复杂度是O(|E|*log|V|)可以说也是相当低了

struct edge{int x,y,val;}E[maxn];
int n,r;
int fa[maxn],deep[maxn];
bool cmp(edge a,edge b){
        return a.val<b.val;
}
int findfa(int x){
        return x==fa[x] ? x : fa[x]=findfa(fa[x]);
}
void unite(int a,int b){
        int faa=findfa(a);
        int fab=findfa(b);
        if(faa==fab) return;
        else{
                if(deep[faa]<deep[fab]){
                        fa[faa]=fab;
                }
                else if(deep[faa]>deep[fab]){
                        fa[fab]=faa;
                }
                else{
                        fa[fab]=faa;
                        deep[faa]++;
                }
        }
}
int kruskal(){
        sort(E,E+r,cmp);
        int res=0;
        for(int i=0;i<maxn;i++){
                fa[i]=i;
                deep[i]=0;
        }
        for(int i=0;i<r;i++){
                if(findfa(E[i].x) != findfa(E[i].y)){
                        unite(E[i].x,E[i].y);
                        res+=E[i].val;
                }
        }
        return res;
}

接下来还有prim算法，他和dijkstra算法极其的相似，只是添加了两句话。未经优先队列优化过的prim算法的负责度是O(|V|^2),优化过后是O(|E| * log|V|)。所以个人觉的没有kruskal算法好写且复杂度低

int r,n;
int cost[maxn][maxn],d[maxn];
bool used[maxn];

int dijkstra(int s){
        fill(d,d+n,INF);
        fill(used,used+n,false);
        d[0]=0;
        int res=0;//添加处1
        while(true){
                int v=-1;
                for(int i=0;i<n;i++)
                //从剩下的点中寻找出最短距离的点
                        if(!used[i] && (v==-1 || d[i]<d[v])) v=i;
                if(v==-1) break;//如果所有的点都不可以选那么就退出
                used[v]=true;
                res+=d[v];//添加处2，把已经得到的最短的长度加到结果中，因为最后不是求最短路，而是要求所有的最短的边，所以这样的操作是完全合理的
                for(int i=0;i<n;i++)//更新所有点的最短距离
                        d[i]=min(d[i],cost[v][i]);//这个时候就只是更新从x到剩下结点的最小权值
        }
        return res;
}
int main(){
        cin >> r >> n;
        //注意点之间的花费如果题中没有那么就是INF
        for(int i=0;i<maxn;i++)
                for(int j=0;j<maxn;j++)
                        cost[i][j]=INF;
        while(r--){
                int x,y,val;
                scanf("%d%d%d",&x,&y,&val);
                x--;y--;
                if(cost[x][y]>val){//有的题中需要考虑重边的情况，但是前面和后面的两种算法可以不用考虑重边的情况
                        cost[x][y]=val;
                        cost[y][x]=val;
                }
        }
        printf("%d",dijkstra());
        return 0;
}