bellman_ford+spfa
bellman_ford
这次加入一些自己的思考
循环k次,当前就是所谓的最多经过了k条边的啦
然后针对每一次,都是在上一次的基础已经更新过了,把更新的都更新了,举个栗子就是,一开始我只有dist[1] = 0,这个时候其他的点都是INF,然后我就循环所有边,看看用dist[0]这个点能更新什么就更新了,然后用更新过后的结果,来再次循环所有的边
这里的bf算法会出现负权路径,并且INF +负数小于INF,所以判断条件要写 > INF / 2
它的存边方式就比较随意了,可以随便存,只要能遍历到所有的边就行,也就是可以用结构体直接进行存储
如果有负权回路的话,最短路不一定存在,比如如果负权回路虽然存在,但是,这个负权回路无法到达终点,这种情况最短路还是存在的, 但是如果在最短路上的话,这个最短路就是不存在的
spfa要求图中不能有负环
思路就是两个循环,先循环要走过多少个边(最多就是n-1个,因为最短路最多就是n-1个),再循环所有的边,就是每次都看一下每边能更新什么就更新什么,但是都要是用上一条边更新之后的结果,所以要出现一个backup数组
#include <bits/stdc++.h>
using namespace std;
#define int long long
const int N = 510;
int backup[N],dist[N];
struct node
{
int a, b, w;
}r[10010];
int n, m, k;
void bellman_ford()
{
dist[1] = 0;
for(int i=1; i<=k; i++)
{
memcpy(backup, dist, sizeof dist);
for(int j=1; j<=m; j++)
{
int a = r[j].a;
int b = r[j].b;
int w = r[j].w;
// cout << a << b << w<<endl;
dist[b] = min(dist[b], backup[a] + w);
}
}
// if(dist[n] > 0x3f3f3f3f3f3f3f3f / 2) return -1;
// return dist[n];
}
signed main()
{
memset(dist, 0x3f, sizeof dist);
cin>>n>>m>>k;
// cout << n << m << k<<endl;
int a, b, c;
for (int i = 1; i <= m; i ++ )
{
cin>>a>>b>>c;
// cout << a << b << c<<endl;
r[i]= {a, b, c};
}
bellman_ford();
if(dist[n] > 0x3f3f3f3f3f3f3f3f / 2) cout << "impossible" << endl;
else cout << dist[n] << endl;
return 0;
}
spfa
最短路
spfa算法中,存储更新了的点的数据结构,可以是队列,可以说堆,可以是优先队列,这都可以
spfa虽然会被卡成nm,但是很常用,卡了再换嘛
感觉spfa的思想就是,我直接存边,然后开始从第一个点开始循环,先更新跟起始点联通的点,然后就继续,把更新过的点放进队列,如果队列不空,就用这些更新过的点,再更新其他点
原理大概就是,看一下BF算法,它dist[b] = min(dist[b], backup[a] + w);里面只有dist[a]被更新过,dist[b]才会被更新
这个我一直有个疑惑就是,为啥一开始要st[1] = 0,后来发现,去掉也对,然后发现,去掉了st数组好像也行,然后就明白,这里的st数组类似dij的堆优化,应该是尽量减少冗余,降低时间复杂度
至于为什么这里是判断 == INF,我们是因为,你可以发现,他这里只会更新能走到的地方,走不到的点都不会进行更新,所以就走不到的话不会更新
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define PII pair<int, int>
#define x first
#define y second
#define endl '\n'
const int N = 1e5 + 10;
vector<PII> v[N];
int dist[N], st[N];
int n, m, k, a, b, c;
void spfa() // 求1号点到n号点的最短路距离,如果从1号点无法走到n号点则返回-1
{
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;
queue<int> q;
q.push(1);
st[1] = 1;
while(!q.empty())
{
int num = q.front();
q.pop();
st[num] = 0;
for(auto i : v[num])
{
if(dist[i.x] > dist[num] + i.y)
{
dist[i.x] = dist[num] + i.y;
if(!st[i.x])
{
q.push(i.x);
st[i.x] = 1;
}
}
}
}
}
signed main()
{
cin >> n >> m;
for(int i=1; i<=m; i++)
{
cin >> a >> b >> c;
v[a].push_back({b, c});
}
spfa();
if (dist[n] == 0x3f3f3f3f3f3f3f3f) puts("impossible");
else cout << dist[n] << endl;;
return 0;
}
判负环
思路大概就是用spfa求最短路,用cnt数组记录一下,从起点到终点最短路上经过的边数,如果有n个边,就需要有n+1个点,然后根据抽屉原理,一定有一个点相同。就形成了一个环。
但是这里跟spfa又不太一样,这里的dist数组不需要初始化,因为判断的是负环,所以0作为初始值,也可以进行更新
#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;
#define int long long
#define x first
#define y second
const int N = 2010, M = 1e4 + 10;
int n, m, a, b, c;
bool st[N];
#define PII pair<int, int>
vector<PII> v[N];
int dist[N], cnt[N];
bool spfa() // 如果存在负环,则返回true,否则返回false。
{
queue<int> q;
for (int i = 1; i <= n; i ++ ) q.push(i), st[i] = true;
while (!q.empty())
{
int t = q.front();
q.pop();
st[t] = false;
for (auto i : v[t])
{
if(dist[i.x] > dist[t] + i.y)
{
dist[i.x] = dist[t] + i.y;
cnt[i.x] = cnt[t] + 1;
if(cnt[i.x] >= n) return 1;
if(!st[i.x])
{
q.push(i.x);
st[i.x];
}
}
}
}
return false;
}
signed main()
{
cin >> n >> m;
for (int i = 1; i <= m; i ++ )
{
cin >> a >> b >> c;
v[a].push_back({b, c});
}
if(spfa()) cout << "Yes" << endl;
else cout << "No" << endl;
return 0;
}