dijkstra求最短路问题

在图中，从一个点到另一个点的路径可能不止一条，每条路径的长度也不一定相同，最短路就是两点之间可达路径上各边的权值总和最小的路径上各边的权值和。

对于最短路问题常常有两种情况，一种是单源最短路问题，另一种是多源最短路问题，单源最短路问题就是求从一个顶点出发到其他各顶点之间的最短路径问题，而多源最短路问题是求每对顶点之间的最短路径。

今天要说的dijkstra算法就是典型的求单源最短路问题：

算法的基本思想：

先选定一个顶点，我们称之为源点，然后用与源点相连的边去更新其他点到源点的距离，然后找离这个源点最近的一个点并对其做出标记，然后在用这个点重复上述操作，直到所有的点都被做出标记为止。

在这引入学长的PPT吧，使得大家对这个基本思想理解的更深刻（以下图片均引用学长PPT），学长写的真的是非常棒。

dist[i]代表i号点到源点的距离（源点是不会变的）

vis[i]用于标记i号点是否在顶点集S中

pre[i]用于记录路径，里面存有i节点的前驱节点

 算法实现步骤：

（1）不妨以1号点为源点，就初始化dist[1]=0，其余结点设置为正无穷大。

（2）找出一个未被标记的dist最小的点x，然后用点x进行更新所有与x有边相连的点到源点的距离，更新完后标记x。

（3）重复以上操作，直至所有节点被标记。

 依靠pre数组我们可以输出源点到每一个点的路径。

路径输出代码：

for(int i=1;i<=n;i++) pre[i]=i;//初始化每个点的前驱节点为自己

void print(int s,int v)//s为起点，v为当前节点(从终点递归) 
{
	if(s==v)//递归边界 
	{
		printf("%d ",s);
		return ;
	} 
	print(s,pre[v]);//注意递归顺序 
	printf("%d ",v);
}

算法核心代码：

void Dijkstra()
{
    memset(dist,0x3f,sizeof(dist));//将 
    dist[1]=0;//将源点初始化为0 
    for(int i=1;i<n;i++)
    {
        int t=-1;
        for(int j=1;j<=n;j++)//找出未被标记的距离源点最近的点 
            if(!vis[j]&&(t==-1||dist[t]>dist[j]))
                t=j;
        vis[t]=true;//标记为已加入集合S 
        for(int j=1;j<=n;j++)
            {
            	if(dist[t]+w[t][j]<dist[j])//用新加入集合S的点更新其他点到源点的距离 
            	{
            		dist[j]=d[t]+w[t][j];
            		pre[j]=t;//标记节点前驱节点 
				}
			}
    }
}

从上面的代码实现上不难发现代码的复杂度是o（n^2）的，那能不能对朴素版的dijkstra算法做出优化呢？答案是YES，我们可以看到在找出未被标记的距离源点最近的点时我们是一个一个遍历的，那我们就可以在找点时用一个优先队列来维护他，从而使复杂度降至nlogn

下面是核心代码（输出路径函数一样）：

void Dijkstra()
{
    memset(d,0x3f,sizeof(d));//将 
    dist[1]=0;//将源点初始化为0 
    priority_queue<PII,vector<PII>,greater<PII> >q;//用优先队列存储其他点，到源点的距离作为优先级 
    q.push({0,1});//将源点加入队列中 
    while(!q.empty())
    {
        int distance=q.top().first,begin=q.top().second;
        q.pop();
        if(vis[begin]) continue;//如果这个点已经在集合S中，那我们没必要对他进行再次遍历 
        vis[begin]=1;//标记为已经加入集合S 
        for(int i=h[begin];i!=-1;i=ne[i])
        {
            int j=e[i];
            if(d[j]>d[begin]+w[i])//用新加入集合S的点遍历未加入集合S的点 
                {
                    d[j]=d[begin]+w[i];
                    q.push({d[j],j});
                    pre[j]=begin;//标记路径 
                }
        }
    }
}

相信大家对dijkstra算法已经有了一定的了解，下面给出一道例题并给出解答：

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，所有边权均为非负值。

请你求出 1 号点到 n 号点的最短距离，如果无法从 1号点走到 n 号点，则输出 −1。

输入格式

第一行包含整数 n 和 m。

接下来 m 行每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。

输出格式

输出一个整数，表示 1 号点到 n 号点的最短距离。

如果路径不存在，则输出 −1。

数据范围

1≤n,m≤1.5×10^5
图中涉及边长均不小于 0，且不超过 10000。

输入样例：

3 3
1 2 2
2 3 1
1 3 4

输出样例：

3

#include<iostream>
#include<cstring>
#include<queue>
using namespace std;
typedef pair<int,int> PII;
const int N=1e6+10;
int n,m;
//h[i]记录头节点,w[i]记录权重,e[i]记录终边,ne[i]用于遍历链条 
int h[N],w[N],e[N],ne[N],d[N],idx;
bool vis[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(d,0x3f,sizeof(d));
    d[1]=0;
    priority_queue<PII,vector<PII>,greater<PII> >q;
    q.push({0,1});
    while(!q.empty())
    {
        int distance=q.top().first,begin=q.top().second;
        q.pop();
        if(vis[begin]) continue;
        vis[begin]=1;
        for(int i=h[begin];i!=-1;i=ne[i])
        {
            int j=e[i];
            if(d[j]>d[begin]+w[i])
                {
                    d[j]=d[begin]+w[i];
                    q.push({d[j],j});
                }
        }
    }
    if(d[n]!=0x3f3f3f3f) return d[n];
    return -1;
}
int main()
{
    cin>>n>>m;
    memset(h,-1,sizeof(h));idx=1;
    int x,y,z;
    while(m--)
    {
        cin>>x>>y>>z;
        add(x,y,z);
    }
    int ans=dijkstra();
    cout<<ans;
    return 0;
} 

最后，提醒大家一点，dijkstra算法要求图中不能出现权值为负的边，其实也很容易理解，就是我们算法是利用贪心的思想，每次选取当前为加入集合S且离源点最近的点，我们所参考的边只是当前集合S中所有的点所连接的边，但是若在非集合S中的点之间出现负权边的话，有可能会形成负权回路，也就是说经过这个圈后反而路径权值和变小了，这是dijkstra算法所不能解决的，这也是他的局限性所在，这个问题是可以通过spfa算法解决，我将在以后的博客中给出介绍。

欢迎大家在评论区中讨论！