目录
一、Bellman_ford算法
bellman算法主要适用于有限边问题,问题中边的权值可能为负,当然因为边有限,不会出现负无穷的结果
1.如何实现+代码模板
1.将dis数组初始值设为正无穷,并将dis[1]设为0;
memset(dis, 0x3f, sizeof dis);
dis[1] = 0;
2.bellman的双循环结构
for (int i = 0; i < k; i++)//k条边的限制,k次循环
{
memcpy(backup, dis, sizeof dis);
for (int j = 0; j < m; j++)
{
int a = stu[j].a, b = stu[j].b, w = stu[j].w;
}
}
其中,备份出来的backup很重要.
假设k=1的情况下,比如1->2是一条边了,如果不对其进行备份,那么2就会更新成起点2->3不会是第二次迭代,而是第一次迭代,如此下去,k条边的限制形同虚设,所以要将dis数组备份,并使用backup数组进行更新。
3.如果最终仍为dis[n]仍为正无穷返回-1,否则返回dis[n];
if (dis[n] > 0x3f3f3f3f / 2)return -1;
return dis[n];
为什么是>03f3f3f3f/2 是因为,到最后一个更新的时候,后面一条边可能是负数,则就不是0x3f3f3f3f了
代码模板:
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];
}
作者:yxc
链接:https://www.acwing.com/blog/content/405/
来源:AcWing
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
2.相关例题
例题来自Acwing
给定一个 n 个点 m 条边的有向图,图中可能存在重边和自环, 边权可能为负数。
请你求出从 11 号点到 n 号点的最多经过 k 条边的最短距离,如果无法从 11 号点走到 n号点,输出 impossible
。
注意:图中可能 存在负权回路 。
输入格式
第一行包含三个整数 n,m,k。
接下来 m行,每行包含三个整数 x,y,z,表示存在一条从点 x 到点 y 的有向边,边长为 z。
点的编号为 1∼n1。
输出格式
输出一个整数,表示从 11 号点到 n 号点的最多经过 k 条边的最短距离。
如果不存在满足条件的路径,则输出 impossible
。
数据范围
1≤n,k≤500
1≤m≤10000
1≤x,y≤n
任意边长的绝对值不超过 1000010000。
输入样例:
3 3 1
1 2 1
2 3 1
1 3 3
输出样例:
3
Ac代码:
#include<bits/stdc++.h>
using namespace std;
const int N =510,M=10010;
int dis[N],backup[N];
int n,m,k;
struct ss
{
int a,b,w;
}stu[M];
int bellman()
{
memset(dis,0x3f,sizeof dis);
dis[1]=0;
for(int i=0;i<k;i++)
{
memcpy(backup,dis,sizeof dis);//copy
for(int j=0;j<m;j++)
{
int a=stu[j].a,b=stu[j].b,w=stu[j].w;
dis[b]=min(dis[b],backup[a]+w);
}
}
if(dis[n]>0x3f3f3f3f/2)return -1;
return dis[n];
}
int main()
{
scanf("%d%d%d",&n,&m,&k);
for(int i=0;i<m;i++)
{
int a,b,w;
scanf("%d%d%d",&a,&b,&w);
stu[i]={a,b,w};
}
int t =bellman();
if(t == -1)printf("impossible");
else
printf("%d",t);
}
二、spfa算法
spfs算法一般时间复杂度为O(m)但是如果题目卡数据的话,时间复杂度可能会达到O(mn);
spfa算法与dijkstra算法和bellman算法都有相似之处
代码模板:
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];
}
作者:yxc
链接:https://www.acwing.com/blog/content/405/
来源:AcWing
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
相关例题:
例题来自Acwing
给定一个 n个点 m条边的有向图,图中可能存在重边和自环, 边权可能为负数。
请你判断图中是否存在负权回路。
输入格式
第一行包含整数 n 和 m。
接下来 m行每行包含三个整数 x,y,z表示存在一条从点 x 到点 y 的有向边,边长为 z。
输出格式
如果图中存在负权回路,则输出 Yes
,否则输出 No
。
数据范围
1≤n≤2000
1≤m≤10000
图中涉及边长绝对值均不超过 1000010000。
输入样例:
3 3
1 2 -1
2 3 4
3 1 -4
输出样例:
Yes
这道题有一个抽屉原理:我们用cnt数组来储存边,一共有n个点,如果cnt>=n说明至少出现了n+1个点,而总数只有n个点,说明至少有一个点出现了两次,而我们是求最短路径,就说明从当前点再回到当前点路径是减少的,也即出现了负权回路.
Ac代码:
#include<bits/stdc++.h>
using namespace std;
const int N =100010;
int idx,e[N],ne[N],w[N],n,m,h[N],dis[N],cnt[N];
bool st[N];
int add(int a,int b,int c)
{
e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}
int spfa()
{
queue<int>q;
for(int i=1;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(dis[j]>dis[t]+w[i])
{
dis[j]=dis[t]+w[i];
cnt[j]=cnt[t]+1;
if(cnt[j]>=n)return true;
if(!st[j])
{
st[j]=true;
q.push(j);
}
}
}
}
return false;
}
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);
}
if(spfa())printf("Yes");
else printf("No");
}
三、floyd算法
前面的都是单源最短路问题,floyd算法针对的是多源最短路,时间复杂度是O(n^3);
//n表示点数
//初始化:
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
图中涉及边长绝对值均不超过 1000010000。
输入样例:
3 3 2
1 2 1
2 3 2
1 3 1
2 1
1 3
输出样例:
impossible
1
题解:
#include<bits/stdc++.h>
using namespace std;
const int N = 210, INF = 1e9;
int n, m, Q;
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()
{
scanf("%d%d%d", &n, &m, &Q);
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;
scanf("%d%d%d", &a, &b, &w);
d[a][b] = min(d[a][b], w);
}
floyd();
while (Q--)
{
int a, b;
scanf("%d%d", &a, &b);
if (d[a][b] >INF/2)printf("impossible\n");
else printf("%d\n", d[a][b]);
}
}