最小生成树的两种算法及模版整理

图伦的算法是我觉得最高大上的，因为每个算法都有一个很叼的名字！

哈哈，陆续整理一些自己的模版，方便自己以后使用吧。

首先是Prim算法的普通版本 复杂度O(V^2)

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int INF = 0x3f3f3f3f;
int n;
int g[105][105];
int vis[105],d[105];
int prim(){
memset(vis,0,sizeof(vis));
memset(d,0x3f,sizeof(d));
int ans = d[1] = 0;
for(int i=1;i<=n;i++){
int k = 0,minn = INF;
for(int j=1;j<=n;j++)if(!vis[j] && d[j] < minn)
minn = d[j],k = j;
if(k == 0)break;
vis[k] = 1;
ans += minn;
for(int j=1;j<=n;j++)
if(!vis[j]&&g[k][j]&&d[j]>g[k][j])
d[j] = g[k][j];
}
return ans;
}
int main()
{
while(scanf("%d",&n)==1){
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
scanf("%d",&g[i][j]);
printf("%d\n",prim());
}
return 0;
}

然后是prim版本的优先队列优化，复杂度变为O(ElogV)

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;
const int INF = 0x3f3f3f3f;
const int N = 100005;
struct edge{
int v,w,next;
bool operator <(const edge &a) const{
return w> a.w;
}
}node
,t1,t2;
int dis
,vis
,head
,cnt;
void init(){
memset(vis,0,sizeof(vis));
memset(node,0,sizeof(node));
memset(head,-1,sizeof(head));
memset(dis,0x3f,sizeof(dis));
}
void addedge(int u,int v,int w){
node[cnt].v = v;
node[cnt].next = head[u];
node[cnt].w = w;
head[u] = cnt++;
}
int prim(){
int ret=0;
priority_queue<edge> q;
for(int i=head[0];i!=-1;i = node[i].next){
int v = node[i].v;
if(node[i].w<dis[v]){
dis[v] = node[i].w;
t1.w = dis[v];
t1.v = v;
q.push(t1);
}
}
vis[0] = 1;
while(!q.empty()){
t1 = q.top();
q.pop();
int u = t1.v;
if(vis[u])continue;
vis[u] = 1;
ret += dis[u];
for(int i=head[u];i!=-1;i = node[i].next)
{
int v = node[i].v;
if(!vis[v] && dis[v] > node[i].w){
dis[v] = node[i].w;
t2.v = v;
t2.w = dis[v];
q.push(t2);
}
}
}
return ret;
}
int main()
{
printf("我TM就是个模版。。\n");
return 0;
}

Prim算法的结构其实跟Dijkstra求最短路特别像，连优化都差不多。。

下面是Kruskal算法，一个贪心算法，每次加入边权最短的边，并且保持树结构（用并查集）。很容易理解，也很好写。

#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
struct edge{
int u, v, w;
edge() {}
edge(int _u, int _v, int _w):u(_u), v(_v), w(_w) {}
}t1;
int cmp(edge a,edge b){return a.w<b.w;}
vector<edge> e;
int n,fa[105];
int findset(int x){
return fa[x] !=x? fa[x] = findset(fa[x]):x;
}
int Kruskal(){
sort(e.begin(),e.end(),cmp);
for(int i=1;i<=n;i++)fa[i] = i;
int ret = 0;
for(int i=0;i<e.size();i++){
int u = e[i].u,v = e[i].v,w = e[i].w;
u = findset(u),v = findset(v);
if(u == v)continue;
fa[u] = v;
ret+=w;
}
return ret;
}
int main()
{
while(scanf("%d",&n)==1){
e.clear();
int temp;
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
{
scanf("%d",&temp);
if(temp)e.push_back(edge(i,j,temp));
}
printf("%d\n",Kruskal());
}
return 0;
}

上面用了三种图的存储方式，邻接矩阵，邻接表，还有vector存（类似邻接表）。用法都是可以互换的。针对结点和边的个数进行选择。