各种最小/最大生成树的实现

最小生成树有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;
}