通关搜索和图论 day_15 -- Bellman_Ford & SPFA & Floyd
Bellman-Ford
循环 n 次，每一次循环所有边
这个算法的存边比较简单，只需要让我可以遍历到所有边就可以，那么可以直接开一个结构体
遍历所有边的时候，更新一下 dist 数组即可
Bellman-Ford 证明了在循环完之后一定满足
dist[b] <= dist[a] + w --- 三角不等式
如果有负权回路的话，最短路是不一定存在的
如果迭代了 n 次 ，第 n 次还在更新的话，一定存在一个最短路径，他的路径是 >= n 的
也就是路径上一定存在环
模板
int n, m; // n表示点数，m表示边数
int dist[N]; // dist[x]存储1到x的最短路距离
struct Edge // 边，a表示出点，b表示入点，w表示边的权重
{
int a, b, w;
}edges[M];
// 求1到n的最短路距离，如果无法从1走到n，则返回-1。
int bellman_ford()
{
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;
// 如果第n次迭代仍然会松弛三角不等式，就说明存在一条长度是n+1的最短路径，由抽屉原理，路径中至少存在两个相同的点，说明图中存在负权回路。
for (int i = 0; i < n; i ++ )
{
for (int j = 0; j < m; j ++ )
{
int a = edges[j].a, b = edges[j].b, w = edges[j].w;
if (dist[b] > dist[a] + w)
dist[b] = dist[a] + w;
}
}
if (dist[n] > 0x3f3f3f3f / 2) return -1;
return dist[n];
}
例题
给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环， 边权可能为负数。
请你求出从 1 号点到 n 号点的最多经过 k 条边的最短距离，如果无法从 1 号点走到 n 号点，输出
impossible。注意：图中可能 存在负权回路 。
输入格式
第一行包含三个整数 n,m,k。
接下来 m 行，每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。
点的编号为 1∼n。
输出格式
输出一个整数，表示从 1 号点到 n 号点的最多经过 k 条边的最短距离。
如果不存在满足条件的路径，则输出
impossible。数据范围
1≤n,k≤500,
1≤m≤10000,
1≤x,y≤n，
任意边长的绝对值不超过 10000。输入样例：
3 3 1 1 2 1 2 3 1 1 3 3输出样例：
3
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 510,M = 10010;
int n,m,k;
int dist[N],backup[N];
struct Edge{
int a,b,w;
}edge[M];
bool bellman_ford()
{
memset(dist,0x3f,sizeof dist);
dist[1] = 0;
//题目要求不超过 k 次，所以外层循环 k 次
for (int i = 0; i < k; i++) {
// 保证我们更新的时候只用上一次迭代的结果，所以备份一个数组，backup数组中存的就是上一次迭代的数组
memcpy(backup,dist,sizeof dist);
for (int j = 0; j < m; j++) {
int a = edge[j].a,b = edge[j].b,w= edge[j].w;
dist[b] = min(dist[b],backup[a]+w);
}
}
if (dist[n] > 0x3f3f3f3f / 2) return false;
return true;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
int a,b,w;
cin >> a >> b >> w;
edge[i] = {a,b,w};
}
if(bellman_ford())
{
cout << dist[n] << endl;
}else{
cout << "impossible" << endl;
}
return 0;
}
SPFA
求最短路
其实就是队列优化的 bellman-ford
核心思想，用已经被更新过的点去更新其他点，通俗地讲--只有我变小了，我后面的人才会变小
队列里存的就是待更新的点
模板
int n; // 总点数
int h[N], w[N], e[N], ne[N], idx; // 邻接表存储所有边
int dist[N]; // 存储每个点到1号点的最短距离
bool st[N]; // 存储每个点是否在队列中
// 求1号点到n号点的最短路距离，如果从1号点无法走到n号点则返回-1
int spfa()
{
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;
queue<int> q;
q.push(1);
st[1] = true;
while (q.size())
{
auto t = q.front();
q.pop();
st[t] = false;
for (int i = h[t]; i != -1; i = ne[i])
{
int j = e[i];
if (dist[j] > dist[t] + w[i])
{
dist[j] = dist[t] + w[i];
if (!st[j]) // 如果队列中已存在j，则不需要将j重复插入
{
q.push(j);
st[j] = true;
}
}
}
}
if (dist[n] == 0x3f3f3f3f) return -1;
return dist[n];
}
例题
给定一个 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
#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
const int N = 1e6;
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++;
}
bool spfa()
{
std::memset(dist,0x3f,sizeof dist);
dist[1] = 0;
queue<int> q;
q.push(1);
st[1] = true; //st数组存的是当前这个点是不是在队列当中
while(q.size())
{
int t = q.front();
q.pop();
st[t] = false;
for (int i = h[t]; i != -1 ; i = ne[i]) {
int j = e[i];
if (dist[j] > dist[t] + w[i])
{
dist[j] = dist[t] + w[i];
if (!st[j])
{
q.push(j);
st[j] = true;
}
}
}
}
if (dist[n] == 0x3f3f3f3f)
{
return false;
}else{
return true;
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> m;
memset(h,-1,sizeof h);
while(m--)
{
int a,b,c;
cin >> a >> b >> c;
add(a,b,c);
}
if (spfa())
{
cout << dist[n] << endl;
}else{
cout << "impossible" << endl;
}
return 0;
}
求负环
求负环的思路也是运用抽屉原理
我们额外维护一个 cnt 数组 cnt[x] 代表了当前最短路的边的个数
更新的时候 让 cnt[j] = cnt[t] + 1
那么如果 cnt[x] >= n 了代表着从 1-x 经过了至少 n 条边，也就是 n+1 个点 由抽屉原理可得 一定有两个点值是相同的
如果是正权的环是不会影响最短路的，所以一定是负环
模板
// 求负环
int n; // 总点数
int h[N], w[N], e[N], ne[N], idx; // 邻接表存储所有边
int dist[N], cnt[N]; // dist[x]存储1号点到x的最短距离，cnt[x]存储1到x的最短路中经过的点数
bool st[N]; // 存储每个点是否在队列中
// 如果存在负环，则返回true，否则返回false。
bool spfa()
{
// 不需要初始化dist数组
// 原理：如果某条最短路径上有n个点（除了自己），那么加上自己之后一共有n+1个点，由抽屉原理一定有两个点相同，所以存在环。
queue<int> q;
for (int i = 1; i <= n; i ++ )
{
q.push(i);
st[i] = true;
}
while (q.size())
{
auto t = q.front();
q.pop();
st[t] = false;
for (int i = h[t]; i != -1; i = ne[i])
{
int j = e[i];
if (dist[j] > dist[t] + w[i])
{
dist[j] = dist[t] + w[i];
cnt[j] = cnt[t] + 1;
if (cnt[j] >= n) return true; // 如果从1号点到x的最短路中包含至少n个点（不包括自己），则说明存在环
if (!st[j])
{
q.push(j);
st[j] = true;
}
}
}
}
return false;
}
例题
给定一个 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
#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
const int N = 1e6;
int n,m;
int h[N],w[N],e[N],ne[N],idx;
int dist[N],cnt[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++;
}
bool spfa()
{
queue<int> q;
for (int i = 0; i <= n; i++) {
st[i] = true;
q.push(i);
}
while(q.size())
{
int t = q.front();
q.pop();
st[t] = false;
for (int i = h[t]; i != -1 ; i = ne[i]) {
int j = e[i];
if (dist[j] > dist[t] + w[i])
{
dist[j] = dist[t] + w[i];
cnt[j] = cnt[t]+1;
if (cnt[j] >= n) return true;
if (!st[j])
{
q.push(j);
st[j] = true;
}
}
}
}
return false;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> m;
memset(h,-1,sizeof h);
while(m--)
{
int a,b,c;
cin >> a >> b >> c;
add(a,b,c);
}
if (spfa())
{
cout << "Yes" << endl;
}else{
cout << "No" << endl;
}
return 0;
}
Floyd
是用来求多源汇最短路问题的，用邻接矩阵来存储图
三重 1-n 的循环，每次更新一遍
循环完之后，d[i,j]存的就是 从 i - j 的最短路
原理是基于动态规划
模板
初始化：
for (int i = 1; i <= n; i ++ )
for (int j = 1; j <= n; j ++ )
if (i == j) d[i][j] = 0;
else d[i][j] = INF;
// 算法结束后，d[a][b]表示a到b的最短距离
void floyd()
{
for (int k = 1; k <= n; k ++ )
for (int i = 1; i <= n; i ++ )
for (int j = 1; j <= n; j ++ )
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}
例题
给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，边权可能为负数。
再给定 k 个询问，每个询问包含两个整数 x 和 y，表示查询从点 x 到点 y 的最短距离，如果路径不存在，则输出
impossible。数据保证图中不存在负权回路。
输入格式
第一行包含三个整数 n,m,k。
接下来 m 行，每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。
接下来 k 行，每行包含两个整数 x,y，表示询问点 x 到点 y 的最短距离。
输出格式
共 k 行，每行输出一个整数，表示询问的结果，若询问两点间不存在路径，则输出
impossible。数据范围
1≤n≤200,
1≤k≤n2
1≤m≤20000,
图中涉及边长绝对值均不超过 10000。输入样例：
3 3 2 1 2 1 2 3 2 1 3 1 2 1 1 3输出样例：
impossible 1
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 210,INF = 1e9;
int n,m,k;
int d[N][N];
void floyd()
{
for (int k = 1; k <= n ; k++) {
for (int i = 1; i <= n ; i++) {
for (int j = 1; j <= n ; j++) {
d[i][j] = min(d[i][j],d[i][k] + d[k][j]);
}
}
}
}
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n ; j++) {
if (i == j)
{
d[i][j] = 0;
}else{
d[i][j] = INF;
}
}
}
while(m--)
{
int a,b,w;
cin >> a >> b >> w;
d[a][b] = min(d[a][b],w);
}
floyd();
while(k--)
{
int x,y;
cin >> x >> y;
if (d[x][y] > INF / 2)
{
cout << "impossible" << endl;
}else{
cout << d[x][y] << endl;
}
}
}
