c++图论——Dijkstra求最短路径问题模板

1.朴素Dijkstra求最短路——局限在于只能求唯一单独特定的终点和起点之间的最短路径
例题
我们需要用到两个数组
一个数组用来记录1号点到每个点的最短距离
另一个记录每一个点的最短路是否已经确定

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 510;
int n, m;
int g[N][N]; //稠密图一般使用邻接矩阵
int dist[N]; //记录每个节点距离起点的距离
bool st[N]; //True表示已经确定最短路 属于s集合

int dijkstra() {
    //所有节点距离起点的距离初始化为无穷大
    memset(dist, 0x3f, sizeof dist);
    //起点距离自己的距离为零
    dist[1] = 0;

    //迭代n次，每次可以确定一个点到起点的最短路
    for (int i = 0; i < n; ++i) {
        int t = -1;
        //t的作用？
        //能够更新第一个定点
        for (int j = 1; j <= n; ++j) {
            //不在s集合，并且
            //如果没有更新过，则进行更新， 或者发现更短的路径，则进行更新
            if (!st[j] && (t == -1 || dist[j] < dist[t])) {
                t = j;
            }
        }

        //加入到s集合中
        st[t] = true;

        //找到了距离最小的点t，并用最小的点t去更新其他的点到起点的距离
        for (int j = 1; j <= n; ++j) {
            dist[j] = min(dist[j], dist[t] + g[t][j]);
        }
    }

    // 如果起点到达不了n号节点，则返回-1
    if (dist[n] == 0x3f3f3f3f) return -1;
    // 返回起点距离n号节点的最短距离
    return dist[n];
}

int main() {
    cin >> n >> m;
    //所有节点之间的距离初始化为无穷大
    memset(g, 0x3f, sizeof g);
    // 0x3f 0x3f3f3f3f 的区别？
    // memset 按字节赋值，所以memset 0x3f 就等价与赋值为0x3f3f3f3f，
    while (m--) {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        g[a][b] = min(g[a][b], c); //如果有重边，请保留权值最小的一条边
    }

    cout << dijkstra() << endl;

    return 0;
}

我们会不会有这样的疑惑（反正我有），dist全都设置成无限大，会不会在进行 if (!st[j] && (t == -1 || dist[j] < dist[t])) 、dist[j] = min(dist[j], dist[t] + g[t][j]);出现出不来的情况，这个是不会的，程序迭代第一次确定的就是起点起点的最短路
如果还没有想明白，这里举个样例

模板：

int g[N][N];  // 存储每条边
int dist[N];  // 存储1号点到每个点的最短距离
bool st[N];   // 存储每个点的最短路是否已经确定

// 求1号点到n号点的最短路，如果不存在则返回-1
int dijkstra()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    for (int i = 0; i < n - 1; i ++ )
    {
        int t = -1;     // 在还未确定最短路的点中，寻找距离最小的点
        for (int j = 1; j <= n; j ++ )
            if (!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;

        // 用t更新其他点的距离
        for (int j = 1; j <= n; j ++ )
            dist[j] = min(dist[j], dist[t] + g[t][j]);

        st[t] = true;
    }

    if (dist[n] == 0x3f3f3f3f) return -1;//1和n不存在通路
    return dist[n];
}

2.堆优化下的Dijkstra算法
朴素的适合稠密图，堆优化适合稀疏图，提到稀疏图就要想到用邻接表存储
邻接表的用法

#include <iostream>
#include <vector>
#include <queue>
#include <memory.h>

using namespace std;
typedef pair<int, int> PII;

const int N = 100010;
vector<vector<pair<int, int>>> gra;
int dist[N];
int st[N];
int n, m;

int solve()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    //这里是距离在前 节点号在后
    priority_queue<PII, vector<PII>, greater<PII>> heap;
    heap.push({ 0, 1 });      // first存储距离，second存储节点编号

    while (heap.size()) {
        auto t = heap.top();
        heap.pop();

        int node = t.second; int distance = t.first;

        if (st[node]) continue;
        st[node] = true;
        //查看每个出边
        for (int i = 0; i < gra[node].size(); i++) {
            int newnode = gra[node][i].first;
            int len = gra[node][i].second;
            if (dist[newnode] > dist[node] + len) {
                dist[newnode] = dist[node] + len;
                heap.push({ dist[newnode],newnode });
            }
        }


    }

    if (dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}



int main()
{
    //cin >> n >> m;
    scanf("%d %d",&n,&m);
    gra.resize(n + 1);

    for (int i = 0; i < m; i++) {
        int a, b, c;
        //cin >> a >> b >> c;
        scanf("%d %d %d",&a,&b,&c);
        //这里是 目的节点号在前 边长在后
        gra[a].push_back({ b,c });
    }

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

    return 0;
}

模板：

typedef pair<int, int> PII;

int n;      // 点的数量
int h[N], w[N], e[N], ne[N], idx;       // 邻接表存储所有边
int dist[N];        // 存储所有点到1号点的距离
bool st[N];     // 存储每个点的最短距离是否已确定

// 求1号点到n号点的最短距离，如果不存在，则返回-1
int dijkstra()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    priority_queue<PII, vector<PII>, greater<PII>> heap;
    heap.push({0, 1});      // first存储距离，second存储节点编号

    while (heap.size())
    {
        auto t = heap.top();
        heap.pop();

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

        if (st[ver]) continue;
        st[ver] = true;

        for (int i = h[ver]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > distance + w[i])
            {
                dist[j] = distance + w[i];
                heap.push({dist[j], j});
            }
        }
    }

    if (dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}