图论——最短路算法笔记 djkstra

一. 单源最短路 

1. 边权为正

（1）朴素版dijkstra算法（基于稠密图）

算法原理：维护一个S集合，存放已经确定最短距离的点（从指定起点到当前点），循环n次，每次从S集合外，取出距离最近的点 t，将 t 加进S集合，然后用 t 点，更新起点到其他所有点的距离

// dijkstra朴素版
#include <iostream>
#include <cstring>
#include <cstdio>
#define N 510
using namespace std;

int g[N][N], dist[N];
bool st[N];
int n, m;

int dijkstra()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    // st[1] = true; 不能在初始化的时候这样做，因为dist[1]实际上还有待进一步确定


    for (int i = 0; i < n; i ++) // 循环n次，遍历每个点，每遍历一个点，这个点到1号点的最短距离就唯一确定了
    {
        int t = -1; // 用-1初始化t，t最后需要返回的使最近的点的下标
        for (int j = 1; j <= n; j ++) // 找到st集合以外的点（还未确定到1号点的最短距离）中离1号点最近的点
        {
            if(!st[j] && (t == -1 || dist[j] < dist[t])) t = j;
        }

        if(t == n) break; // 如果n号点到1号点的距离已经唯一确定了，就可以直接break

        st[t] = true; // 到这一步t号点到1号点的距离就已经唯一确定了（加入集合st）

        for (int j = 1; j <= n; j ++) // 用最新确定的t号点来更新所有点到1号点的距离
        {
            dist[j] = min(dist[j], dist[t] + g[t][j]); // 在（原值）与（先经过t点再从t点到j点的路径长度）二者之间取最小值
        }
    }

    if(dist[n] == 0x3f3f3f3f) return -1; // 代表1号点与n号点不连通
    return dist[n];
}

int main()
{
    cin >> n >> m;

    memset(g, 0x3f, sizeof g);

    for (int i = 0; i < m; i ++)
    {
        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;
}

（2）dijkstra算法（堆优化版）

// dijkstra堆优化版
#include <iostream>
#include <cstring>
#include <cstdio>
#include <queue>
#define N 150010
using namespace std;

int n, m;
int idx, h[N], e[N], ne[N], w[N]; // w(weight)记录每条边的权重（边的长度）
typedef pair<int, int> PII;
int dist[N];
bool st[N]; // 标记第i号点到1号点的最短距离是否唯一确定

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

int dijkstra()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    // 用来存储所有的未确定的点及其距离,每次以第一关键字（点到1号点的距离）为排序顺序，返回最小距离（小根堆）
    // 但是优先队列不能修改某个值，所以每次只能把更新的值push进去，再用一个st数组来记录i号点是否已经确定最短距离
    priority_queue<PII, vector<PII>, greater<PII>> heap;
    heap.push({0, 1});

    while(heap.size()) // 代替朴素版中的每次找到未确定的点中距离1号点最近的点
    {
        PII t = heap.top(); // 找出来作为新确定的
        heap.pop();

        int id = t.second, distance = t.first;

        if(id == n) break; // 如果n号点的最短距离已经唯一确定了，就break
        if(st[id]) continue; // 如果这个点已经是确定过的点

        st[id] = true;
        for (int i = h[id]; i != 0; i = ne[i]) // 通过相连的边来更新所有关联的点
        {
            int tmp = distance + w[i];
            int j = e[i];
            if(st[j]) continue; // 如果是已经确定的点-->有回路
            if(dist[j] > tmp)
            {
                dist[j] = tmp;
                heap.push({tmp, j});
            }
        }
    }

    if(dist[n] == 0x3f3f3f3f) return -1; // 1号点与n号点不连通
    return dist[n];
}

int main()
{
    cin >> n >> m;

    for (int i = 0; i < m; i ++)
    {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        add(a, b, c);
    }

    printf("%d\n", dijkstra());

    return 0;
}