acwing 849. Dijkstra求最短路
题目描述
给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，所有边权均为正值。
请你求出 1 号点到 n 号点的最短距离，如果无法从 1 号点走到n 号点，则输出 −1。
输入格式
第一行包含整数 n 和 m。
接下来 m 行每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。
输出格式
输出一个整数，表示 1 号点到 n 号点的最短距离。
如果路径不存在，则输出 −1。
数据范围
1≤n≤500
1≤m≤105
图中涉及边长均不超过10000。输入样例：
3 3 1 2 2 2 3 1 1 3 4输出样例：
3
算法求解
分析
模板
注意初始化的时候，初始化为正无穷
循环n-1次，然后每次确定一个点的最短距离
代码
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int INF = 0x3f3f3f3f;
const int N = 510;
int g[N][N]; // 用邻接矩阵存图
int st[N];// st[i] = true 表示i点的最短距离已经确定了
int dist[N]; // 存从1到每个点的最短距离
int n, m;
// 返回从1到n的最短距离
int dijkstra()
{
// 初始化从1到所有点距离为正无穷
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;
// 循环n-1次每次取未确定的点里面距离最小的
for(int i = 0; i < n-1; i++)
{
// 从没确定的点里面选一个最小的值 t
int t = -1;
for(int i = 1; i <= n; i++)
if(!st[i] && (t == -1 || dist[i] < dist[t]))
t = i;
// 跟新t指向节点的最短距离
for(int i = 1; i <= n; i++)
// dist[i] = min(dist[i], dist[t] + g[t][i]);
if(!st[i] && dist[i] > dist[t] + g[t][i])
dist[i] = dist[t] + g[t][i];
st[t] = true; //确定了一个点的最短距离
}
if(dist[n] == INF) return -1;
else return dist[n];
}
int main()
{
// 初始化所有点之间边权为无穷大
memset(g, 0x3f, sizeof g);
scanf("%d%d", &n, &m);
while(m--)
{
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;
}
堆优化算法
#include<iostream>
#include<cstdio>
#include<vector>
#include<queue>
#include<cstring>
using namespace std;
typedef pair<int, int> PII;
const int N = 150010;
const int INF = 0x3f3f3f3f;
int dist[N]; // 从1到每个点的最短距离
bool st[N]; // 每个点是否出现过
int n, m;
// 一个点和边权
struct VER
{
int to;
int w;
};
vector<VER> h[N];
// a->b 边权是w
void add(int a, int b, int w)
{
VER ver;
ver.to = b;
ver.w = w;
h[a].push_back(ver);
}
// 定义图
int dijkstra()
{
// 初始化所有点的最小距离为INF，1的最小距离为0
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;
priority_queue< PII, vector<PII>, greater<PII> > heap; //定义小根堆
heap.push({0,1}); // {distance, ver} push到堆里的是一个pair，第一个是到该点的最短距离，第二个是该点的编号，
// 因为优先队列按照第一个排序
// 每次不continue的时候确定一个点的最小距离
while(heap.size())
{
PII t = heap.top();
heap.pop();
int distance = t.first, ver = t.second;
if(st[ver]) continue; // 因为一个点的距离会被放入堆多次，只需要取一次最小的就行
// 遍历ver指向的所有点j
for(int i = 0; i < h[ver].size(); i++)
{
int j = h[ver][i].to;
int w = h[ver][i].w;
// 如果j没被确定最小距离，并且可以更新的话
// 就更新j的最短距离，同时加入堆
if(!st[j] && dist[j] > distance + w)
{
dist[j] = distance + w;
heap.push({dist[j], j}); //dist[j]会被放入多次，会有冗余，只需要取最小的那个就行
}
}
st[ver] = true; // 确定了该点的最小距离
}
if(dist[n] == INF) return -1;
else return dist[n];
}
int main()
{
scanf("%d%d", &n, &m);
while(m --)
{
int a, b, w;
scanf("%d%d%d", &a, &b, &w);
// 重边冗余存储，不会对dijkstra有影响
add(a, b, w);
}
int t = dijkstra();
printf("%d\n", t);
return 0;
}
y总代码
#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>
using namespace std;
typedef pair<int, int> PII;
const int N = 1e6 + 10;
int n, m;
int h[N], w[N], e[N], ne[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;
priority_queue<PII, vector<PII>, greater<PII>> heap;
heap.push({0, 1});
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] > dist[ver] + w[i])
{
dist[j] = dist[ver] + w[i];
heap.push({dist[j], j});
}
}
}
if (dist[n] == 0x3f3f3f3f) return -1;
return dist[n];
}
int main()
{
scanf("%d%d", &n, &m);
memset(h, -1, sizeof h);
while (m -- )
{
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
add(a, b, c);
}
cout << dijkstra() << endl;
return 0;
}
作者：yxc
链接：https://www.acwing.com/activity/content/code/content/48493/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
时间复杂度
参考文章
https://www.acwing.com/solution/content/6554/
朴素Dijkstra与堆优化Dijkstra总结，初学算法如有错误还望指正。
Dijkstra
朴素版dijkstra适合稠密图
思路
集合S为已经确定最短路径的点集。
- 初始化距离
一号结点的距离为零，其他结点的距离设为无穷大（看具体的题）。- 循环n次，每一次将集合S之外距离最短X的点加入到S中去（这里的距离最短指的是距离1号点最近。点X的路径一定最短，基于贪心，严格证明待看）。然后用点X更新X邻接点的距离。
时间复杂度分析
寻找路径最短的点：O(n^2)加入集合S：O(n)
更新距离：O(m)
所以总的时间复杂度为O(n^2)
具体问题
稠密图用邻接矩阵存。#include<iostream> #include<cstring> #include<cstdio> #include<algorithm> using namespace std; const int N = 510, M = 10010; // y总增大数据范围了吧M改到100010就能ac了 int g[N][N], dist[N]; bool visited[N]; int n, m; int dijkstra() { memset(dist, 0x3f, sizeof(dist)); dist[1] = 0; for(int i = 1; i <= n; i++) { int t = -1; for(int j = 1; j <= n; j++) { if(!visited[j] && (t == -1 || dist[j] < dist[t])) t = j; } visited[t] = true; for(int j = 1; j <= n; j++) dist[j] = min(dist[j], dist[t] + g[t][j]); } if(dist[n] == 0x3f3f3f3f) return -1; return dist[n]; } int main() { scanf("%d%d", &n, &m); memset(g, 0x3f, sizeof(g)); while (m--) { int x, y, c; scanf("%d%d%d", &x, &y, &c); g[x][y] = min(g[x][y], c); } cout << dijkstra() << endl; return 0; } 作者：optimjie 链接：https://www.acwing.com/solution/content/6554/ 来源：AcWing 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。堆优化版dijkstra适合稀疏图
思路
堆优化版的dijkstra是对朴素版dijkstra进行了优化，在朴素版dijkstra中时间复杂度最高的寻找距离最短的点O(n^2)可以使用最小堆优化。
- 一号点的距离初始化为零，其他点初始化成无穷大。
- 将一号点放入堆中。
- 不断循环，直到堆空。每一次循环中执行的操作为：
弹出堆顶（与朴素版diijkstra找到S外距离最短的点相同，并标记该点的最短路径已经确定）。
用该点更新临界点的距离，若更新成功就加入到堆中。
时间复杂度分析
寻找路径最短的点：O(n)#include<iostream> #include<cstring> #include<queue> using namespace std; typedef pair<int, int> PII; const int N = 100010; // 把N改为150010就能ac // 稀疏图用邻接表来存 int h[N], e[N], ne[N], idx; int w[N]; // 用来存权重 int dist[N]; bool st[N]; // 如果为true说明这个点的最短路径已经确定 int n, m; void add(int x, int y, int c) { w[idx] = c; // 有重边也不要紧，假设1->2有权重为2和3的边，再遍历到点1的时候2号点的距离会更新两次放入堆中 e[idx] = y; // 这样堆中会有很多冗余的点，但是在弹出的时候还是会弹出最小值2+x（x为之前确定的最短路径），并 ne[idx] = h[x]; // 标记st为true，所以下一次弹出3+x会continue不会向下执行。 h[x] = idx++; } int dijkstra() { memset(dist, 0x3f, sizeof(dist)); dist[1] = 0; priority_queue<PII, vector<PII>, greater<PII>> heap; // 定义一个小根堆 // 这里heap中为什么要存pair呢，首先小根堆是根据距离来排的，所以有一个变量要是距离，其次在从堆中拿出来的时 // 候要知道知道这个点是哪个点，不然怎么更新邻接点呢？所以第二个变量要存点。 heap.push({ 0, 1 }); // 这个顺序不能倒，pair排序时是先根据first，再根据second，这里显然要根据距离排序 while(heap.size()) { PII k = heap.top(); // 取不在集合S中距离最短的点 heap.pop(); int ver = k.second, distance = k.first; if(st[ver]) continue; st[ver] = true; for(int i = h[ver]; i != -1; i = ne[i]) { int j = e[i]; // i只是个下标，e中在存的是i这个下标对应的点。 if(dist[j] > distance + w[i]) { dist[j] = distance + w[i]; heap.push({ dist[j], j }); } } } if(dist[n] == 0x3f3f3f3f) return -1; else return dist[n]; } int main() { memset(h, -1, sizeof(h)); scanf("%d%d", &n, &m); while (m--) { int x, y, c; scanf("%d%d%d", &x, &y, &c); add(x, y, c); } cout << dijkstra() << endl; return 0; } 作者：optimjie 链接：https://www.acwing.com/solution/content/6554/ 来源：AcWing 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。作者：optimjie
链接：https://www.acwing.com/solution/content/6554/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
