迪杰斯特拉算法——求最短路径

朴素版本（时间复杂度O（n^2））： 

迪杰斯特拉算法采用的是一种贪心的策略。  

用一个 dist 数组保存源点到其余各个节点的距离，dist[i] 表示源点到节点 i 的距离。初始时，dist 数组的各个元素为无穷大。 源点到源点的距离为 0。即dist[1] = 0。

用一个状态数组 st记录是否找到了源点到该节点的最短距离，st[i] 如果为真，则表示找到了源点到节点 i 的最短距离，st[i] 如果为假，则表示源点到节点 i 的最短距离还没有找到。初始时，st各个元素为假。

遍历 dist 数组，找到一个节点t，这个节点是：没有确定最短路径的节点中距离源点最近的点。假设该节点编号为 t。此时就找到了源点到该节点的最短距离，st[t] 置为 1。 

遍历 t所有可以到达的节点 j，如果 dist[j] 大于 dist[t] 加上 t -> j 的距离，即 dist[j] > dist[t] + w[t][j]（w[t][j] 为 i -> j 的距离） ，则更新 dist[j] = dist[t] + w[t][j]。

样题： 

#include <bits/stdc++.h>
using namespace std;
const int N = 510;
const int INF = INT_MAX; // 使用INT_MAX作为无穷大
int n, m;
int g[N][N], dist[N];
bool st[N];

int dijkstra() {
    memset(dist, 0x3f, sizeof dist); // 初始化距离为无穷大
    dist[1] = 0; // 起点距离设为0
    for (int i = 0; i < n; i++) {
        int t = -1;
        // 找到没有确定最短路径的且距离最小的节点
        for (int j = 1; j <= n; j++) {
            if (!st[j] && (t == -1 || dist[t] > dist[j])) {
                t = j;
            }
        }
        if (t == -1) break; // 如果没有找到有效节点，退出循环
        st[t] = true;

        for (int j = 1; j <= n; j++) {
            if (g[t][j] < INF) {
                dist[j] = min(dist[j], dist[t] + g[t][j]);
            }
        }
    }
    if (dist[n] == INF) return -1;
    return dist[n];
}

int main() {
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    cin >> n >> m;
    memset(g, 0x3f, sizeof g); // 初始化图
    while (m--) {
        int a, b, c; 
        cin >> a >> b >> c;
        g[a][b] = min(g[a][b], c); // 处理多条边，只保留最小权值
    }
    int t = dijkstra();
    cout << t << '\n';
    return 0;
}

扩展 ：

题目的意思是，你作为一个城市的紧急救援队队长，当你接到来自另一个城市的紧急求救电话时，你的任务是尽快带领你的队伍前往该城市，并且在前往的途中尽可能多地召集其他城市的救援队伍来支援。

具体来说，题目给出了一张国家的地图，这张地图标明了若干个城市以及它们之间的道路。每个城市有一定数量的救援队伍，每条道路有其长度。你需要计算：

1. 从起始城市到达目标城市的不同最短路径的数量。
2. 在这些最短路径上能够召集的最大救援队伍数量。

输入格式：

输入包括以下内容：

• 第一行包含4个正整数：N 表示城市的数量（城市编号从0到N-1），M 表示道路的数量，C1 表示你所在的起始城市，C2 表示需要救援的目标城市。
• 第二行包含 N 个整数，其中第 i 个整数表示城市 i 的救援队伍数量。
• 接下来的 M 行每行包含3个整数：c1、c2 和 L，表示城市 c1 和城市 c2 之间有一条长度为 L 的道路。

输出格式：

输出包括一行，包含两个整数：

• 从起始城市 C1 到目标城市 C2 的不同最短路径的数量。
• 在这些最短路径上能召集到的最大救援队伍数量。

扩展：不仅要计算最短路径，还要统计路径数量以及路径上的资源最大化问题。

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

const int N = 510; // 最大城市数量
const int INF = 0x3f3f3f3f; // 无穷大，表示不可达的距离

int n, m, c1, c2; // 城市数量，道路数量，起点城市，终点城市
int g[N][N], dist[N], rescue[N], num_paths[N], max_rescue[N];
bool st[N]; // 标记每个城市是否已确定最短路径

