地址:
描述:
思路:
问题一:
为什么需要backup[N]数组
假如边数没有限制必须为1条,不需要使用backup[]数组
为了避免如下的串联情况, 在边数限制为一条的情况下,节点3的距离应该是3,但是由于串联情况,利用本轮更新的节点2更新了节点3的距离,所以现在节点3的距离是2。
正确做法是用上轮节点2更新的距离--无穷大,来更新节点3, 再取最小值,所以节点3离起点的距离是3。
for (int i = 0; i < k; i ++ )
{
memcpy(backup, dist, sizeof dist);
for (int j = 0; j < m ; j ++ )
{
int a = edges[j].a, b = edges[j].b, w = edges[j].w;
dist[b] = min(dist[b], backup[a] + w);
}
}
问题二:
为什么是dist[n]>0x3f3f3f3f/2, 而不是dist[n]==0x3f3f3f3f
5号节点距离起点的距离是无穷大,利用5号节点更新n号节点距离起点的距离,将得到10^9-2, 虽然小于10^9, 但并不存在最短路,(在边数限制在k条的条件下)。
代码:
正常模板:
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];
}
本题:
#include <cstring>
#include <iostream>
using namespace std;
//1<=n,k<=500 1<=m<=10000
int n,m,k;
const int N=510,M=10010;
int dist[N],backup[N];
struct Edge{
int a,b,w;
}edge[M];
void bellman_fort(){
dist[1]=0;
//k代表最短路径最多包涵k条边
for(int i=0;i<k;i++){
//很重要备份数组防止串联
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;
if(dist[b]>backup[a]+w){
dist[b]=backup[a]+w;
}
}
}
if(dist[n]>=0x3f3f3f3f/2) cout<<"impossible";
else cout<<dist[n];
}
int main(){
cin>>n>>m>>k;
memset(dist,0x3f,sizeof dist);
for(int i=0;i<m;i++){
int a,b,w;
cin>>a>>b>>w;
edge[i]={a,b,w};
}
bellman_fort();
}