图论·最小生成树·笔记（Prim&Kruskal）

最近上课讲LCA，但是一早上轻松愉快地打完好几道近似模板题后，事情便变得奇怪了起来。由于我太菜了，又退回来看了一个钟头的最小生成树。这个故事告诉我们，学习，一定要一步一步，脚踏实地地走（正经）。
本文，便整理了一下Prim和Kruskal的笔记。
顺便推荐一道Prim不错的例题（附题解），由此进入。

最小生成树·笔记

• 生成树简介
  在一个$V$个点的无向连通图中，取其中（$V-1$）条边，并连接所有的顶点，所得到的子图称为原图的一棵生成树。
• 树的属性
  树是图的一种特殊形态。图$G$是树当且仅当以下任意一个条件成立：

1. $G$有$V-1$条边，无环；
2. $G$有$V-1$条边，连通；
3. 任意两点之间只有唯一的简单路径；
4. $G$连通，但任意删除一条边后就不连通。

• 最小生成树（MST）
  最小生成树：在一张带权的无向连通图中，各边权和为最小的一棵生成树即为最小生成树。简单讲：找出连接所有点的最低成本路线。
• 算法原理
  最小边原则：图中权值最小的边(如果唯一的话)一定在最小生成树上。唯一性：一棵生成上，如果各边的权都不相同，则最小生成树是唯一的。反之不然。
• 一般与之有关的问题，会有求最小边权和、生成树个数、最短路生成树、次小生成树、删除最大边、动态维护等等。做题过程中，正难则反、灵活运用，非常重要。

注：用$ans$存储边权和。

Prim算法

思路：贪心

1. 将1号节点置入集合$S$中。
2. 找到所有连接$S$中的节点和非$S$中的节点的边中的权值最小的那一条，并标记这条边，同时将连接的非$S$中的节点加入$S$集合。
3. 重复2步骤，直到所有节点都在$S$中了。

一般代码

int prim()
{
	int ans=0,k=0;
	for(int i=1;i<=n;i++)
		m[i]=a[1][i];
	m[1]=0;
	for(int i=1;i<=n-1;i++)
	{
		int mi=inf;
		for(int j=1;j<=n;j++)
			if(m[j]&&m[j]<mi)
			{
				k=j;
				mi=m[j];
			}
		ans=max(ans,mi);
		m[k]=0;
		for(int j=1;j<=n;j++)
			if(m[j]&&a[k][j]<m[j])
				m[j]=a[k][j];
	}
	return ans;
}

堆优化：
关键在于第2步：求出最小生成树的$n-1$条边（重复操作$n-1$次），由于边数一定，肯定要重复操作$n-1$次，只能优化每次选取的最小值。所以使用堆来保存已选集合中点到未选集合中点的最短边长并维护其最小值，并在访问每条边的时候更新。这样，可以把时间复杂度由$O(n^2)$优化至$O(logm)$，总时间复杂度为$O((n+m)logm)$。

堆优化代码

inline bool operator <(node a,node b)
{
	return a.dis>b.dis;
}
void prim()
{
	priority_queue<node> q;
	q.push((node){1,0});
	memset(vis,0,sizeof(vis));
	while(!q.empty())
	{
		node x=q.top();
		q.pop();
		if(vis[x.id]) continue;
		vis[x.id]=1;
		ans+=x.dis;
		int u=x.id;
		for(int i=first[u];i;i=e[i].nxt)
		{
			int y=e[i].v,z=e[i].w;
			if(vis[y]) continue;
			q.push((node){y,z});
		}
	}
}

Kruskal算法

思路：贪心。将边按权值排序，每次从剩下的边集中选择权值最小且两个端点不在同一集合的边加入生成树中，反复操作，直到加入了$n-1$条边。

1. 将图$G$中的边按权值从小到大快排；
2. 按照权值从小到大依次选边。若当前选取的边加入后使生成树$T$形成环，则舍弃当前边；否则标记当前边并计数。
3. 重复第2步的操作，直到生成树$T$中包含$n-1$条边为止。否则当遍历完所有的边后，都不能选取$n-1$条边，表示最小生成树不存在。
4. 一个关键点是判断边的2个节点是否连通，用并查集。

代码

inline bool cmp(node a,node b)
{
	return a.w<b.w;//以权值为关键字上升排序 
}
inline int get(int x)
{
	return x==fa[x]?x:fa[x]=get(fa[x]);
}
int kruskal()
{
	int f1,f2,sum=0,ans=0;
	sort(e+1,e+m+1,cmp);
	for(int i=1;i<=m;i++)
	{
		f1=get(e[i].u),f2=get(e[i].v);
		if(f1!=f2)
		{
			fa[f1]=f2;
			ans+=e[i].w;
			sum++;
		}
		if(sum==n-1) return ans;
	}
}

那么，最小生成树，大概就是这样了。希望现在再去看LCA，心里能更有底气吧。