AcWing 851. spfa求最短路&&AcWing 852. spfa判断负环—spfa算法

11 篇文章 0 订阅
10 篇文章 0 订阅

问题链接:AcWing 851. spfa求最短路
问题描述
在这里插入图片描述
spfa算法是对bellman-ford算法的改进,bellman-ford算法比较笨,要遍历所有边来更新,其实如果当前点没有被更新的话,就不用用当前点来更新他所连接的点了。我们只需要每次更新一个点后,继续更新该点连接的点即可。
代码如下:

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;
const int N=1e5+10,M=1e5+10,INF=0x3f3f3f3f;

struct E{
    int v,w,nxt;
};
E edge[M];
int head[N], idx=0;
int n,m;
int dist[N];
int st[N];

void init(){
    for(int i=0;i<=n;i++){
        head[i]=-1;
        dist[i]=INF;
    }
}
void add(int u,int v,int w){
    edge[idx].v=v;
    edge[idx].w=w;
    edge[idx].nxt=head[u];
    head[u]=idx++;
}
int spfa(){
    dist[1]=0;
    st[1]=1;
    queue<int> q;
    q.push(1);
    while(!q.empty()){
        int t=q.front();
        q.pop();
        st[t]=0;
        for(int i=head[t];~i;i=edge[i].nxt){
            int v=edge[i].v;
            int w=edge[i].w;
            if(dist[v]>dist[t]+w){
                dist[v]=dist[t]+w;
                if(!st[v]){
                    q.push(v);
                    st[v]=1;
                }
            }
        }
    }
    return dist[n];
}
int main(){
    cin>>n>>m;
    init();
    while(m--){
        int u,v,w;
        scanf("%d%d%d",&u,&v,&w);
        add(u,v,w);
    }
    int k=spfa();
    if(k<INF/2) cout<<k;
    else puts("impossible");
    return 0;
}

我这里用的是链式前向星来存图
问题链接:AcWing 852. spfa判断负环
问题描述
在这里插入图片描述
正如bellman-ford算法中提到的,一个点到其余点的最短路径,最长需要经过n-1条边,所以如果有大于等于n条边,则说明一定有环。注意从单元点出发,有可能找不到环,因为环不一定在最短路径上。
代码如下:

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;
const int N=1e5+10,M=1e5+10,INF=0x3f3f3f3f;

struct E{
    int v,w,nxt;
};
E edge[M];
int head[N], idx=0;
int n,m;
int dist[N];
int st[N];
int cnt[N];

void init(){
    for(int i=0;i<=n;i++){
        head[i]=-1;
        dist[i]=INF;
    }
}
void add(int u,int v,int w){
    edge[idx].v=v;
    edge[idx].w=w;
    edge[idx].nxt=head[u];
    head[u]=idx++;
}
bool spfa(){
    dist[1]=0;
    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]=0;
        for(int i=head[t];~i;i=edge[i].nxt){
            int v=edge[i].v;
            int w=edge[i].w;
            if(dist[v]>dist[t]+w){
                cnt[v]=cnt[t]+1;
                if(cnt[v]>=n) return false;
                dist[v]=dist[t]+w;
                if(!st[v]){
                    q.push(v);
                    st[v]=1;
                }
            }
        }
    }
    return true;
}
int main(){
    cin>>n>>m;
    init();
    while(m--){
        int u,v,w;
        scanf("%d%d%d",&u,&v,&w);
        add(u,v,w);
    }
    int k=spfa();
    if(!k) puts("Yes");
    else puts("No");
    return 0;
}
  • 5
    点赞
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
SPFA算法(Shortest Path Faster Algorithm)是一种用于解决最短路问题的算法。它是一种单源最短路算法,可以解决带有权边的图的最短路径问题。 SPFA算法基本思想是使用队列对图中的所有节点进行遍历,对于每一个节点,如果它的邻居节点的最短路径可以通过当前节点更新,则将邻居节点加入队列中进行下一轮遍历,直到所有节点的最短路径都被更新后停止遍历。 在Java中,可以使用邻接矩阵或邻接表来表示图,并使用队列来实现SPFA算法。下面是一个使用邻接矩阵实现SPFA算法的Java代码示例: ```java import java.util.*; public class SPFA { public static void main(String[] args) { int[][] graph = { {0, 2, 5, Integer.MAX_VALUE, Integer.MAX_VALUE}, {Integer.MAX_VALUE, 0, 7, 1, Integer.MAX_VALUE}, {Integer.MAX_VALUE, Integer.MAX_VALUE, 0, 4, Integer.MAX_VALUE}, {Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE, 0, 3}, {Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE, 0} }; int[] dist = shortestPath(graph, 0); System.out.println(Arrays.toString(dist)); } public static int[] shortestPath(int[][] graph, int start) { int n = graph.length; int[] dist = new int[n]; Arrays.fill(dist, Integer.MAX_VALUE); dist[start] = 0; Queue<Integer> queue = new LinkedList<>(); queue.offer(start); boolean[] inQueue = new boolean[n]; inQueue[start] = true; while (!queue.isEmpty()) { int u = queue.poll(); inQueue[u] = false; for (int v = 0; v < n; v++) { if (graph[u][v] != Integer.MAX_VALUE && dist[v] > dist[u] + graph[u][v]) { dist[v] = dist[u] + graph[u][v]; if (!inQueue[v]) { queue.offer(v); inQueue[v] = true; } } } } return dist; } } ``` 在上面的代码中,我们使用一个二维数组`graph`来表示图,其中`graph[i][j]`表示从节点`i`到节点`j`的边的权重,如果没有边则为`Integer.MAX_VALUE`。函数`shortestPath`接受一个图和一个起点`start`,返回一个数组`dist`,其中`dist[i]`表示从起点`start`到节点`i`的最短路径。 在函数中,我们首先初始化`dist`数组为`Integer.MAX_VALUE`,表示所有节点到起点的距离都是无限大。然后将起点`start`加入队列中,并标记为已加入队列。进入循后,每次取出队列中的一个节点`u`,将`u`标记为未加入队列,然后遍历`u`的所有邻居节点`v`,如果从起点到`v`的距离可以通过从起点到`u`再加上`u`到`v`的距离来更新,则更新`dist[v]`的值,并将`v`加入队列中,并标记为已加入队列。当队列为空时,所有节点的最短路径都已被更新,函数返回`dist`数组。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

chp的博客

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值