最小生成树算法总结【洛谷P3366】

一、Prim算法

    Prim算法是一种以点集为出发点的最小生成树算法，它将无向图G中所有顶点V分成两个子集A、B。初始时，A中只包含一个随机选取的顶点u，其余顶点属于集合B。每次从集合B中选取一个顶点加入顶点A，该顶点是集合B到集合A中距离最小的一个点。直到V个顶点全部属于A，算法结束。算法时间复杂度O(n^2)。

#include <cstdio>
#include <memory.h>
using namespace std;

#define MaxN 5005

int N, M;
int G[MaxN][MaxN];

bool flag[MaxN];
int dis[MaxN];

int Prim()
{
	int ans = 0;
	memset(dis, 0x7f, sizeof(dis));
	flag[1] = true;
	for(int i = 1; i<=N; ++i) dis[i] = G[1][i];
	for(int i = 1; i<N; ++i)
	{
		int min = 0x7f7f7f7f, min_j = 0;
		for(int j = 1; j<=N; ++j)
		{
			if(flag[j]) continue;
			if(dis[j]<min)
			{
				min = dis[j];
				min_j = j;
			}
		}
		if(!min_j) return -1;
		ans += min;
		flag[min_j] = true;
		for(int j = 1; j<=N; ++j)
		{
			if(flag[j]) continue;
			if(G[min_j][j]<dis[j])
			{
				dis[j] = G[min_j][j];
			}
		}
	}
	return ans;
}

int min(int a, int b)
{
	return a<b ? a : b;

}

int main()
{
	memset(G, 0x7f, sizeof(G));
	scanf("%d %d", &N, &M);
	for(int i = 0; i<M; ++i)
	{
		int x, y, z;
		scanf("%d %d %d", &x, &y, &z);
		G[x][y] = G[y][x] = min(G[x][y], z);
	}
	int ans = Prim();
	if(ans == -1)
	{
		printf("orz\n");
	}
	else
	{
		printf("%d\n", ans);
	}
	return 0;
}

    以洛谷P3366最小生成树模板题为例测试代码，10个测试点用时1.00s。注意这个题有坑，测试数据存在平行边，如果用邻接矩阵存图的话应该存最短的平行边。

二、堆优化Prim算法

    上述Prim算法是朴素Prim算法。朴素算法能否继续优化？关键在于每次循环中如何更快地寻找权值最小的边——可以借助堆优化。优化后时间复杂度降为O((n+m)logm)。

    注意堆优化的Prim算法需要用邻接表存图。

#include <cstdio>
#include <queue>
#include <vector>
#include <memory.h>
using namespace std;

#define MaxN 5005

struct NODE{
	int v; int key;
	bool operator < (const NODE &a) const{
		return key > a.key;
	}
};
priority_queue<NODE, vector<NODE>, less<NODE> >que;

int N, M;
struct EDGE{
	int nxt, w, v;
};
int point[MaxN], tot;
vector<EDGE>edge;

bool flag[MaxN];

void add(int x, int y, int z){
	edge.push_back((EDGE){point[x], z, y});
	++tot; point[x] = tot;
}

int Heap_Prim(){
	int ans = 0, min_v;
	flag[1] = true;
	for(int i = point[1]; i; i = edge[i].nxt){
		que.push((NODE){edge[i].v, edge[i].w});
	}
	for(int i = 1; i<N; ++i){
		while(true){
			if(!que.size()) return -1;
			if(flag[que.top().v]){
				que.pop();
				continue;
			}
			break;
		}
		ans += que.top().key;
		min_v = que.top().v;
		flag[min_v] = true;
		que.pop();
		for(int j = point[min_v]; j; j = edge[j].nxt){
			if(flag[edge[j].v]) continue;
			que.push((NODE){edge[j].v, edge[j].w});
		}
	}
	return ans;
}

int main(){
	freopen("test.in", "r", stdin);
	freopen("test.out", "w", stdout);
	edge.push_back((EDGE){0, 0, 0});
	scanf("%d %d", &N, &M);
	for(int i = 1; i<=M; ++i){
		int x, y, z;
		scanf("%d %d %d", &x, &y, &z);
		add(x, y, z);
		add(y, x, z);
	}
	int ans =Heap_Prim();
	if(ans == -1){
		printf("orz\n");
	}else{
		printf("%d\n", ans);
	}
	fclose(stdin);
	fclose(stdout);
	return 0;
}

   依然用板子题测试，十个测试点运行时间缩短至0.3s。

三、Kruskal算法

    Kruskal算法是一种以边集为出发点的贪心算法，他将边首先按权值排序，每次从剩下的边集中选择权值最小且两个端点不在同一集合的边加入生成树中，反复操作，直到加入了n-1条边。算法时间复杂度O(mlogm+mα(n))，α(n)是一次并查集的复杂度，可以认为是一个非常小的常数。

#include <cstdio>
#include <algorithm>
using namespace std;

#define MaxN 5005
#define MaxM 400005

int N, M;
struct EDGE{
	int x, y, w;
}edge[MaxM];

bool cmp(EDGE a, EDGE b){
	return a.w<b.w;
}

int fa[MaxN];
int find(int x){
	return x == fa[x] ? fa[x] : fa[x] = find(fa[x]);
}

int Kruskal(){
	int ans = 0, cnt = 0;
	for(int i = 1; i<=N; ++i) fa[i] = i;
	for(int i = 1; i<=M; ++i){
		if(cnt>=N-1) break;
		int fx = find(edge[i].x);
		int fy = find(edge[i].y);
		if(fx == fy) continue;
		fa[fx] = fy;
		ans += edge[i].w;
		++cnt;
	}
	if(cnt<N-1) return -1;
	return ans;
}

int main(){
	scanf("%d %d", &N, &M);
	for(int i = 1; i<=M; ++i) scanf("%d %d %d", &edge[i].x, &edge[i].y, &edge[i].w);
	sort(edge+1, edge+1+M, cmp);
	int ans = Kruskal();
	if(ans == -1) printf("orz\n");
	else printf("%d\n", ans);
	return 0;
}

    十个测试点用时0.2s。