ACwing算法备战蓝桥杯——Day16——spfa

最新推荐文章于 2024-09-12 19:02:20 发布

切勿踌躇不前

最新推荐文章于 2024-09-12 19:02:20 发布

阅读量142

点赞数

分类专栏：算法学习笔记文章标签：算法 c++ 开发语言 Powered by 金山文档

本文链接：https://blog.csdn.net/weixin_73569934/article/details/129372156

版权

算法学习笔记专栏收录该内容

27 篇文章 0 订阅

订阅专栏

文章介绍了两种用于寻找带负权边的图中最短路径的算法：Bellman-Ford算法及其优化SPFA。Bellman-Ford算法能检测负权回路，而SPFA是其优化版本，平均时间复杂度更低。文章提供了模板代码示例，展示了如何使用这两种算法解决最短路径问题，包括限制边数的情况以及检测负权回路的存在。

摘要由CSDN通过智能技术生成

spfa是bellman_Ford算法的优化，基于dp。

求带负权的最短路径;

bellman_Ford算法:

模板:

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>
#include <cstdio>
using namespace std;
const int N=510,M=10010;

struct Edge{
    int a,b,w;   
}edge[M];

int n,m,k;
int dist[N],backup[N];

int bellman_ford(){
    memset(dist,0x3f,sizeof dist);//实际上0x3f3f3f3f只有int最大值的一半
    dist[1]=0;
    
    for(int i=0;i<k;i++){//循环k次表示从1到其余点边数不超过k的最短路径
        
        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  0x3f3f3f3f;
    else return dist[n];
}

int main(){

    cin>>n>>m>>k;
    
    for(int i=0;i<m;i++){
        int a,b,w;
        scanf("%d%d%d",&a,&b,&w);
        edge[i].a=a;
        edge[i].b=b;
        edge[i].w=w;
    }
    
    int res=bellman_ford();
    
    if(res==0x3f3f3f3f) puts("impossible");
    else cout<<res<<endl;
    
    return 0;
}

spfa求最短路:(对bellman_Ford算法的优化):

模板：

平均时间复杂度为O(m),最坏为O(n*m);

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=1e5+10;

int n,m;
int h[N],ne[N],e[N],w[N],idex;
int dist[N];
bool st[N];

void add(int a,int b,int c){
    ne[idex]=h[a],e[idex]=b,w[idex]=c,h[a]=idex++;    
}

int spfa(){
    memset(dist,0x3f,sizeof dist);
    dist[1]=0;
    
    queue<int> q;
    q.push(1);
    st[1]=true;
    
    while(q.size()){
        int t=q.front();
        q.pop();
        
        st[t]=false;
        
        for(int j=h[t];j!=-1;j=ne[j]){
            int k=e[j];
            if(dist[k]>dist[t]+w[j]){
                dist[k]=dist[t]+w[j];
                if(!st[k]){
                    q.push(k);
                    st[k]=true;
                }
            }
        }
    }
    return dist[n];
}

int main(){
    memset(h,-1,sizeof h);
    
    cin>>n>>m;
    
    for(int i=0;i<m;i++){
        int a,b,w;
        scanf("%d%d%d",&a,&b,&w);
        add(a,b,w);
    }
    
    int res=spfa();
    
    if(res==0x3f3f3f3f) puts("impossible");
    else cout<<res<<endl;
    
    return 0;
}

spfa求是否有负权自环:

模板：

时间复杂度是 O(nm), n 表示点数，m 表示边数

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 <queue>
#include <cstring>
using namespace std;

const int N=2010,M=10010;

int n,m;

int e[M],ne[M],h[M],w[M],idex;
int d[N],cnt[N];
bool st[N];

void add(int a,int b,int c){
    ne[idex]=h[a],e[idex]=b,w[idex]=c,h[a]=idex++;
}

int spfa(){
    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(d[j]>d[t]+w[i]){
                d[j]=d[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(){
    memset(h,-1,sizeof h);
    cin>>n>>m;
    
    for(int i=0;i<m;i++){
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        add(a,b,c);
    }
    
    bool res=spfa();
    
    if(res) puts("Yes");
    else puts("No");
    
    return 0;
}