朴素版本（时间复杂度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;
}
扩展 ：
题目的意思是，你作为一个城市的紧急救援队队长，当你接到来自另一个城市的紧急求救电话时，你的任务是尽快带领你的队伍前往该城市，并且在前往的途中尽可能多地召集其他城市的救援队伍来支援。
具体来说，题目给出了一张国家的地图，这张地图标明了若干个城市以及它们之间的道路。每个城市有一定数量的救援队伍，每条道路有其长度。你需要计算：
- 从起始城市到达目标城市的不同最短路径的数量。
- 在这些最短路径上能够召集的最大救援队伍数量。
输入格式：
输入包括以下内容：
- 第一行包含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(logN)的时间内完成插入和提取操作，使得每个节点的处理都更加高效。
使用优先队列优化的迪杰斯特拉算法的时间复杂度为 O((E+V)logV)，其中 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;
}
