最短路-----图论

最新推荐文章于 2025-12-28 18:00:24 发布

原创最新推荐文章于 2025-12-28 18:00:24 发布 · 1.2k 阅读

21 ·

CC 4.0 BY-SA版权

文章标签：

#图论 #算法 #dijkstra #spfa #bellman-ford #Floyd #c++

部署运行你感兴趣的模型镜像

一、朴素版的Dijkstra算法

O(n^2)
1.初始化,dis[1]=0,dist[i]=正无穷(比较大的数) Si存当前已经确定最短距离的点
2.(迭代)for i:0~n
   (1)t=找到不在s中的距离最近的点       O(n^2)
   (2)t加到s中                           O(n);
   (3)用t更新其他点的距离       从t出去的所有的边是否可以用t更新dis[x]>dis[t]+W(权重) O(m);
代码如下：

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=510;
int n,m;
int g[N][N];//用邻接矩阵存边长
int dist[N];//表示从1号点走到当前这个点的最短距离
bool st[N];

int dijkstra(){
	memset(dist,0x3f,sizeof(dist));
	dist[1]=0;
	for(int i=0;i<n;i++){
		int t=-1;
		for(int j=1;j<=n;j++)
			if(!st[j]&&(t==-1||dist[t]>dist[j]))
				t=j;

		st[t]=true;
		for(int j=1;j<=n;j++){
			dist[j]=min(dist[j],dist[t]+g[t][j]);
		}
		
	}
	if(dist[n]==0x3f3f3f)return -1;
	return dist[n];
}

int main(){
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	cin>>n>>m;
	memset(g,0x3f,sizeof(g));
	while(m--){
		int a,b,c;
		cin>>a>>b>>c;
		g[a][b]=min(g[a][b],c);
	}
	int t=dijkstra();
	cout<<t<<endl;
}

二、堆优化版的Dijkstra算法步骤

O(mlogn)
1.初始化,dis[1]=0,dist[i]=正无穷(比较大的数) Si存当前已经确定最短距离的点
2.(迭代)for i:0~n
   (1)t=找到不在s中的距离最近的点       O(n)
   (2)t加到s中                           O(n);
   (3)用t更新其他点的距离       从t出去的所有的边是否可以用t更新dis[x]>dis[t]+W(权重) O(mlogn);

#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
const int N=1e5+10;
typedef pair<int,int>PII;
int n,m;
int h[N],w[N],e[N],ne[N],idx;//用邻接表存,w[N]权重
int dist[N];//表示从1号点走到当前这个点的最短距离
bool st[N];

void add(int a,int b,int c){
	e[idx]=b,w[idx]=c;ne[idx]=h[a],h[a]=idx++;
}

int dijkstra(){
	memset(dist,0x3f,sizeof(dist));
	dist[1]=0;
	
	priority_queue<PII,vector<PII>,greater<PII>> heap;	//小根堆	//(元素类型，容器，比较器)
	heap.push({0,1});
	
	while(heap.size()){
		auto t=heap.top();
		heap.pop();
		int ver=t.second,distance=t.first;
		if(st[ver])continue;
		st[ver]=true;
		for(int i=h[ver];i!=-1;i=ne[i]){
			int j=e[i];
			if(dist[j]>distance+w[i]){
				dist[j]=distance+w[i];
				heap.push({dist[j],j});
			}
		}
	}
	
	if(dist[n]==0x3f3f3f)return -1;
	return dist[n];
}

int main(){
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	cin>>n>>m;
	memset(h,-1,sizeof(h));
	while(m--){
		int a,b,c;
		cin>>a>>b>>c;
		add(a,b,c);
	}
	int t=dijkstra();
	cout<<t<<endl;
}

三、Bellman_Ford 算法

有边数限制用Bellman_Ford 算法   O(nm)
Bellman_Ford 算法 O(nm)       （存边方式：结构体）循环完后所有边满足三角不等式：d[b]<=d[a]+w
思路：   1.迭代n次，           //迭代k次，经过不超过k条边的最短路的距离
           备份一份d(否则可能发生串联)，为了保证更新点的距离只用上一次的d
       2.循环每一条边，从a到b，权重为w
       3.d[b]=min(d[b],d[a]+w);
Bellman_Ford 算法可以知道有没有负权回路，但找负权回路用SPFA

#include<iostream>
#include<algorithm>
#include<cstring>

using namespace std;

const int N=510,M=10010;
int n,m,k;
int dist[N],backup[N];//backup备份d

struct Edge
{
	int a,b,w;
}edges[M];

int bellman_ford(){
	memset(dist,0x3f,sizeof dist);
	dist[1]=0;
	for(int i=0;i<k;i++){
		memcpy(backup,dist,sizeof dist);
		for(int j=0;j<m;j++){
			int a=edges[j].a,b=edges[j].b,w=edges[j].w;
			dist[b]=min(dist[b],backup[a]+w);
		}
	}
	if(dist[n]>0x3f3f3f3f/2)return 0x3f3f3f3f;
	return dist[n];
}
int main(){
	cin>>n>>m>>k;
	for(int i=0;i<m;i++){
		int a,b,w;
		cin>>a>>b>>w;
		edges[i]={a,b,w};
	}
	int t=bellman_ford();
	if(t==0x3f3f3f3f)puts("impossible");
	else cout<<t<<endl;
}

