算法-图-dijkstra 最短路径

理论知识

dijkstra三部曲

朴素版dijkstra

模拟过程

堆优化版dijksra

经典模版例题

Dijkstra求最短路 I

参加科学大会（第六期模拟笔试）--模版题

网络延迟

ref

理论知识

最短路是图论中的经典问题即：给出一个有向图，一个起点，一个终点，问起点到终点的最短路径。

dijkstra算法：在有权图（权值非负数）中求从起点到其他节点的最短路径算法。需要注意两点：

dijkstra 算法可以同时求起点到所有节点的最短路径
权值不能为负数

dijkstra三部曲

第一步，选源点到哪个节点近且该节点未被访问过;（minDist数组里的数值，结合visited数组筛选出未访问的节点）
第二步，该最近节点被标记访问过;（更新visited数组）
第三步，更新非访问节点到源点的距离（即更新minDist数组）。minDist数组用来记录每一个节点距离源点的最小距离。（更新minDist数组）（初始化的时候就应该初始为最大值）

朴素版dijkstra

模拟过程

①初始化：节点0 不做处理，统一从下标1 开始计算，源点（节点1）到自己的距离为0，所以 minDist[1] = 0；此时所有节点都没有被访问过，所以 visited数组都为0。

②dijkstra 三部曲：

更新 minDist数组，即：源点（节点1）到 节点6 、节点3 和节点4【与当前被访问节点2相连的节点】的距离。

源点到节点6的最短距离为5，小于原minDist[6]的数值max，更新minDist[6] = 5
源点到节点3的最短距离为3，小于原minDist[3]的数值4，更新minDist[3] = 3
源点到节点4的最短距离为6，小于原minDist[4]的数值max，更新minDist[4] = 6

源点到节点4的最短距离为5，小于原minDist[4]的数值6，更新minDist[4] = 5

...........

...........最终

节点1）到终点（节点7）的最短距离就是 minDist[7] ，按上面举例讲解来说，minDist[7] = 12，节点1 到节点7的最短路径为 12。

堆优化版dijksra

1、邻接表结构存储： vector<vector<pair<int, int>>> adj(n + 1); // 邻接表直接存储边

2、初始化最短距离数组和优先队列，设定起点距离

使用小顶堆（priority_queue）存储 <距离, 节点> 对，初始时将起点 (0, 1) 加入队列

priority_queue<pair<int, int>, vector<pair<int, int>>, greater<>> pq;

3、主循环：通过优先队列快速找到当前最短路径节点，并更新邻接节点。

用到的数据结构：

vector<vector<pair<int, int>>> adj(n + 1)
adj[1] = { {2, 2}, {3, 4} }; // 从 1 出发，有 1→2 (权2)，1→3 (权4)
adj[2] = { {3, 1}, {4, 7} }; // 从 2 出发，有 2→3 (权1)，2→4 (权7)
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<>> pq;

动态维护当前扩展的最短路径节点

经典模版例题

Dijkstra求最短路 I

完整代码：

