最短路径模板——dijkstra算法

dijkstra算法

有向带权图的单源最短路，适用于找所有点到某一个顶点 i 的最短路径。
适用范围：所有边权都是正数的图。且允许存在回路。
分为朴素dijkstra算法和堆优化dijkstra算法两种。

dijkstra算法思想：
将顶点分为两类：已经统计过最短路径的顶点集合s和没有统计过最短路径的顶点。
利用贪心的思想，每次从不在 集合s 的顶点中找到距离 i 最近的顶点 j，将其加入s，然后更新从 j 出发能到达的点 到 顶点i 的距离，取最小值，这样循环n次，n个顶点都加入集合s了。

朴素算法和堆优化算法的算法差距就在于 从不在 集合s 的顶点中找到距离 i 最近的顶点 j。

朴素算法适用于稠密图，采用邻接矩阵存储，时间复杂度O(n²)

g[i][j]=x，表示i->j的距离为x

堆优化算法适用于稀疏图，采用邻接表存储，时间复杂度O(mlogn)

n 点数 m 边数

分析：重边、自环对dijkstra算法的影响

环路。
自环：自身到自身的情况；以及环路
自己肯定不会往自己更新，只会由别人更新到自己，因为当更新自己到别的点的距离时，自己已经加入集合s，成为已经统计过最短距离的点了，不管更不更新都无效了。
环路是自环的一般情况，假如图中存在环路，根据dijkstra的思想，他也不会走环当到达环的最后一个结点要走环时，说明前面的结点已经加入集合s了，不会再在考虑的范畴内了，也不会进行更新距离，因为只会考虑不在集合s中的情况

重边，好处理，两点之间有多条边时，取最短的边即可。

题目描述

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

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

输入格式
第一行包含整数n和m。

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

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

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

输入样例：

3 3
1 2 2
2 3 1
1 3 4

输出样例：

3

朴素dijkstra算法

数据范围
1≤n≤500,
1≤m≤10⁵,
图中涉及边长均不超过10000。

分析：
n个顶点，有向图最多n×(n-1)条)<不考虑重边、自环>，n²等于2.5e5，m等于1e5，m和n²一个级别，是稠密图，采用邻接矩阵存储。

#include <iostream>
#include <cstring>

using namespace std;

const int N=510,INF=0x3f3f3f3f;
int g[N][N];
int dis[N];
bool vis[N]; //判断该结点是否已加入统计完最短路径的集合s，初始时为false，均未加入
int n,m;//n个点 m条边

void dijkstra(int s)//处理 1号结点->所有结点 的最短路径
{
    memset(dis,0x3f,sizeof dis);
    dis[s]=0;  //s到自身距离为0
    //最多循环n次，每次选出一个距离1号结点最近的结点，可求出每个结点到s结点的距离
    //第一次选出的一定是s结点自己
    int num=n;
    while (num--) {
        int t=-1; //最终选出的t号结点，先初始化为小于1的结点(因为正常的结点是从1号开始)
        for (int i=1;i<=n;i++) {
            if (!vis[i] && (t==-1 || dis[i]<dis[t])) t=i;
        }
        
        if (t==n) break; 
        这题特定的结束条件：我们只需求1->n结点的最短路径。
        此时到了n号结点，但是仍不能确定dis[t]的值是不是无穷大，设想一下：n个顶点，0条边的情况。
        
        vis[t]=true;
        //接下来更新 s->其它结点 通过t结点的最短距离
        for (int i=1;i<=n;i++) {
            if (!vis[i]) { 只需更新不在集合中的结点，但是if条件可省略
                dis[i]=min(dis[i],dis[t]+g[t][i]);
            }  若i是已经记录过最短路径的点，因为t后于i加入集合，所以dis[i]<=dis[t]必然成立(贪心),所以这里不需要!vis[j]的判断
        }
    }
}

int main()
{
    scanf("%d%d",&n,&m);
    //初始化邻接矩阵，规定自身到自身距离为0，但是求最短路时自环的边无效，可以不用初始化。
    memset(g,0x3f,sizeof g);
    //存储边
    int a,b,w;
    while (m--) {
        scanf("%d%d%d",&a,&b,&w);
        g[a][b]=min(g[a][b],w);//处理重边的情况，取最小值的边，同时忽略自环
    }
    dijkstra(1); //求1号点到所有点的最短距离。
    dis[n]==INF?cout<<"-1":cout<<dis[n]; //输出1号顶点到n号顶点的最短距离
    
    return 0;
}

dis数组存储的是s结点到所有结点的最短路径之和，它基于贪心的思想，每次选出一个距离s结点最近的结点。
因此在while(num–)num次循环的时候，每次选出的dis[ ]数组的值是依次增大的。

