Dijkstra
处理无负权边的图
算法思路：
首先从图中找到离起点距离最小的点，然后将这个点标记，然后再用这个点去更新这个点连接的所有点。
时间复杂度：0(n * m)
测试题目：
- Dijkstra求最短路 I
题目
提交记录
讨论
题解
视频讲解
给定一个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
测试过的代码:
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 505, M = 1e5 + 5;
int g[N][N];
int n, m;
int d[N];
bool vis[N];
inline int dijkstra(void) {
memset(d, 0x3f, sizeof d);
d[1] = 0;
for(int i = 1; i < n; i ++) {
int t = -1;
for(int j = 1; j <= n; j ++) {
if(!vis[j] && (t == -1 || d[j] < d[t]))
t= j;
}
if(d[t] > 0x3f3f3f3f / 2) return -1;
vis[t] = true;
for(int j = 1; j <= n; j ++)
d[j] = min(d[j], d[t] + g[t][j]);
}
if(d[n] > 0x3f3f3f3f) return -1;
return d[n];
}
int main(void) {
scanf("%d%d", &n, &m);
memset(g, 0x3f, sizeof g);
for(int i = 1; i <= m; i ++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
g[a][b] = min(g[a][b], c);
}
printf("%d\n", dijkstra());
return 0;
}
Dijstra 堆优化
处理无负权边的图
算法思路：
通过优先队列可以直接找到离起点距离最短的点，只有当这个点到起点的距离被更新后才会加到队列中，然后队列总最多就只会有n个点，然后队列里面将得到的这个点标记一下，然后再更新与这个点相连的其他的点的dist。
时间复杂度：0(mlogn)
测试题目：
- Dijkstra求最短路 II
题目
提交记录
讨论
题解
视频讲解
给定一个n个点m条边的有向图，图中可能存在重边和自环，所有边权均为正值。
请你求出1号点到n号点的最短距离，如果无法从1号点走到n号点，则输出-1。
输入格式
第一行包含整数n和m。
接下来m行每行包含三个整数x，y，z，表示点x和点y之间存在一条有向边，边长为z。
输出格式
输出一个整数，表示1号点到n号点的最短距离。
如果路径不存在，则输出-1。
数据范围
1≤n,m≤105,
图中涉及边长均不超过10000。
输入样例：
3 3
1 2 2
2 3 1
1 3 4
输出样例：
3
测试过的代码：
#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <map>
using namespace std;
typedef pair<int, int> PII;
const int maxn = 1e5 + 5;
int n, m;
int h[maxn], w[maxn], e[maxn], ne[maxn], idx;
int dist[maxn];
bool vis[maxn];
inline void add(int a, int b, int c) {
e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
}
inline int dijkstra(void) {
memset(dist, 0x3f, sizeof dist);
priority_queue<PII, vector<PII>, greater<PII> > q;
dist[1] = 0;
q.push({dist[1], 1});
while(q.size()) {
PII t = q.top(); q.pop();
int u = t.second, du = t.first;
if(dist[u] > 0x3f3f3f3f / 2) return -1;
vis[u] = true;
for(int i = h[u]; i != -1; i = ne[i]) {
int v = e[i];
if(!vis[v]) {
if(dist[v] > dist[u] + w[i]) {
dist[v] = dist[u] + w[i];
q.push({dist[v], v});
}
}
}
}
if(dist[n] > 0x3f3f3f3f / 2) return -1;
return dist[n];
}
int main(void) {
scanf("%d%d", &n, &m);
memset(h, -1, sizeof h);
for(int i = 1; i <= m; i ++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
add(a, b, c);
}
printf("%d\n", dijkstra());
return 0;
}
Bellman_Ford
处理有负权边
算法思路：
假如有n 个点，m条边，那么这个算法将会去循环n次，每次都没去遍历所有的边，在遍历的时候会更新对应的点到起点的距离。
测试题目：
853. 有边数限制的最短路
题目
提交记录
讨论
题解
视频讲解
给定一个n个点m条边的有向图，图中可能存在重边和自环， 边权可能为负数。
请你求出从1号点到n号点的最多经过k条边的最短距离，如果无法从1号点走到n号点，输出impossible。
注意：图中可能 存在负权回路 。
输入格式
第一行包含三个整数n，m，k。
接下来m行，每行包含三个整数x，y，z，表示点x和点y之间存在一条有向边，边长为z。
输出格式
输出一个整数，表示从1号点到n号点的最多经过k条边的最短距离。
如果不存在满足条件的路径，则输出“impossible”。
数据范围
1≤n,k≤500,
1≤m≤10000,
任意边长的绝对值不超过10000。
输入样例：
3 3 1
1 2 1
2 3 1
1 3 3
输出样例：
3
AC代码：
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int N = 505, M = 10005;
struct Edge {
int a, b, w;
}edge[M];
int n, m, k;
int d[N], tmp[N];
inline int bellman_ford(void) {
memset(d, 0x3f, sizeof d);
d[1] = 0;
for(int i = 1; i <= k; i ++) {
memcpy(tmp, d, sizeof tmp);
for(int j = 1; j <= m; j ++) {
int a = edge[j].a, b = edge[j].b, w = edge[j].w;
d[b] = min(d[b], tmp[a] + w);
}
}
if(d[n] > 0x3f3f3f3f / 2) return -1;
return d[n];
}
int main(void) {
scanf("%d%d%d", &n, &m, &k);
for(int i = 1; i <= m; i ++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
edge[i].a = a;
edge[i].b = b;
edge[i].w = c;
}
int t = bellman_ford();
if(t == -1) puts("impossible");
else printf("%d\n", t);
return 0;
}
SPFA
可以处理负权边
算法思路：
首先我们将起点的距离设置为0， 然后让让他入队，并且将这个点标记，然后在队列中假如当前u这个点出了队列，那么我们要将这个点的vis[u] = false, 然后在用这个点去更新和他相连接的点的距离，如果某一个点可以被更新，那么更新这个点，然后判断这个点是否在队列中，若是不在就将这个点标记一下，然后放到队列里去。
关键点：只有被更新的点才可以继续去更新其他的点，所以队列里的所有点都是被更新过的点，只有 被更新的点才会放到队列里面去，因为某个点出了队列之后，我们把这个点取消标记，所以后面若是还可以更新这个点的话，这个点还可以再次放到队列里面。
时间复杂度：一般情况下：0(m), 极限情况：0(m * n)
测试题目：
851. spfa求最短路
题目
提交记录
讨论
题解
视频讲解
给定一个n个点m条边的有向图，图中可能存在重边和自环， 边权可能为负数。
请你求出1号点到n号点的最短距离，如果无法从1号点走到n号点，则输出impossible。
数据保证不存在负权回路。
输入格式
第一行包含整数n和m。
接下来m行每行包含三个整数x，y，z，表示点x和点y之间存在一条有向边，边长为z。
输出格式
输出一个整数，表示1号点到n号点的最短距离。
如果路径不存在，则输出”impossible”。
数据范围
1≤n,m≤105,
图中涉及边长绝对值均不超过10000。
输入样例：
3 3
1 2 5
2 3 -3
1 3 4
输出样例：
2
AC代码：
#include <iostream>
#include <cstdio>
#include <queue>
#include <cstring>
using namespace std;
typedef pair<int, int> PII;
const int maxn = 1e5 + 5;
int h[maxn], e[maxn], w[maxn], ne[maxn], idx;
int d[maxn];
bool vis[maxn];
int n, m;
inline void add(int a, int b, int c) {
e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
}
inline int spfa(void) {
memset(d, 0x3f, sizeof d);
queue<int> q;
d[1] = 0;
q.push(1);
vis[1] = true;
while(q.size()) {
int u = q.front(); q.pop();
vis[u] = false;
for(int i = h[u]; i != -1; i = ne[i]) {
int v = e[i];
if(d[v] > d[u] + w[i]) {
d[v] = d[u] + w[i];
if(!vis[v]) {
vis[v] = true;
q.push(v);
}
}
}
}
if(d[n] > 0x3f3f3f3f / 2) return -1;
return d[n];
}
int main(void) {
scanf("%d%d", &n, &m);
memset(h, -1, sizeof h);
for(int i = 1; i <= m; i ++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
add(a, b, c);
}
int t = spfa();
if(t == -1) puts("impossible");
else printf("%d\n", t);
return 0;
}
SPFA判断负环
算法思路：
cnt[i], 表示起点到i这个点的路径长度；
因为这个图不一定是一张连通图，所以在spfa中我们一开始需要把所有的点都当作起点放到队列中，若是存在负环，那么一点 会被更新到，并且会一直更新，而这张图中总共只有n个点，当某一的点的路径的长度为n的时候，表示这条路径上有n + 1个点，说明存在负回路。
时间复杂度: 0(m * n)
测试题目：
852. spfa判断负环
题目
提交记录
讨论
题解
视频讲解
给定一个n个点m条边的有向图，图中可能存在重边和自环， 边权可能为负数。
请你判断图中是否存在负权回路。
输入格式
第一行包含整数n和m。
接下来m行每行包含三个整数x，y，z，表示点x和点y之间存在一条有向边，边长为z。
输出格式
如果图中存在负权回路，则输出“Yes”，否则输出“No”。
数据范围
1≤n≤2000,
1≤m≤10000,
图中涉及边长绝对值均不超过10000。
输入样例：
3 3
1 2 -1
2 3 4
3 1 -4
输出样例：
Yes
AC代码:
#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;
const int N = 2005, M = 10005;
int n, m;
int h[N], e[M], ne[M], w[M], idx;
int d[N], cnt[N];
bool vis[N];
inline void add(int a, int b, int c) {
e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
}
inline bool spfa(void) {
queue<int> q;
for(int i = 1; i <= n; i ++) {
q.push(i);
vis[i] = true;
}
while(q.size()) {
int u = q.front(); q.pop();
vis[u] = false;
for(int i = h[u]; i != -1; i = ne[i]) {
int v = e[i];
if(d[v] > d[u] + w[i]) {
d[v] = d[u] + w[i];
cnt[v] = cnt[u] + 1;
if(cnt[v] >= n) return true;
if(!vis[v]) {
q.push(v);
vis[v] = true;
}
}
}
}
return false;
}
int main(void) {
scanf("%d%d", &n, &m);
memset(h, -1, sizeof h);
for(int i = 1; i <= m; i ++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
add(a, b, c);
}
if(spfa()) puts("Yes");
else puts("No");
return 0;
}
2176
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
