最小生成树

下面以洛谷P3366为例
prim算法思想：
Prim算法和dijkstra最短路很像。Prim的思想是将任意节点作为根，再找出与之相邻的所有边，再将新节点更新并以此节点作为根继续搜，维护一个数组：dis，作用为目前最先生成树中所有顶点到还未加入最小生成树点的最短距离。
kruskal算法思想：
先把边按照权值进行排序，用贪心的思想优先选取权值较小的边，并依次连接，若出现环则跳过此边（用并查集来判断是否存在环）继续搜，直到已经使用的边的数量比总点数少一即可。
① kruskal算法实现
关于其算法时间复杂度，首先快排是O(MlogM)，在 m 条边中找 n - 1条边是O(MlogN)，通常M要比N大很多，所以最终时间复杂度为O(MlogM)。

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
int n, m;
int f[10005];

struct Edge{
	int x, y, w;
}edge[200005];
//  并查集模板 
int getf(int x)
{
	if (f[x] == x)
	{
		return x;
	}
	int fx = getf(f[x]);
	return f[x] = fx;
}

int merge(int u, int v)
{
	int t1 = getf(u);
	int t2 = getf(v);
	if (t1 != t2)
	{
		f[t1] = t2;
		return 1;
	}
	return 0;
}

int cmp(Edge x, Edge y)
{
	return x.w < y.w;
}

int main()
{
	scanf("%d%d", &n, &m);
	
	for (int i = 1; i <= n; i++)
	{
		f[i] = i;
	}
	
	for (int i = 1; i <= m; i++)
	{
		int u, v, w;
		scanf("%d%d%d", &u, &v, &w);
		edge[i] = {u, v, w};
	}
	//  根据 w 由小到大排序 
	sort(edge + 1, edge + 1 + m, cmp);
	
	int sum = 0, count = 0;
	//  Kruskal算法核心 
	for (int i = 1; i <= m; i++)//  这里是枚举m条边，非n条 
	{
		if (merge(edge[i].x, edge[i].y))
		{
			count++;//  如果该边还未进入集合中，则选用这条边 
			sum += edge[i].w;
		}
		if (count == n - 1)
		{
			printf("%d\n", sum);
			return 0;
		}
	}
	
	puts("orz");
	
	return 0;
} 

② prim算法实现
该算法时间复杂度O(n^2)

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

int edge[5005][5005], dis[5005], vis[5005];

int main()
{
	int n, m; 
	scanf("%d%d", &n, &m);
	//  初始化 
	for (int i = 1; i <= n; i++)
	{
		for (int j = 1; j <= n; j++)
		{
			edge[i][j] = 0x3f3f3f3f;
		}
		edge[i][i] = 0;
	}
	//  读入边 
	for (int i = 1; i <= m; i++)
	{
		int u, v, w;
		scanf("%d%d%d", &u, &v, &w);
		edge[u][v] = edge[v][u] = w;
	}

	for (int i = 1; i <= n; i++)
	{
		dis[i] = edge[1][i];
	}
	
	//  prim 算法核心
	int count = 0, index = 1, sum = 0;
	while (++count < n)
	{
		int MIN = 0x3f3f3f3f;
		vis[index] = 1;
		for (int i = 1; i <= n; i++)
		{
			if (!vis[i] && MIN > dis[i])
			{
				MIN = dis[i];
				index = i;
			}
		}
		sum += dis[index];
		
		for (int k = 1; k <= n; k++)
		{
			if (!vis[k] && dis[k] > edge[index][k])
			{
				dis[k] = edge[index][k];
			}
		}
	}
	printf("%d\n", sum);
	return 0;
} 

③ 前向星存图

#include <iostream>
using namespace std;
int n, m, cnt;
int head[5005], dis[5005], vis[5005];
struct Edge
{
	int to;
	int w;
	int next;
}edge[200005 << 1];
void add(int u, int v, int w)
{
	edge[++cnt].to = v;
	edge[cnt].w = w;
	edge[cnt].next = head[u];
	head[u] = cnt;
}

int main()
{
	scanf("%d%d", &n, &m);
	for (int i = 1; i <= m; i++)
	{
		int u, v, w;
		scanf("%d%d%d", &u, &v, &w);
		add(u, v, w);
		add(v, u, w);
	}
	for (int i = 2; i <= n; i++)
	{
		dis[i] = 0x3f3f3f3f;
	}
	
	for (int i = head[1]; i; i = edge[i].next)
	{
		dis[edge[i].to] = min(dis[edge[i].to], edge[i].w);
	}
	int tot = 0, now = 1, sum = 0;
	while (++tot < n)
	{
		int MIN = 0x3f3f3f3f;
		vis[now] = 1;
		for (int i = 1; i <= n; i++)
		{
			if (!vis[i] && MIN > dis[i])
			{
				MIN = dis[i];
				now = i;
			}
		}
		sum += dis[now];
		for (int i = head[now]; i; i = edge[i].next)
		{
			int to = edge[i].to;
			if (dis[to] > edge[i].w && !vis[to])
			{
				dis[to] = edge[i].w;
			}
		}
	}
	printf("%d\n", sum);
	return 0;
}

④ 前向星存图 + 堆优化

#include <cstdio>
#include <iostream>
#include <queue>
using namespace std;
int n, m, cnt;
int head[5005], dis[5005], vis[5005];

struct Edge
{
	int to;
	int w;
	int next;
}edge[200005 << 1];

void add(int u, int v, int w)
{
	edge[++cnt].to = v;
	edge[cnt].w = w;
	edge[cnt].next = head[u];
	head[u] = cnt;
}

typedef pair<int, int> p;
priority_queue<p, vector<p>, greater<p> > q;

int main()
{
	scanf("%d%d", &n, &m);
	for (int i = 1; i <= n; i++)
	{
		dis[i] = 0x3f3f3f3f;
	}
	for (int i = 1; i <= m; i++)
	{
		int u, v, w;
		scanf("%d%d%d", &u, &v, &w);
		add(u, v, w);
		add(v, u, w);
	}
	dis[1] = 0;
	q.push(make_pair(0, 1));
	int tot = 0, sum = 0;
	while (!q.empty() && tot < n)
	{
		int d = q.top().first, now = q.top().second;
		q.pop();
		if (!vis[now])
		{
			vis[now] = 1;
			sum += d;
			tot++; 
			for (int i = head[now]; i; i = edge[i].next)
			{
				if (dis[edge[i].to] > edge[i].w)
				{
					dis[edge[i].to] = edge[i].w;
					q.push(make_pair(dis[edge[i].to], edge[i].to));
				}
			}
		}
	}
	printf("%d\n", sum);
	return 0;
}