#include<bits/stdc++.h>
using namespace std;
int main()
{int n,m;cin>>n>>m;vector<vector<int>> grid(n+1,vector<int>(n+1,INT_MAX));for(int i=1;i<=m;i++){int x,y,z;cin>>x>>y>>z;if (z < grid[x][y]) {  // 处理重边，保留最小权重grid[x][y] = z;}}vector<int> minDist(n+1,INT_MAX);vector<bool> visited(n+1,false);int start=1;minDist[start]=0;for(int i=1;i<=n;i++){int minval=INT_MAX;int cur=-1;for(int j=1;j<=n;j++){if(!visited[j]&&minDist[j]<minval){minval=minDist[j];cur=j;}}if (cur == -1) break;  // 所有剩余节点不可达visited[cur]=true;for(int j=1;j<=n;j++){if(!visited[j]&&grid[cur][j]!=INT_MAX&&grid[cur][j]+minDist[cur]<minDist[j]){minDist[j]=minDist[cur]+grid[cur][j];}}}if(minDist[n]==INT_MAX) cout<<"-1";else cout<<minDist[n];return 0;
}

注意重边？？？？？！！！！

堆优化版：

#include <bits/stdc++.h>
using namespace std;int main() {int n, m;cin >> n >> m;vector<vector<pair<int, int>>> adj(n + 1); // 邻接表直接存储边// 读取边并构建邻接表（无需预处理二维数组）for (int i = 0; i < m; ++i) {int x, y, z;cin >> x >> y >> z;adj[x].emplace_back(y, z); // 直接添加所有边}// Dijkstra算法vector<int> dist(n + 1, INT_MAX);priority_queue<pair<int, int>, vector<pair<int, int>>, greater<>> pq;dist[1] = 0;pq.push({0, 1});while (!pq.empty()) {auto [d, u] = pq.top();pq.pop();if (d > dist[u]) continue; // 跳过过时记录for (auto [v, w] : adj[u]) {if (dist[v] > dist[u] + w) {dist[v] = dist[u] + w;pq.push({dist[v], v});}}}// 输出结果cout << (dist[n] == INT_MAX ? -1 : dist[n]);return 0;
}

参加科学大会（第六期模拟笔试）--模版题

完整代码： （我真的好爱卡哥，代码简洁又易懂！！！！！）

#include<bits/stdc++.h>
using namespace std;
int main()
{int n,m;cin>>n>>m;//邻接矩阵存储vector<vector<int>> grid(n+1,vector<int>(n+1,INT_MAX));//初始化数值为INT_MAXfor(int i=0;i<m;i++) //输入边权{int s,e,v;cin>>s>>e>>v;grid[s][e]=v;//存储边权值}int start=1;//记录源点，从哪个点开始走int end=n;//记录终点vector<int> minDist(n+1,INT_MAX);//存储每个点至源点的最小距离minDist[start]=0;//源点到自身距离为0；vector<bool> visited(n+1,false);//记录该点是否被访问过，初始化都没有被访问过//依次遍历所有结点for(int i=1;i<=n;i++){int minval=INT_MAX;int cur=start;//记录当前被访问的点中哪个点距离源点最近//1、选距离源点最近&&没有被访问过的点for(int v=1;v<=n;v++){if(!visited[v]&&minDist[v]<minval){minval=minDist[v];cur=v;//记录该最近结点的id}}//2、标记该最近结点beifnagwvisited[cur]=true;//3、更新其他非访问节点到源点的距离（更新minDist数组）for(int v=1;v<=n;v++){//没有被访问过的、与 cur相连的、更新后minDist更小的if(!visited[v]&&grid[cur][v]!=INT_MAX &&minDist[v]>minDist[cur]+grid[cur][v])minDist[v]=minDist[cur]+grid[cur][v];}}//不能到达终点if(minDist[end]==INT_MAX) cout<<-1<<endl;else cout<<minDist[end]<<endl; //输出到达终点的最短路径return 0;}

堆优化版：

#include <bits/stdc++.h>
using namespace std;int main() {int n, m;cin >> n >> m;// 邻接表存储：adj[x]保存从x出发的所有边，格式为<目标节点, 边权>vector<vector<pair<int, int>>> adj(n + 1);// 处理输入并保留最小边权（处理重边）vector<vector<int>> grid(n + 1, vector<int>(n + 1, INT_MAX));for (int i = 0; i < m; ++i) {int s, e, v;cin >> s >> e >> v;if (v < grid[s][e]) grid[s][e] = v;  // 仅保留最小权重}// 将邻接矩阵转换为邻接表for (int x = 1; x <= n; ++x) {for (int y = 1; y <= n; ++y) {if (grid[x][y] != INT_MAX) {adj[x].push_back({y, grid[x][y]});}}}// Dijkstra堆优化实现vector<int> dist(n + 1, INT_MAX);        // 存储起点到各节点的最短距离priority_queue<pair<int, int>, vector<pair<int, int>>, greater<>> pq; // 小顶堆，格式<距离, 节点>dist[1] = 0;                             // 起点距离初始化为0pq.push({0, 1});                         // 将起点加入堆while (!pq.empty()) {auto [d, u] = pq.top();              // 取出当前距离最小的节点pq.pop();if (d > dist[u]) continue;           // 跳过过时的路径记录for (auto [v, w] : adj[u]) {         // 遍历所有邻接节点if (dist[v] > dist[u] + w) {     // 发现更短路径dist[v] = dist[u] + w;       // 更新距离pq.push({dist[v], v});       // 将新距离加入堆}}}// 输出结果：终点不可达则输出-1cout << (dist[n] == INT_MAX ? -1 : dist[n]) << endl;return 0;
}

网络延迟

#include<bits/stdc++.h>
using namespace std;int main() {int n, k, m;cin >> n >> k >> m;vector<vector<int>> grid(n+1, vector<int>(n+1, INT_MAX));for(int i = 0; i < m; ++i) {int u, v, w;cin >> u >> v >> w;grid[u][v] = w; // 存储有向边}vector<int> minDist(n+1, INT_MAX);vector<bool> visited(n+1, false);minDist[k] = 0; // 起点距离为0for(int i = 1; i <= n; ++i) {int minVal = INT_MAX;int cur = -1;// 寻找当前未访问的最小距离节点for(int v = 1; v <= n; ++v) {if (!visited[v] && minDist[v] < minVal) {minVal = minDist[v];cur = v;}}// 所有剩余节点不可达if (cur == -1) break;visited[cur] = true;// 更新相邻节点for(int v = 1; v <= n; ++v) {if (!visited[v] && grid[cur][v] != INT_MAX && minDist[cur] != INT_MAX) {if (minDist[v] > minDist[cur] + grid[cur][v]) {minDist[v] = minDist[cur] + grid[cur][v];}}}}int maxTime = 0;for(int i = 1; i <= n; ++i) {if (minDist[i] == INT_MAX) {cout << -1 << endl;return 0;}maxTime = max(maxTime, minDist[i]);}cout << maxTime << endl;return 0;
}

堆优化版：

#include <bits/stdc++.h>
using namespace std;int main() {int n, k, m;cin >> n >> k >> m;vector<vector<pair<int, int>>> adj(n + 1); // 邻接表存储图for (int i = 0; i < m; ++i) {int u, v, w;cin >> u >> v >> w;adj[u].emplace_back(v, w);}// Dijkstra算法vector<int> dist(n + 1, INT_MAX);priority_queue<pair<int, int>, vector<pair<int, int>>, greater<>> pq;dist[k] = 0;pq.push({0, k});while (!pq.empty()) {auto [d, u] = pq.top();pq.pop();if (d > dist[u]) continue;for (auto [v, w] : adj[u]) {if (dist[v] > dist[u] + w) {dist[v] = dist[u] + w;pq.push({dist[v], v});}}}int maxTime = *max_element(dist.begin() + 1, dist.end());cout << (maxTime == INT_MAX ? -1 : maxTime) << endl;return 0;
}