// 迪杰斯特拉算法实现
void dijkstra() {
    // 初始化
    memset(dist, 0x3f, sizeof dist); // 最短距离初始化为无穷大
    memset(num_paths, 0, sizeof num_paths); // 最短路径数量初始化为0
    memset(max_rescue, 0, sizeof max_rescue); // 最大救援团队数初始化为0

    dist[c1] = 0; // 起点到起点的距离为0
    num_paths[c1] = 1; // 起点到起点的路径数量为1
    max_rescue[c1] = rescue[c1]; // 起点的最大救援团队数为自身的救援团队数

    for (int i = 0; i < n; i++) {
        int t = -1; // t代表当前未确定最短路径的城市
        for (int j = 0; j < n; j++) {
            if (!st[j] && (t == -1 || dist[t] > dist[j])) {
                t = j; // 找到距离最小且未确定的城市
            }
        }

        if (t == -1) break; // 如果没有可选的城市，退出循环

        st[t] = true; // 标记城市t的最短路径已确定

        // 更新城市t的所有邻接城市的距离
        for (int j = 0; j < n; j++) {
            if (g[t][j] != INF) { // 如果t和j之间有道路
                // 发现更短路径
                if (dist[j] > dist[t] + g[t][j]) {
                    dist[j] = dist[t] + g[t][j]; // 更新最短距离
                    num_paths[j] = num_paths[t]; // 更新路径数量
                    max_rescue[j] = max_rescue[t] + rescue[j]; // 更新最大救援团队数
                } 
                // 如果发现相同长度的路径
                else if (dist[j] == dist[t] + g[t][j]) {
                    num_paths[j] += num_paths[t]; // 增加该路径的数量
                    max_rescue[j] = max(max_rescue[j], max_rescue[t] + rescue[j]); // 更新最大救援团队数
                }
            }
        }
    }
}

int main() {
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    cin >> n >> m >> c1 >> c2; // 输入城市数量，道路数量，起点和终点
    memset(g, 0x3f, sizeof g); // 初始化图的邻接矩阵为无穷大，表示没有直接连接的道路
    
    // 输入每个城市的救援团队数量
    for (int i = 0; i < n; i++) {
        cin >> rescue[i];
    }

    // 输入每条道路的信息
    while (m--) {
        int a, b, l;
        cin >> a >> b >> l;
        g[a][b] = g[b][a] = l; // 设置无向图中两城市间的距离
    }

    dijkstra(); // 调用迪杰斯特拉算法

    // 输出从c1到c2的最短路径数量和最大救援团队数
    cout << num_paths[c2] << " " << max_rescue[c2] << '\n';

    return 0;
}

 堆优化版：

小根堆（优先队列）的使用：

• 小根堆（Min-Heap） 作为优先队列，用于维护当前待处理的最短路径节点。在迪杰斯特拉算法中，堆始终确保提取出距离起点最近的未处理节点。
• 这种方式避免了每次都遍历所有节点来找出当前的最短路径节点（这会增加时间复杂度）。通过堆，我们可以在 O(log⁡N)的时间内完成插入和提取操作，使得每个节点的处理都更加高效。

使用优先队列优化的迪杰斯特拉算法的时间复杂度为 O((E+V)log⁡V)，其中 V是节点数，E是边数。相比于未优化的版本（时间复杂度 O(V^2)，在稀疏图中效率提升明显。

#include <bits/stdc++.h>
using namespace std;
typedef pair<int,int> PII;
/*
第一个值 (first)：表示从起点到当前节点的最短距离。
在迪杰斯特拉算法中，堆会根据这个值进行排序，优先处理距离最短的节点。

第二个值 (second)：表示当前的节点编号。
这个编号用于标识从堆中取出的节点，并用来更新该节点的邻接节点的最短距离。
*/
const int N = 100010;

const int INF = INT_MAX; // 使用INT_MAX作为无穷大
int n, m;
int h[N],e[N],ne[N],w[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() {
    memset(dist, 0x3f, sizeof dist); // 初始化距离为无穷大
    dist[1] = 0; // 起点距离设为0
    priority_queue<PII,vector<PII>,greater<PII>> heap; // 小根堆
    heap.push({0,1}); // 将起点加入堆中，起点的距离为0
    while(heap.size()){
        auto t = heap.top();
        heap.pop();

        int ver = t.second,distance = t.first;
        if(st[ver]) continue; // 如果节点已确定最短路径，则跳过
        
        //对当前节点 ver 的所有邻接节点进行遍历和更新
        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] == INF) return -1; // 如果终点不可达，返回-1
    return dist[n]; // 返回终点的最短距离
}

int main() {
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    cin >> n >> m;
    memset(h, -1, sizeof h); // 初始化邻接表的头节点数组为-1
    while (m--) {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c); // 添加边到邻接表
    }
    int t = dijkstra(); // 计算最短路径
    cout << t << '\n'; // 输出结果
    return 0;
}