最短路径问题C++代码实现

刘艺金

已于 2024-05-09 20:25:09 修改

阅读量290

点赞数 3

文章标签： c++ 图论算法

于 2024-05-09 20:22:31 首次发布

本文链接：https://blog.csdn.net/2301_79249663/article/details/138630061

版权

最短路径：

邻接表存储(单源最短路)：

Dijkstra算法：

//适用于非负权图
#include<iostream>
#include<cstring>
using namespace std;
const int N=1001;
const int M=10001;
struct edge{
	//v表示这条边连接顶点编号
	//w边权 。next下一条边的顶点编号 
	int v,w,next;
	edge(){}
	edge(int _v,int _w,int _next){
		v=_v;
		w=_w;
		next=_next;
	}
}e[M*2]; //这个e数组里就是每一条边 
int head[N],size;
void init(){
	memset(head,-1,sizeof(head));
	size=0; //当前图中一共有多少条边 
}
void insert(int u,int v,int w){
	e[size]=edge(v,w,head[u]);
	head[u]=size;
	size++;
}
void insert2(int u,int v,int w){
	insert(u,v,w);
	insert(v,u,w);
}
int n,m;
int dis[N];  //dis数组表示源点到某个点的最短路径 
bool vis[N]; //表示这个点有没有被标记过 
void dijkstra(int u){
	memset(vis,false,sizeof(vis));
	memset(dis,0x3f,sizeof(dis));  //memset是逐字符赋值的 
	dis[u]=0;
	for(int i=0;i<n;i++){
		// mind两点距离初始是正无穷，minj表示点的编号，初始是-1 
		int mind=1000000000,minj=-1; 
		for(int j=1;j<=n;j++){   //表示顶点编号从1开始 
			if(!vis[j]&&dis[j]<mind){
				minj=j;
				mind=dis[j];
			}
		}
		if(minj==-1){ //不是连通图,直接结束循环 
			return;
		}
		vis[minj]=true;
		for(int j=head[minj];~j;j=e[j].next){ //~j表示j!=-1 
			int v=e[j].v;
			int w=e[j].w;
			if(!vis[v]&&dis[v]>dis[minj]+w){
				dis[v]=dis[minj]+w;
			}
		}
	}	
}
int main(){
	init();//初始化邻接表 
	int u,v,w;
	//n表示源点第n个顶点的最短路径
	//m表示m条无向边 
	cin>>n>>m; 
	while(m--){
		cin>>u>>v>>w;
		insert2(u,v,w); //插入无向边 
	}
	dijkstra(1);   //从第一个顶点开始 
	cout<<dis[n]<<endl;
	return 0;
}
//3 3
//1 2 5
//2 3 5
//3 1 2
//2

SPFA算法：

适用于不带负环的图

设置一个优先队列和一个表，从起点开始找到起点的下n个结点进入优先队列，更新表，然后取出第一个结点找到下个结点更新表，循环直至优先队列为空(类似BFS)

#include<iostream>
#include<cstring>
#include<queue>
using namespace std;
const int N=1e3+9;
const int M=1e4+9;
const int inf=0x3f3f3f3f;
struct edge{
	int v,w,fail;
	edge(){}
	edge(int _v,int _w,int _fail){
		v=_v;
		w=_w;
		fail=_fail;
	}
}e[M<<1];
int head[N],len;
void init(){
	memset(head,-1,sizeof(head));
	len=0;
}
void add(int u,int v,int w){
	e[len]=edge(v,w,head[u]);
	head[u]=len++;
}
void add2(int u,int v,int w){
	add(u,v,w);
	add(v,u,w);
}

int n,m;
int dis[N];
bool vis[N];
void spfa(int u){
	memset(vis,false,sizeof(vis));
	vis[u]=true;
	memset(dis,0x3f,sizeof(dis));
	dis[u]=0;
	queue<int>q;
	q.push(u);
	while(!q.empty()){
		u=q.front();
		q.pop();
		vis[u]=false;
		for(int j=head[u];~j;j=e[j].fail){
			int v=e[j].v;
			int w=e[j].w;
			if(dis[v]>dis[u]+w){
				dis[v]=dis[u]+w;
				if(!vis[v]){
					q.push(v);
					vis[v]=true;
				}
			}
		}
	}
}
int main(){
	init();
	int u,v,w;
	cin>>n>>m;
	while(m--){
		cin>>u>>v>>w;
		add2(u,v,w);
	}
	spfa(1);
	cout<<dis[n]<<endl;
	return 0;
}
//3 3
//1 2 5
//2 3 5
//3 1 2

//可用于判断是否有负环
//一般情况下，spfa判定负环只用在有向图中，因为在无向图上，一条负边权的边就是一个负环了
#include<iostream>
#include<cstring>
#include<queue>
using namespace std;
const int N=1e3+9;
const int M=1e4+9;
const int inf=0x3f3f3f3f;
struct edge{
	int v,w,fail;
	edge(){}
	edge(int _v,int _w,int _fail){
		v=_v;
		w=_w;
		fail=_fail;
	}
}e[M<<1];
int head[N],len;
void init(){
	memset(head,-1,sizeof(head));
	len=0;
}
void add(int u,int v,int w){
	e[len]=edge(v,w,head[u]);
	head[u]=len++;
}
void add2(int u,int v,int w){
	add(u,v,w);
	add(v,u,w);
}

int n,m;
int dis[N],in[N];
bool vis[N];
bool spfa(int u){
	memset(vis,false,sizeof(vis));
	vis[u]=true;
	memset(dis,0x3f,sizeof(dis));
	dis[u]=0;
	queue<int>q;
	q.push(u);
	in[u]++;
	while(!q.empty()){
		u=q.front();
		q.pop();
		vis[u]=false;
		for(int j=head[u];~j;j=e[j].fail){
			int v=e[j].v;
			int w=e[j].w;
			if(dis[v]>dis[u]+w){
				dis[v]=dis[u]+w;
				if(!vis[v]){
					q.push(v);
					vis[v]=true;
					in[v]++;
					if(in[v]>n){
						return true;
					}
				}
			}
		}
	}
	return false;
}
int main(){
	init();
	int u,v,w;
	cin>>n>>m;
	while(m--){
		cin>>u>>v>>w;
		add2(u,v,w);
	}
	if(spfa(1)){
		cout<<"yes"<<endl;//有负环 
	}else{
		cout<<"no"<<endl;//无负环 
	}
	return 0;
}
//3 3
//1 2 5
//2 3 5
//3 1 2 输出no

//4 4
//1 2 1
//2 3 1
//1 3 -3
//3 4 1  输出yes

邻接矩阵存储(多源最短路)：

Floyd算法(dp)：

//只能解决不带负环的图，可以解决带负边权的图
#include<iostream>
#include<cstring>
using namespace std;
const int N=101;
int g[N][N];
void floyd(int n){
	for(int k=1;k<=n;k++){
		for(int i=1;i<=n;i++){
			for(int j=1;j<=n;j++){
				g[i][j]=min(g[i][j],g[i][k]+g[k][j]); 
			}
		}
	}
}
int main(){
	//用邻接矩阵存储 
	memset(g,0x3f,sizeof(g));
	for(int i=0;i<N;i++){
		g[i][i]=0;  //不存在自环 
	}
	int n,m;
	int u,v,w;
	cin>>n>>m;
	while(m--){
		cin>>u>>v>>w;
		g[u][v]=g[v][u]=w;
	} 
	floyd(n);
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			cout<<g[i][j]<<" ";
		}cout<<endl;
	}
	return 0;
}
//3 3
//1 2 5
//2 3 5
//3 1 2