图论（三）（最小生成树）

news2025/3/18 23:48:54

一、图的表示（简要概述）

对于图G=（V，E）（ V 为节点的集合，E 为边的集合 = V*V 的子集）有两种表示方法：邻接链表和邻接矩阵，两种表示方法既可以表示有向图，也可以表示无向图。

如果 G 是连通图，则 $E \geq V-1$ ，一个图连通，至少有 v -1 条边。

邻接链表适合表示稀疏图（边的条数 E 远远小于 $V^{2}$ ），而邻接矩阵适合表示稠密图（E 接近 $V^{2}$ ），此外要判 $V^{2}$ 断两个节点之间是否有边相邻，可以快速通过邻接矩阵判断。

1.邻接矩阵

邻接矩阵的表示，考虑节点集合 $V=\left \{ 1,2,3......n \right \}$ ，用一个二维数组定义邻接矩阵 $A\left [ 1.....n \right ]\left [ 1.....n \right ]$ ，满足以下

对于一个简单的有向图（或无向图），邻接矩阵如下：

无向图：若 u 与 v 之间存在一条边，则 A[u][v]=A[v][u]=1 （两个方向）

有向图：若有一条 u 指向 v 的边，则 A[u][v]=1；若有一条 v 指向 u 的边，则 A[v][u]=1（单向）

邻接矩阵的空间消耗为 $O(V^{2})$ ，无向图的邻接矩阵为对称矩阵。在某些情况下，只存储邻接矩阵的对角线及以上的部分，这样，图占用的存储空间可以减少一半。

2.邻接链表

Adj为一个包含 V 条链表的数组，每个节点有一个链表，对于每个节点u∈V，邻接链表Adj[u]包含所有与节点u之间有边相连的节点v。

如果G是一个有向图，则对于边（u，v）而言，节点 v 将出现在链表 Adj [ u ]里，所有邻接链表的长度之和等于 E；如果G是一个无向图，对于边（ｕ，ｖ），节点ｖ将出现在链表 Adj [ u ] 里，节点 u 将出现在链表 Adj [ v ]里，所有邻接链表的长度之和为 2*E。

邻接链表表示法的储存空间均为 O（V+E）

二、最小生成树

1.相关概念

树的概念：如果一个无向连通图不包含回路（连通图中不存在环），那么就是一棵树

最小生成树：一个图中可能存在多条相连的边，一定可以从图中挑出一些边生成一棵树，当每条边都存在权重时，这时候我们从图中生成一棵树（仅有n-1条边相连n个节点），生成这棵树的总代价就是每条边的权重相加之和。

一个有 n 个点的图，边一定是 ≥ n-1，最小生成树就是在这些边中选择 n-1 条边，连接 n 个点，这 n-1 条边的边权之和是所有方案里最小的。

2.最小生成树的应用

要在 n 个城市之间铺设光缆，主要是要使这 n 个城市的任意两个之间都可以通信，但铺设光缆的费用很高，且各个城市之间铺设光缆的费用不同，因此是要使铺设光缆的总费用最低。需要找到带权的最小生成树。

3.实现最小生成树的算法

① prim 算法

算法思路：

a.选择一个起始点作为最小生成树的起点，将该起始节点加入最小生成树的集合，并标记已访问。

b.在所有与最小生成树集合相邻的边中，选择权重最小的边和它连接的未访问节点，并将其加入最小生成树集合，并标记已访问，

c.重复上述 b 操作，直到所有的节点都加入到最小生成树里面结束。

算法复杂度分析：需要考虑每个插入每个节点，并且找出当前最小生成树集合相邻边权重最小和其连接的未访问节点，因此时间复杂度为 $O(n^{2})$

图示：

代码运行：

// prim 算法求最小生成树 
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define INF 0x3f3f3f3f
using namespace std;
const int maxn=505;
int a[maxn][maxn];
int vis[maxn],dist[maxn];
int n,m;
int u,v,w;
long long sum=0;
int prim(int pos) 
{
	dist[pos]=0;    // dist[x]为当前到达节点 x 的最小权值的边（最小生成树集合中）
	// 一共有 n 个点,就需要 遍历 n 次,每次寻找一个权值最小的点,记录其下标
	for(int i=1;i<=n;i++) 
    {
		int cur=0;
		for(int j=1;j<=n;j++)
			if(!vis[j] && dist[j]<dist[cur]) //找出与最小生成树集合相邻的权重最小的边
				cur=j; 
	    sum+=dist[cur];
	    vis[cur]=1;
	    for(int k=1;k<=n;k++) 
         {
		   // 只更新还没有找到的最小权值
		    if(!vis[k]) dist[k]=min(dist[k],a[cur][k]);
	    }
	}
	return sum;
}
	
int main(void) 
{
	scanf("%d%d",&n,&m);
	memset(a,0x3f,sizeof(a));
	memset(dist,0x3f,sizeof(dist));
	for(int i=1;i<=m;i++) 
    {
		scanf("%d%d%d",&u,&v,&w);
		a[u][v]=min(a[u][v],w);
		a[v][u]=min(a[v][u],w);
	}
	int value=prim(1);
	printf("%lld\n",sum);
	return 0;
}

prim算法的优化：

在寻找最小生成树集合相邻边的最小权重时，可以通过优先队列的方法直接进行求出，按照从小到大的顺序直接得出。

定义一个优先队列，队列中元素记录了节点的编号和与树中顶点相连的边权，将原点压入队列中，然后弹出。执行以下操作：

从栈顶弹出节点（按照边权排序，最短边权对应的元素弹出），判断该节点是否被访问，若没有被访问，则直接将该点加入最小生成树集合中。并且将与 u 相连的边加入队列当中。

实现优化后的时间复杂度为 $O(nlogn)$

void prim(int s)
{
	memset(dis,0x3f,sizeof(dis));
	memset(vis,0,sizeof(vis));
	dis[s]=0;
	q.push((node){0,s});   // 加入优先队列
	while(!q.empty())
	{
		int u=q.top().v;
		q.pop();
		if(vis[u]) continue;
		vis[u]=1;
		sum+=dis[u];
		for(int i=0;i<map[u].size();i++)
		{
			int v=map[u][i].v;
			int w=map[u][i].w;
			if(dis[v]>w)
			{
				dis[v]=w;
				q.push((node){w,v});
			}
		}
	}
}

② Kruskal 算法

算法思路：按照边的权值从小到大排序，选择 n-1 条边，并且保证这 n-1 条边连接 n 个顶点

如何保证判断某条边是多余的呢？（第 i 条边连接的两个顶点 u v在之前是连通的，该条边就不需要了）

通过并查集的思想，如果这两个顶点有共同的“祖先”，则此条边多余。如果这两个顶点祖先不相同，则将两个顶点合并。

当插入的节点个数为 n 时，即已经产生了最小生成树。

 void Kruskal()
{
    sort(ed+1,ed+m+1,cmp);
    for(int i=1;i<=m;i++)
    {
        int p=FindSet(ed[i].u);
        int q=FindSet(ed[i].v);
        if(p!=q)
        {
            UnionSet(p,q);
            mst+=ed[i].bq;
            if(si[q]==n)
                return;
        }
    }
}

算法时间复杂度的分析：

对边进行排序： $O(ElgE)=O(ElogV) \, \, \, \, \, \, \, \, \, \, E\leq V^{2}$