【模板】Dijkstra算法_dijkstra算法模板-优快云博客

知识点：

Dijkstra 算法用于求解单元最短路，而且所有边都是正权边

当 m 和 n^2 是一个级别，叫稠密图（边数比较多的情况）

当 n 和 m 是一个级别，叫稀疏图。（点和边的数量差不多一样多）

稠密图用邻接矩阵，稀疏图用邻接表

朴素版Dijkstra

时间复杂度 O(n^2)

声明：朴素版的Dijkstra算法与边数无关，因此适用于边数比较多的稠密图

稠密图利用邻接矩阵来存储

int n,m; 
int g[N][N];

scanf("%d%d",&n,&m);
    
    memset(g,0x3f,sizeof g);  //初始化- 解决自环和重边的问题
    
    //读入每一条边
    while(m--){
        int a,b,c;
        scanf("%d%d%d",&a, &b, &c);
        g[a][b] = min(g[a][b],c);    
    }

思路：

1.首先把所有距离初始化为无穷大；

2.dist[1] = 0; //起点自己到自己的距离为0；

2.共有n个顶点，迭代n次，确定n个点的最短路径

在每一次迭代过程中：（1）未确定最短路的点中找距离最近的点（遍历所有点，循环n次）

（2）用该点来更新其他点到起点的所有距离 (遍历所有边，循环m次）

C++代码：

#include <bits/stdc++.h>
using namespace std;

const int N = 510;

int n,m;
int g[N][N];  //稠密图用邻接矩阵
int dist[N];  //确定每一个点到起点的最短距离
bool st[N];   //是否已经确定最短距离

int dijkstra(){
    memset(dist,0x3f,sizeof dist);
    
    dist[1] = 0;  
    
    //n次迭代，在每一次迭代中确定n个点的最短路径
    for(int i = 1; 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] == 0x3f3f3f3f) return -1;
    else return dist[n];
}
int main(){
    scanf("%d%d",&n,&m);
    
    memset(g,0x3f,sizeof g);
    
    while(m--){
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        g[a][b] = min(g[a][b],c);
    }
    int t = dijkstra();
    
    printf("%d\n",t);
    
    return 0;
}

堆优化版的Dijkstra算法：

优化部分：

首先分析朴素版的dijkstra()

//迭代n次，确定n个点的最短距离
for(int i = 1; i <= n; i++)   

每一次循环，遍历n个点，需要循环 n次  ------- 时间复杂度为O(n^2)

st[t] = true;   

确定当前所有点中距离最短的点O(1),总共确定n个点 ------- 时间复杂度为O(n)

for(int j = 1; j <= n; j++)   

遍历所有的边，因此实际循环m次        --------时间复杂度O(m)

需要优化的部分就是找下一个距离最小的点

如何优化呢？

这里我们可以采用堆来进行优化，也就是利用小根堆来维护当前最小的距离以及顶点的信息

需要维护距离以及顶点的信息，因此我们用pair来存储

typedef pair<int,int> PII;

priority_queue<PII,vector<PII>,greater<PII> > q;  //小根堆

这样找下一个距离最小的点的时间复杂度从O(n^2) --> O(1)，共有n个点 O(n);

由于堆中修改1个数的时间复杂度为logn,总共修改m条边，因此总共的时间复杂度为O(mlogn)

需要注意的点：

如果我们手写堆，那么可以保证堆中只有n个数，（手写堆支持修改队中的元素），但是需要映射，写起来比较复杂；

因此我们可以采用STL中的优先队列priority_queue 来实现，

优先队列中的元素个数为m个，

即每一次修改，往堆里插入新的元素，这样会出现冗余的现象

因此我们需要判断当前点是否已经确定的最短距离的点，如果是，则说明当前点就是冗余备份的。

C++代码：

#include <bits/stdc++.h>
using namespace std;

const int N = 1e6 + 10;
typedef pair<int,int>PII;

int n,m;
int h[N],e[N],w[N],ne[N],idx;
int dist[N];
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(){
    priority_queue<PII,vector<PII>,greater<PII> >q; //小根堆
    
    memset(dist,0x3f,sizeof dist);
    
    dist[1] = 0;
    q.push({0,1});
    
    while(!q.empty()){
        int ver = q.top().second;  //取出当前距离最小的点的编号
        q.pop();                  //一定要出队
        
        if(st[ver]) continue;
        st[ver] = true;   // 当前点已经确定最短距离
        
        for(int i = h[ver]; i != -1; i = ne[i]){
            int j = e[i];
            if(dist[j] > dist[ver] + w[i]){
                dist[j] = dist[ver] + w[i];
                q.push({dist[j],j});
            }
        }
    }
    if(dist[n] == 0x3f3f3f3f) return -1;   //说明不是连通图
    return dist[n];
    
    
}
int main(){
    scanf("%d%d",&n,&m);
    
    memset(h,-1,sizeof h);
    
    while(m--){
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        add(a,b,c);
    }
    int t = dijkstra();
    printf("%d",t);
    
    return 0;
}