Dijkstra(迪杰斯特拉)算法的总结

应用领域

常用于在正权图中求单源最短路，经常是起点到其他点的最短路，最大路，或者是找通路中所有最大边中的最小边（最大），通路中所有最小的边的最大边（最小）等，视情况而定

算法思想：

Dijkstra算法是基于贪心来实现的，例如在求最短路时，有点（1~n）将起点1设为0，然后起点到其他点的值设为无穷，利用当前确定可达最短路来更新其他点，就是是点1到点x的距离是否比当前可达最短路点1到点t和点t到点x更远(有点像绕路比较)，如果更远则更新，每次迭代可确定一个可达最近点，然后将其标记，那么n个点n-1次迭代即可，因为n-1的点的最短路确定了，第n个点的最短路一定被前n-1次迭代所更新成最短路

算法复杂度：

朴素版Dijkstra算法复杂度是$O(N^2)$, 其时间开销主要是存在于每次确定当前可达最小可达最近点

模板题 AcWing 849. Dijkstra求最短路 I

#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;

const int N = 510, INF = 0x3f3f3f3f;  //最大点数
int g[N][N];        //邻接矩阵存边
int dist[N];        //存起点到其他点的最短距离
bool st[N];         //标记是否已经确定

int dijkstra(int n)
{
    memset(st, false, sizeof st);       //所有点最开始的最小值都未确定
    memset(dist, 0x3f, sizeof dist);    //都初始化（1~n）的距离为无穷
    dist[1] = 0;                        //先确定起点最小值
    for(int i = 1; i < n; ++i)          //n-1次迭代，每次固定一个最小值
    {
        int t = -1;
        for(int j = 1; j <= n; ++j)     //找未固定的点中找一个最小距离
            if(!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;
         
        st[t] = true;      //将t固定
        for(int j = 1; j <= n; ++j)
            dist[j] = min(dist[j], dist[t] + g[t][j]);    //看是否能用该点更新最短距离
    }
    return dist[n] == INF ? -1 : dist[n];  //返回1到n的最短距离
}

int main()
{
    int n, m;
    scanf("%d%d", &n, &m);
    
    memset(g, 0x3f, sizeof g);   //0x3f代表没有边
    while(m--)  //读入边
    {
        int u, v, w;
        scanf("%d%d%d", &u, &v, &w);
        g[u][v] = min(g[u][v], w);  //重边取最小
    }
    
    printf("%d\n", dijkstra(n));
    
    return 0;
}

堆优化版Dijkstra算法，因为朴素版Dijkstra时间开销主要来源是每次找未固定的当前最小值$O(N)$，而堆可以在$O(lo{g}_2^N)$找到未确定的最小值，当点数为N,边数为M时其复杂度为$O(Mlo{g}_2^N)$.

模板题 Acwing 850 Dijkstra求最短路 II

#include <iostream>
#include <cstring>
#include <cstdio>
#include <vector>
#include <queue>
using namespace std;

typedef pair<int, int> PII;
const int N = 1.5e5 + 10, M = 1.5e5 + 10, INF = 0x3f3f3f3f;
int e[M], w[M], ne[M], h[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(int n)
{
    memset(st, false, sizeof st);
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    priority_queue<PII, vector<PII>, greater<PII> > heap; //小顶堆，用来存距离和点
    heap.push({dist[1], 1});
    
    while(heap.size())
    {
        int t = heap.top().second; //快速找到最小距离点
        heap.pop();
        
        if(st[t])   continue;   //已经用该点更新过其他点， 无需重复使用
        st[t] = true;   //锁定
        for(int i = h[t]; i != -1; i = ne[i])   //尝试更新t点的邻点
        {
            int j = e[i];
            if(dist[j] > dist[t] + w[i])    //可以更新
            {
                dist[j] = dist[t] + w[i];
                heap.push({dist[j], j});    //加入堆，只用被更新过的点才有可能更新别的点
            }
        }
    }
    return dist[n] == INF ? -1 : dist[n];
}

int main()
{
    int n, m;
    scanf("%d%d", &n, &m);
    
    memset(h, -1, sizeof h);    //头结点一定记得初始化
    while(m--)
    {
        int u, v, w;
        scanf("%d%d%d", &u, &v, &w);
        add(u, v, w);
    }
    
    printf("%d\n", dijkstra(n));
    
    return 0;
}

多敲就能慢慢理解
最短路算法复杂度
链式向前星