四、spfa算法

SPFA算法   一般O(m),最坏O(nm)   (Bellman-ford算法的优化用宽搜)
思路：   1.迭代n次，           //迭代k次，经过不超过k条边的最短路的距离
       2.循环每一条边，从a到b，权重为w
       3.d[b]=min(d[b],d[a]+w);   //只有d[a]变小，d[b]才会变小

   优化：迭代时用队列做
   1.迭代时将起点放入队列
   2.while (!q.empty())
           t=q.front;q.pop();
           更新t的所有初边
           更新成功，如果队列中没有，将b加入队列;

#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>

using namespace std;
const int N=1e5+10;
typedef pair<int,int>PII;
int n,m;
int h[N],w[N],e[N],ne[N],idx;//用邻接表存,w[N]权重
int dist[N];//表示从1号点走到当前这个点的最短距离
bool st[N];

void add(int a,int b,int c){
	e[idx]=b,w[idx]=c;ne[idx]=h[a],h[a]=idx++;
}

int spfa(){
	memset(dist,0x3f,sizeof(dist));
	dist[1]=0;
	queue<int> q;
	q.push(1);
	st[1]=true;
	while(q.size()){
		int t=q.front();
		q.pop();
		st[t]=false;
		for(int i=h[t];i!=-1;i=ne[i]){
			int j=e[i];
			if(dist[j]>dist[t]+w[i]){
				dist[j]=dist[t]+w[i];
				if(!st[j]){
					q.push(j);
					st[j]=true;
				}
				
			}
		}
	}
	return dist[n];
}

int main(){
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	cin>>n>>m;
	memset(h,-1,sizeof(h));
	while(m--){
		int a,b,c;
		cin>>a>>b>>c;
		add(a,b,c);
	}
	int t=spfa();
	if(t==0x3f3f3f3f)puts("impossible");
	else cout<<t<<endl;
}

spfa算法判断负环

在spfa算法的基础上加一个cnt数组记录边数,n个点最多有n-1条边，当cnt[j]>=n时，说明有负环。

#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>

using namespace std;
const int N=1e5+10;
typedef pair<int,int>PII;
int n,m;
int h[N],w[N],e[N],ne[N],idx;//用邻接表存,w[N]权重
int dist[N];//表示从1号点走到当前这个点的最短距离
bool st[N];
int cnt[N];//边数

void add(int a,int b,int c){
	e[idx]=b,w[idx]=c;ne[idx]=h[a],h[a]=idx++;
}

bool spfa(){
	
	queue<int> q;
	for(int i=1;i<=n;i++){
		st[i]=true;
		q.push(i);
	}
	st[1]=true;
	while(q.size()){
		int t=q.front();
		q.pop();
		st[t]=false;
		for(int i=h[t];i!=-1;i=ne[i]){
			int j=e[i];
			if(dist[j]>dist[t]+w[i]){
				dist[j]=dist[t]+w[i];
				cnt[j]=cnt[t]+1;
				if(cnt[j]>=n)return true;
				if(!st[j]){
					q.push(j);
					st[j]=true;
				}
				
			}
		}
	}
	return false;
}

int main(){
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	cin>>n>>m;
	memset(h,-1,sizeof(h));
	while(m--){
		int a,b,c;
		cin>>a>>b>>c;
		add(a,b,c);
	}
	if(spfa())puts("Yes");
	else cout<<"No"<<endl;
}

五、Floyd算法

Floyd算法 O(n^3)   //基于动态规划d[k][i][j]=d[k-1][i][k]+d[k-1][k][j] -> d[i][j]=d[i][k]+d[k][j]
d[i][j]存所有边
三层循环
   for(k:1~n)
       for(i:1~n)
           for(j:1~n)
               d[i][j]=min(d[i][j],d[i][k]+d[k][j]);

#include<iostream>
#include<cstring>
#include<algorithm>

using namespace std;
const int N=210,INF=1e9;
int n,m,Q;
int d[N][N];
void floyd(){
	for(int k=1;k<=n;k++)
		for(int i=1;i<=n;i++)
			for(int j=1;j<=n;j++)
				d[i][j]=min(d[i][j],d[i][k]+d[k][j]);
}
int main(){
	cin>>n>>m>>Q;
	for(int i=1;i<=n;i++)
		for(int j=1;j<=n;j++)
			if(i==j)d[i][j]=0;
			else d[i][j]=INF;
	while(m--){
		int a,b,w;
		cin>>a>>b>>w;
		d[a][b]=min(d[a][b],w);
	}
	floyd();
	while(Q--){
		int a,b;
		cin>>a>>b;
		if(d[a][b]>INF/2)puts("impossible");
		else cout<<d[a][b]<<endl;
	}
}

您可能感兴趣的与本文相关的镜像