所以第31行到第34之间中if (!vis[i]) { dis[i]=min(dis[i],dis[t]+g[t][i]);} if 判断可以加也可以不加。
因为如果 i 结点是已经加入集合s的结点，那么必有dis[i] <= dis[t] ，且图中的边的权值都是正数，所以dis[i]是不会被影响的。

堆优化dijkstra算法

堆优化算法是将上面的21 22 23行进行优化，利用最小堆，每次直接取出距离最小的顶点，而不用再经过n次循环确定。

堆中需要记录的信息要由结点和距离，然后按照距离排序。因此利用pair<int,int>，第一个存储距离，第二个存储顶点编号。取出之后，就要进行更新距离，更新完后的距离要对dis数组进行修改，但是还有一个问题：如果该结点已经存在于堆中了，那就又要涉及堆的修改了，根据第二个关键字。堆的修改stl容器的堆无法实现，虽然可以通过手写堆实现，但是比较复杂。

因此，我们不修改了，将其再一次插入堆中，这样的做法是，不用手写堆了，但是堆中的元素冗余了，堆中可能存在多个相同顶点但是距离不同的元素，原来堆中最多可能存在N个元素(因为最多N个顶点)，现在可能更多了，不过这没有影响，每个顶点只会根据它最短距离那次只更新距离一次，可以通过vis数组判断该顶点是不是已经加入已知最短路径的集合，从而避免重复。

另外有一点注意：
朴素做法中，最多循环n次就可以确定 i 结点到其它所有结点的最短距离。
堆优化做法中理论上应该也是的，但是我们用插入操作代替了修改了操作，所以也就是说可能一个结点会被重复好几次，虽然只会距离最短那一次有效，后面都通过vis数组过滤掉了，如果存在不可达顶点INF，那么它就要被放在所有顶点的后面了。
所以，堆优化做法有两个终止条件：队列不为空 || vis数组统计的true的个数小于n。

数据范围：
1≤n,m≤1.5×10⁵ ,
图中涉及边长均不小于0，且不超过10000。

m和n是一个级别的，是稀疏图，采用邻接表存储，堆优化。

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

using namespace std;

typedef pair<int,int> PII; //first表示距离，second表示节点编号，按距离升序排列，每次选出最小的
priority_queue< PII,vector<PII>,greater<PII> >heap;
const int N=2e5,INF=0x3f3f3f3f;
int h[N],e[N],w[N],ne[N],idx;
int dis[N];
bool vis[N];
int n,m;

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

void dijkstra(int s)
{
    memset(dis,0x3f,sizeof dis);
    dis[s]=0;
    
    heap.push({dis[s],s});
    int num=n;   n在后面还要用到，不能修改，因此用num替代
    while(heap.size() && num) { //当队列不空时 或者 成功计数小于n次
        PII t=heap.top();
        heap.pop();
        //每次取出距离s最近的结点，然后开始更新距离
        int v=t.second,d=t.first;   //s->v的最短距离为d
        if (vis[v]) continue; //已经更新过，重复更新的情况跳过，否则
        vis[v]=true,num--;//还剩下n个点未统计
        for (int i=h[v];i!=-1;i=ne[i]) {
            int j=e[i];
            if (!vis[j] && dis[j]>d+w[i]) { //同理，if条件可省略
                dis[j]=d+w[i];
                heap.push({dis[j],j});
            }
        }
    }
}

int main()
{
    memset(h,-1,sizeof h);
    scanf("%d%d",&n,&m);
    int a,b,c;
    while (m--) {
        scanf("%d%d%d",&a,&b,&c);
        add(a,b,c);
    }
    dijkstra(1);
    dis[n]==INF?puts("-1"):printf("%d",dis[n]);
    
    return 0;
}

在第25行时，只把起点s放入堆中了，本来还应该剩下的顶点都放进去，然后进行更新就行了，但是stl中的堆不能实现按关键字更新，而是用了插入代替更新，所以剩下的点就不放入了，更新到时再放入。

关于27行的while判断，两个判断条件： while(heap.size() && num)
这是由于冗余元素的出现，使得n次循环就结束不可能，可能在n次循环里堆中的顶点是已经求过最短距离的点了，这次循环就是无效的，因此只有经过有效的n次循环才行，同时有条件heap.size()是为了防止堆在有效n次循环前就null了的情况，想像一种情况，非连通图：n各顶点，0条边，在第二次循环的时候堆就空了，却还要循环，PII t=heap.top();就出现了问题，会TLE。

如果是手写堆，可以更新的情况下，那么循环n次就够了，刚开始时就可以把所有点都放入堆中。