求单源最短路径及距离——dijkstra模板

Tinex589

已于 2023-07-15 11:51:35 修改

阅读量125

点赞数

CC 4.0 BY-SA版权

分类专栏：算法 # 图论文章标签：算法

于 2023-07-13 16:22:30 首次发布

本文链接：https://blog.csdn.net/weixin_60344133/article/details/131702748

算法同时被 2 个专栏收录

11 篇文章

订阅专栏

图论

2 篇文章

订阅专栏

文章介绍了Dijkstra算法的基本思想和优化方法，通过使用优先队列（堆）来提高效率，实现单源最短路径问题。提供了两种C++代码实现，一种计算所有节点到源点的最短路径，另一种则在找到最短路径的同时记录路径信息。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

关于dijkstra的介绍，可以阅读这篇文章
算法之迪杰斯特拉（dijkstra）非常详细介绍

在这里使用<后继，权值>的结构体edge来构建邻接表G。dis表示源点到各点的距离。 题中结点编号为 1~n，为方便这里以 0~n-1 的编号进行处理，再以1~n的编号输出

堆优化dijkstra求最短路径的距离（若不可达，输出URA，即 $2^{31}-1$ ）

思想：因为dijkstra有个不断选出源点到未访问点最短的路径的过程，所以可以使用堆（priority_queue）对距离进行排序，这个距离是通过构建pair<距离，后继>实现的，堆会对pair.first进行排序。值得注意的是，选取的堆顶距离若不是最小值，说明入队之后该点又经过最小值的更新，堆顶这个值不是当前的最小距离，所以舍弃这个值。这种方法不需要辅助数组vis判断是否访问过。
使用堆优化后，复杂度为 $O (∣ E ∣ l o g ∣ V ∣)$ 。

例题：
洛谷-【模板】单源最短路径（弱化版）
洛谷-【模板】单源最短路径（标准版）

#include<iostream>
#include<queue>
#include<vector>
using namespace std;
const int MAX_N=1e4+10;
const int INF=1e9+10;
const int URA=(2<<30)-1;
typedef pair<int,int> pii;
struct edge
{
	int to,cost;	
	edge(int t,int c):to(t),cost(c){}
};
int n,m,s;
int dis[MAX_N];
vector<edge> G[MAX_N];
void dijkstra(int s)//s：源点
{
	priority_queue<pii,vector<pii>,greater<pii>>q;
	for(int i=0;i<n;i++)
		dis[i]=INF;
	dis[s]=0;
	q.push(pii(0,s));
	while(!q.empty())
	{
		pii p=q.top();
		q.pop();
		int u=p.second;
		if(dis[u]<p.first)//若堆顶的距离不是最小值，说明入队之后又经过最小值的更新
			continue;
		for(int i=0;i<G[u].size();i++)
		{
			int v=G[u][i].to;
			if(dis[u]+G[u][i].cost<dis[v])
			{
				dis[v]=dis[u]+G[u][i].cost;
				q.push(pii(dis[v],v));
			}
		}
	}
}
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	cin>>n>>m>>s;
	int u,v,w;
	while(m--)
	{
		cin>>u>>v>>w;
		G[u-1].push_back(edge(v-1,w));
	}
	dijkstra(s-1);
	for(int i=0;i<n;i++)
		cout<<(dis[i]==INF?URA:dis[i])<<" ";
	return 0;
}

求其中一条1到n的最短路径（若不可达，仅输出-1）
思想：在原基础上设置前趋数组pre，当某个点更新最短距离时，使用pre保存其前趋结点，dijkstra运算结束后，可以从结点n往上回溯，由于回溯的顺序和输出顺序相反，所以使用栈stack保存和输出。

例题：codeforces-Dijkstra?

#include<iostream>
#include<vector>
#include<queue>
#include<stack>
using namespace std;
typedef long long ll;
typedef pair<ll,int> pli;
const ll INF=9e13+7;
const int MAX_N=1e5+10;
struct edge
{
	int to;
	ll cost;	
	edge(int t,ll c):to(t),cost(c){}
};
int n,m;
int pre[MAX_N];//记录每个点的前驱结点
ll dis[MAX_N];
vector<edge> G[MAX_N];//邻接表
void dijkstra(int s)
{
	priority_queue<pli,vector<pli>,greater<pli> > q;
	for(int i=0;i<n;i++)
	{
		dis[i]=INF;
		pre[i]=-1;
	}
	dis[s]=0;
	q.push(pli(0,s));
	while(!q.empty())
	{
		pli p=q.top();
		q.pop();
		int u=p.second;
		if(p.first>dis[u])
			continue;
		for(int i=0;i<G[u].size();i++)
		{
			int v=G[u][i].to;
			if(dis[v]>G[u][i].cost+dis[u])
			{
				dis[v]=G[u][i].cost+dis[u];
				q.push(pli(dis[v],v));
				pre[v]=u;//记录前趋
			}
		}
	}
}
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	cin>>n>>m;
	int u,v,w;
	while(m--)
	{
		cin>>u>>v>>w;
		G[u-1].push_back(edge(v-1,w));
		G[v-1].push_back(edge(u-1,w));
	}
	dijkstra(0);
	if(dis[n-1]==INF)
		cout<<-1<<"\n";
	else
	{
		int i=n-1;
		stack<int> s;
		while(i!=-1)
		{
			s.push(i);
			i=pre[i];
		}
		while(!s.empty())
		{
			cout<<s.top()+1<<" ";
			s.pop();
		}
	}
	return 0;
}