图论之单源最短路
// 0x3f 0x3f3f3f3f 的区别？
memset 按字节赋值，所以memset 0x3f 就等价与赋值为0x3f3f3f3f，
1. Dijkstra
int g[N][N]; //为稠密阵所以用邻接矩阵存储
int dist[N]; //用于记录每一个点距离第一个点的距离
bool st[N]; //用于记录该点的最短距离是否已经确定
int Dijkstra()
{
memset(dist, 0x3f,sizeof dist); //初始化距离 0x3f代表无限大
dist[1]=0; //第一个点到自身的距离为0
for(int i=0;i<n;i++) //有n个点所以要进行n次 迭代
{
int t=-1; //t存储当前访问的点
for(int j=1;j<=n;j++) //这里的j代表的是从1号点开始
if(!st[j]&&(t==-1||dist[t]>dist[j]))
t=j;
st[t]=true;
for(int j=1;j<=n;j++) //依次更新每个点所到相邻的点路径值
dist[j]=min(dist[j],dist[t]+g[t][j]);
}
if(dist[n]==0x3f3f3f3f) return -1; //如果第n个点路径为无穷大即不存在最低路径
return dist[n];
}
堆优化版的dijkstra是对朴素版dijkstra进行了优化，在朴素版dijkstra中时间复杂度最高的寻找距离最短的点O(n^2)可以使用小根堆优化。
- 一号点的距离初始化为零，其他点初始化成无穷大。
- 将一号点放入堆中。
- 不断循环，直到堆空。每一次循环中执行的操作为：
弹出堆顶（与朴素版diijkstra找到S外距离最短的点相同，并标记该点的最短路径已经确定）。
用该点更新临界点的距离，若更新成功就加入到堆中。
2. 堆优化版的Dijkstra
int dijkstra()
{
memset(dist, 0x3f, sizeof(dist));
dist[1] = 0;
priority_queue<PII, vector<PII>, greater<PII>> heap; // 定义一个小根堆
// 这里heap中为什么要存pair呢，首先小根堆是根据距离来排的，所以有一个变量要是距离，其次在从堆中拿出来的时
// 候要知道知道这个点是哪个点，不然怎么更新邻接点呢？所以第二个变量要存点。
heap.push({ 0, 1 }); // 这个顺序不能倒，pair排序时是先根据first，再根据second，这里显然要根据距离排序
while(heap.size())
{
PII k = heap.top(); // 取不在集合S中距离最短的点
heap.pop();
int ver = k.second, distance = k.first;
if(st[ver]) continue;
st[ver] = true;
for(int i = h[ver]; i != -1; i = ne[i])
{
int j = e[i]; // i只是个下标，e中在存的是i这个下标对应的点。
if(dist[j] > distance + w[i])
{
dist[j] = distance + w[i];
heap.push({ dist[j], j });
}
}
}
if(dist[n] == 0x3f3f3f3f) return -1;
else return dist[n];
}
3. Bellman-ford（有边数限制的最短路）
- SPFA算法各方面优于该算法，但是在碰到限制了最短路径上边的长度时就只能用bellman_ford了，此时直接把n重循环改成k次循环即可
- 如果边数限制为k，则外层循环为k，内层循环是枚举所有的边，对所有的边都进行一次松弛操作。如果没有边数限制的话，外层循环n次，内层每次松弛所有边，执行完之后一定会找到起点到终点的最短路了。
- 原题链接：https://www.acwing.com/problem/content/855/
这个题解写的好：https://www.acwing.com/solution/content/17551/
//这道题有收藏题解，写的挺不错的
#include<cstring>
#include<iostream>
#include<algorithm>
#include<stdio.h>
using namespace std;
const int N=510,M=10010;
int n,m,k;
int dist[N],backup[N];
struct Edge{
int a,b,w;
}edges[M];
int bellman_ford()
{
dist[1]=0;
// 如果k是n的话，就不需要backup数组了
for(int i=0;i<k;i++)
{
//为什么需要back[a]数组
// 为了避免串联情况，有可能1号点把2号点的距离更新了. 如果不用backup数组的话, 2号点会在本次循环中把3号点也更新了, 那就不对了. 计网中不是讲过吗
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);
}
}
// cout<<dist[n]<<endl;
// if(dist[n]>0x3f3f3f3f/2) return -1;
return dist[n];
}
int main()
{
scanf("%d%d%d",&n,&m,&k);
memset(dist,0x3f3f3f3f,sizeof dist);
for(int i=0;i<m;i++)
{
int a,b,w;
scanf("%d%d%d",&a,&b,&w);
edges[i]={a,b,w};
}
int t=bellman_ford();
// if(t==-1) puts("impossible");有道理，万一返回的t就是-1呢，那岂不是会输出impossible
//应该直接返回dist[n],在外边判断
if(dist[n]>0x3f3f3f3f/2) puts("impossible");
else printf("%d\n",t);
return 0;
}
4. SPFA
看这个题解：https://www.acwing.com/solution/content/9306/
Bellman_ford算法可以存在负权回路，是因为其循环的次数是有限制的因此最终不会发生死循环；但是SPFA算法不可以，由于用了队列来存储，只要发生了更新就会不断的入队，因此假如有负权回路请你不要用SPFA否则会死循环。
由于SPFA算法是由Bellman_ford算法优化而来，在最坏的情况下时间复杂度和它一样即时间复杂度为 O(nm)O(nm) ，假如题目时间允许可以直接用SPFA算法去解Dijkstra算法的题目。(好像SPFA有点小小万能的感觉?)
1] Dijkstra算法中的st数组保存的是当前确定了到源点距离最小的点，且一旦确定了最小那么就不可逆了(不可标记为true后改变为false)；SPFA算法中的st数组仅仅只是表示的当前发生过更新的点，且spfa中的st数组可逆(可以在标记为true之后又标记为false)。顺带一提的是BFS中的st数组记录的是当前已经被遍历过的点。
2] Dijkstra算法里使用的是优先队列保存的是当前未确定最小距离的点，目的是快速的取出当前到源点距离最小的点；SPFA算法中使用的是队列(你也可以使用别的数据结构),目的只是记录一下当前发生过更新的点。
#include<iostream>
#include<queue>
#include<cstring>
using namespace std;
const int N=1e5+10;
#define fi first
#define se second
typedef pair<int,int> PII;//到源点的距离，下标号
int h[N],e[N],w[N],ne[N],idx=0;
int dist[N];//各点到源点的距离
bool st[N];
int n,m;
void add(int a,int b,int c){
e[idx]=b;w[idx]=c;ne[idx]=h[a];h[a]=idx++;
}
int spfa(){
queue<PII> q;
memset(dist,0x3f,sizeof dist);
dist[1]=0;
q.push({0,1});
st[1]=true;
while(q.size()){
PII p=q.front();
q.pop();
int t=p.se;
st[t]=false;//从队列中取出来之后该节点st被标记为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]){//当前已经加入队列的结点，无需再次加入队列，即便发生了更新也只用更新数值即可，重复添加降低效率
st[j]=true;
q.push({dist[j],j});
}
}
}
}
if(dist[n]==0x3f3f3f3f) return -1;
else return dist[n];
}
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);
}
int res=spfa();
if(res==-1) puts("impossible");
else printf("%d",res);
return 0;
}
5. SPFA判断负环
题目链接：https://www.acwing.com/problem/content/854/
我的代码：https://www.acwing.com/problem/content/submission/code_detail/4350171/
//这道题也有收藏题解，利用抽屉原理，判断一下最短路径上是否有超过n-1
//条边，cnt[i]存i号点到源点的最短路上，边的数量。
//这道题让判断整个图中有无负环、上一题是求1到n的最短路,这道题也并不是让求从1开始的负环
//所以题解中有个思想很好，就是假设一个虚拟原点，初始把所有的点都加到队列中
/*
多加一个0号顶点，到其他顶点的距离都是零，求0到其他顶点的最短路，如果0到i号顶点的最短路中超过了n-1个节点
那么整个图中必定存在负环。那么本题中就必定存在负环，所以说开始把所有顶点都加入到队列中的操作，等于上述设虚拟原点
的操作，上述虚拟原点的新图中，0到任意一个点有负环，就等于原来的图中一定存在负环，可以画个图理解一下
*/
#include<cstring>
#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;
const int N=100010;
int n,m;
int h[N],w[N],ne[N],e[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()
{
//这里的把dist数组初始化为正无穷的操作也就不用了
//因为我们最后注意的是cnt数组，而不是dist，dist刚开始是0的话也无所依
//图中存在负环的话，cnt必然会>=n,相当于所有距离都减去了正无穷，但是并不
//影响最后cnt的判断
//更牛逼的解释来了！
// 观察这个更新操作，if(dist[j] > dist[t] + w[i]) )
//如果存在负环，则一定会更新无穷次。cnt数组肯定会>=n的 ！所以不初始化dist也没事!!
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(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()
{
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()) puts("Yes");
else puts("No");
return 0;
}
954
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
