《算法笔记》学习记录 Part 4 图（中）

第十章    数据结构专题 —— 图（中）

10.4 最短路径

对任意给出的图G（V，E）和起点S、终点T，如何求S到T的最短路径，解决最短路径问题的常用算法有Dijkstra算法，SPFA算法、Bellman-Ford算法、Floyd算法

10.4.1 Dijkstra算法

Dijkstra算法用来解决单源最短路径问题，即给定图G和起点S，通过算法得到S到其他每个顶点的最短距离。

const int MAXV = 1000;
const int INF = 1000000000;

//邻接矩阵版,适用于点数不打（V不超过1000）的情况。相对好写
int n,G[MAXV][MAXV];		//n为顶点数，MAXV为最大顶点数
int d[MAXV];	//起点到达各个点的最短路径长度
bool vis[MAXV] = {false};	//标记数组，vis[i]==true表示已经访问

void Dijkstra(int s){		//s为起点
	fill(d,d+MAXV,INF);	//fill函数将整个d数组赋值为INF
	d[s]=0;	//起点s到达自身的距离为0
	for(int i=0;i<n;i++){	//循环n次
		int u=-1,MIN=INF;	//u使d[u]最小，MIN存放该最小的d[u]
		for(int j=0;j<n;j++){
			if(vis[j]==false && d[j]<MIN){
				u=j;
				MIN=d[j];
			}
		}
	//找不到小于INF的d[u]，说明剩下的顶点和起点不连通
		if(u == -1) return;
		vis[u] = true;	//标记u为已访问
		for(int v=0;v<n;v++){
			//如果v未访问 && u能到到v && 以u为中介点可以使d[v]更优
			if(vis[v]==false && G[u][v]!=INF && d[u]+G[u][v]<d[u]){
				d[v] = d[u] + G[u][v]; 	//优化d[v]
			}
		}
	}
}

//邻接表版
struct Node{
	int v,dis;	//v为边的目标顶点，dis为边权
};

vector<Node> Adj[MAXV];
int n;
int d[MAXV];
bool vis[MAXV] = {false};

void Dijkstra(int s){
	fill(d,d+MAXV,INF);
	d[s]=0;
	for(int i=0;i<n;i++){
		int u=-1,MIN=INF;
		for(int j=0;j<n;j++){
			if(vis[j]==false && d[j]<MIN){
				u=j;
				MIN=d[j];
			}
		}
		//找不到小于INF的d[u]，说明剩下的顶点和起点不连通
		if(u==-1) return;
		vis[u] = true;	//访问u为已访问
		//只有下面这个for循环与邻接矩阵的写法不同
		for(int j=0;j<Adj[u].size();j++){
			int v = Adj[u][j].v;		//通过邻接表直接获得u到达的顶点v
			if(vis[v]==false && d[u]+Adj[u][j].dis<d[v]){
				//如果v未被访问，而且 以u为中介点可以使d[v]更优
				d[v] = d[u] + Adj[u][j].dis; //优化d[v]
			}
		}
	}
}

10.4.3 Floyd算法

Floyd用来解决全源最短路径，即对给定的图G（V，E），求任意两点u，v之间的最短路径长度，时间复杂度为O（n3），这个复杂度决定了顶点数n的限制约在200以内，因此使用邻接矩阵来实现Floyd算法是非常合适且方便的

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

const int INF = 10000000000;
const int MAXV = 200;	//MAXV为最大顶点数
int n,m;		//n为顶点数，m为边数
int dis[MAXV][MAXV];			//dis[i][j]表示顶点i和顶点j的最短距离

void Floyd(){
	for(int k=0;k<n;k++){
		for(int i=0;i<n;i++){
			for(int j=0;j<n;j++){
				if(dis[i][k]!=INF && dis[k][j]!=INF && dis[i][k]+dis[k][j]<dis[i][j])
					dis[i][j] = dis[i][k]+dis[k][j];//找到更短的路径
			}
		}
	}
}
int main() {
	int u,v,w;
	fill(dis[0],dis[0]+MAXV*MAXV,INF);	//dis数组赋初始值
	scanf("%d%d",&n,&m);	//顶点数n，边数m
	for(int i=0;i<n;i++){
		dis[i][i]=0;	//顶点i到顶点i的距离初始化为0
	}
	for(int i=0;i<m;i++){
		scanf("%d%d%d",&u,&v,&m);
		dis[u][v] = w;	//以有向图为例输入
	}
	Floyd();	//Floyd算法入口
	for(int i=0;i<n;i++){
		for(int j=0;j<n;j++){
			printf("%d ",dis[i][j]);
		}
		printf("\n");
	}
	return 0;

}

10.5 最小生成树（MST）

Minimum Spanning Tree , MST 是在一个给定的无向图 G（V，E）中求一棵树T，使得这棵树拥有图G中的所有顶点，且所有边都是来自图G中的边，并且满足整棵树的边权之和最小

10.5.1 Prim算法

适合稠密图，加点法

const int MAXV = 1000;
const int INF = 1000000000;

//邻接矩阵版
int n,G[MAXV][MAXV];
int d[MAXV]; 	//顶点与集合s的最短距离
bool vis[MAXV] = {false};

int prim(){		//默认0号位初始点，函数返回最小生成树的边权之和
	fill(d,d+MAXV,INF);
	d[0]=0;
	int ans=0;	//存放最小生成树的边权之和
	for(int i=0;i<n;i++){
		int u=-1,MIN=INF;	//使得d[u]最小，MIN存放该最小的d[u]
		for(int j=0;j<n;j++){	//找到未访问的顶点中d[]最小的
			if(vis[j]==false && d[j]<MIN){
				u=j;
				MIN=d[j];
			}
		}
		//找不到小于INF的d[u]，则剩下的顶点和集合S不连通
		if(u==-1) return -1;
		vis[u] = true;	//标记u为已访问
		ans+=d[u];
		for(int v=0;v<n;v++){
			//v未访问 && u能到达v && 以u为中介点可以使v理集合S更近
			if(vis[v]==false && G[u][v]!=INF && G[u][v]<d[v]){
				d[v] = G[u][v];	//将G[u][v]赋值给d[v]
			}
		}
	}
		return ans;	//返回最小生成树的边权之和
}

//邻接表版
struct Node{
	int v,dis;	//v为边的目标顶点，dis为边权
};
vector<Node> Adj[MAXV];
int n;
int d[MAXV];
bool vis[MAXV] = {false};

int Prim(){
	fill(d,d+MAXV,INF);
	d[0]=0;
	int ans = 0;
	for(int i=0;i<n;i++){
		int u=-1,MIN=INF;
		for(int j=0;j<n;j++){
			if(vis[j]==false && d[j]<MIN){
				u=j;
				MIN=d[j];
			}
		}
		//找不到小于INF的d[u]，则剩下的顶点和集合S不连通
		if(u == -1) return -1;
		vis[u] = true;
		ans += d[u];
		//只有下面这个for循环与邻接矩阵写法不同
		for(int j=0;j<Adj[u].size();j++){
			int v = Adj[u][v].v;	//通过邻接表直接获得u能到达的顶点v
			if(vis[v]==false && Adj[u][j].dis<d[v]){
				//如果v未访问 && 以u为中介点可以使v离集合S更近
				d[v]=G[u][v];
			}
		}
	}
	return ans;
}

10.5.2 Kruskal算法

Kruskal算法采用了边贪心的策略，其思想极其简洁，理解难度比Prim算法低很多

如果是稀疏图，边少，适用于Kruskal，加边法

#include <iostream>
#include <algorithm>
using namespace std;
const int MAXV = 110;
const int MAXE = 10010;

//边集定义部分
struct edge{
	int u,v;		//边的两个端点编号
	int cost; 	//边权
}E[MAXE];	//最多有MAXE条边

bool cmp(edge a,edge b){
	return a.cost<b.cost;
}

//并查集部分
int father[MAXV]; //并查集数组
int findFather(int x){	//并查集查询函数
	int a = x;
	while(x != father[x]){
		x = father[x];
	}
	//到这里，x存放的是根结点。下面把路径上的所有结点的father改成根结点
	while(a != father[a]){
		int z = a;
		a = father[a];
		father[z] = x;
	}
	return x; //返回根节点
}

//Kruskal部分，返回最小生成树的边权之和，参数n为顶点个数，m为图的边数
int Kruskal(int n,int m){
	//ans为所求边权之和，Num_Edge为当前生成树的边数
	int ans=0,Num_Edge=0;
	for(int i=0;i<n;i++){
		father[i]=i;		//并查集初始化
	}
	sort(E,E+m,cmp);	//所有边按边权从小到大排序
	for(int i=0;i<m;i++){
		//枚举所有边
		int faU = findFather(E[i].u);	//查询测试边两个端点所在集合的根结点
		int faV = findFather(E[i].v);
		if(faU != faV){	//如果不在一个集合中
			father[faU] = faV;	//合并集合（即把测试边加入最小生成树中）
			ans += E[i].cost;	//边权之和增加测试边的边权
			Num_Edge++;			//当前生成树的边数加1
			if(Num_Edge == n-1) break;	//边数等于顶点数减1时结束算法
		}
	}
		if(Num_Edge != n-1) return -1;	//无法连通时返回-1
		else return ans;
}

int main() {
	int n,m;
	scanf("%d%d",&n,&m);//顶点数n，边数m
	for(int i=0;i<m;i++){
		scanf("%d%d%d",&E[i].u,&E[i].v,&E[i].cost);
	}
	int ans = Kruskal(n,m);
	printf("%d",ans);
	return 0;
}