【原创】SPFA判负环

【定义与概念】

给定一张有向图,若其中存在一个环的所有权值之和为负数,这个环称为负环。

【算法实现】

当然,负环的求解可以暴搜,但是时间复杂度就难以入眼了,我们回到求解单源最短路径算法上面,看看它们能否求解。

我们知道

各种最短路算法
算法名称能否处理负边时间复杂度
Dijkstra不能,负权的存在使得最短路径不一定最短O(n^2)
堆优化Dijkstra不能,如上O(mlogn)
Bellman-FordO(nm)
SPFAO(km)

 

 

 

 

 

 

 

 

 

 

 

我们主要使用SPFA,讲一下SPFA判断负环。

SPFA有三种以上的方法判断负环:

  1. 设cnt[x]表示1~x的最短路径包含边数,cnt[1]=0。当收敛边权(判断三角形不等式)时,更新cnt[y]=cnt[x]+1。如果某时cnt[x]>=边的总数m,说明存在负环。
  2. 记录每个点入队的次数,如果某个点入队次数超过点的总数n,说明存在最小环。
  3. 卡时判负环,判负环最骚的操作。给队列总长度做限制,超过限制说明有环。至于这个限制具体是什么,请去问玄学,我不知道。

 

给出第一、二种解法的参考吧。

拿道板子题出来。

P3385 【模板】负环

 注意这道题鬼畜的输出。。。

这是第一种: 573ms /  5.04MB AC

 1 #include<cstdio>
 2 #include<iostream>
 3 #include<cmath>
 4 #include<queue>
 5 #include<algorithm>
 6 #include<cstring>
 7 #include<vector>
 8 #include<ctime>
 9 #define N 10010
10 using namespace std;
11 priority_queue<int,vector<int>,greater<int> > q;
12 int head[N],tot,n,m,d[N],cnt[N];
13 struct rec{
14     int next,ver,edge;
15 }g[N<<1];
16 void add(int x,int y,int val){
17     g[++tot].ver=y,g[tot].edge=val;
18     g[tot].next=head[x],head[x]=tot;
19 }
20 bool spfa(int x)
21 {
22     memset(d,0x3f,sizeof(d));
23     memset(cnt,0,sizeof(cnt));
24     d[x]=0;cnt[x]=1;
25     q.push(x);
26     while(q.size())
27     {
28         int index=q.top();q.pop();
29         for(int i=head[index];i;i=g[i].next){
30             int y=g[i].ver,z=g[i].edge;
31             if(d[y]>d[index]+z){
32                 d[y]=d[index]+z;
33                 cnt[y]=cnt[index]+1;
34                 if(cnt[y]>=m) return 1;
35                 q.push(y);
36             }
37         }
38     }
39     return 0;
40 }
41 int main()
42 {
43     int t;
44     cin>>t;
45     while(t--)
46     {
47         memset(g,0,sizeof(g));
48         memset(head,0,sizeof(head));
49         if(!q.empty()) q.pop();
50         tot=0;
51         scanf("%d%d",&n,&m);
52         for(int i=1;i<=m;i++){
53             int x,y,val;
54             scanf("%d%d%d",&x,&y,&val);
55             if(val<0) add(x,y,val);
56             else add(x,y,val),add(y,x,val);
57         }
58         if(spfa(1)) cout<<"YE5"<<endl;
59         else cout<<"N0"<<endl;
60     }
61     return 0;
62 }

 

这是第二种:1965ms /  9.04MB 91pnts

 1 #include<cstdio>
 2 #include<iostream>
 3 #include<cmath>
 4 #include<queue>
 5 #include<algorithm>
 6 #include<cstring>
 7 #include<vector>
 8 #define N 10010
 9 using namespace std;
10 priority_queue<int,vector<int>,greater<int> > q;
11 int head[N],tot,n,m,d[N],cnt[N];
12 struct rec{
13     int next,ver,edge;
14 }g[N<<1];
15 void add(int x,int y,int val){
16     g[++tot].ver=y,g[tot].edge=val;
17     g[tot].next=head[x],head[x]=tot;
18 }
19 bool spfa(int x)
20 {
21     memset(v,0,sizeof(v));
22     memset(d,0x3f,sizeof(d));
23     memset(cnt,0,sizeof(cnt));
24     d[x]=0;cnt[x]=1;
25     q.push(x);
26     while(q.size())
27     {
28         int index=q.top();q.pop();
29         for(int i=head[index];i;i=g[i].next){
30             int y=g[i].ver,z=g[i].edge;
31             if(d[y]>d[index]+z){
32                 d[y]=d[index]+z; 
33                 if(cnt[y]>=n) return 1;
34                 cnt[y]++,q.push(y),v[y]=1;
35             }
36         }
37     }
38     return 0;
39 }
40 int main()
41 {
42     int t;
43     cin>>t;
44     while(t--)
45     {
46         memset(g,0,sizeof(g));
47         memset(head,0,sizeof(head));
48         if(!q.empty()) q.pop();
49         tot=0;
50         scanf("%d%d",&n,&m);
51         for(int i=1;i<=m;i++){
52             int x,y,val;
53             scanf("%d%d%d",&x,&y,&val);
54             if(val<0) add(x,y,val);
55             else add(x,y,val),add(y,x,val);
56         }
57         if(spfa(1)) cout<<"YE5"<<endl;
58         else cout<<"N0"<<endl;
59     }
60     return 0;
61 }

 

转载于:https://www.cnblogs.com/DarkValkyrie/p/10999902.html

### SPFA算法检测的实现及原理 SPFA(Shortest Path Faster Algorithm)是一种用于解决单源最短路径问题的有效算法,尤其适用于含有权边但不包含的情况。然而,在实际应用中,如果图中存在SPFA可能陷入无限循,因此需要一种机制来检测这种特殊情况。 #### 的存在条件 指的是在一个图中存在一条回路,该回路上所有边的权重之和为数。由于每次经过这条回路都会使路径长度变得更小,理论上可以不断绕圈从而得到无穷小的距离值[^1]。 #### SPFA算法的工作方式 SPFA的核心思想是利用队列进行广度优先搜索(BFS),并通过松弛操作更新节点到起点之间的距离。具体来说,对于每一个从队列弹出的顶点u,遍历它所有的邻接点v,并尝试用当前已知的最佳路径加上(u,v)这条边的成本去改进到达v点的距离。一旦发现新的更优解,则将v重新放入队列等待进一步探索[^3]。 #### 检测的关键技术 尽管标准版SPFA不具备内置功能自动识别,但可以通过增加额外计数器变量`cnt[]`记录每个结点被访问(即入队)的最大次数来间接完成此任务: - **初始化阶段**: 设置数组 `dis[]` 表示各顶点至源点间的最小估计成本;设初值均为正无穷大(+∞),除了起始位置设置成零外(`dis[s]=0`)。另外定义辅助数组 `inQueue[]`,用来标记哪些顶点正处于队列之中以防重复插入相同元素浪费时间资源。 - **核心逻辑修改**: - 当某顶点再次进入队列前检查它的累计入队数目是否已经超过整个网络中的总定点数量V; 如果满足上述条件则立即终止运算并报告发现了不可接受状况—存在至少一个权闭合链表结构[^2]. 以下是具体的伪代码描述如何扩展基础版本以支持探测: ```python from collections import deque def spfa_with_negative_cycle_detection(graph, start_node, num_nodes): dis = [float('inf')] * (num_nodes + 1) cnt = [0] * (num_nodes + 1) in_queue = [False] * (num_nodes + 1) queue = deque() dis[start_node] = 0 queue.append(start_node) in_queue[start_node] = True while queue: u = queue.popleft() in_queue[u] = False for v, weight in graph[u]: if dis[v] > dis[u] + weight: dis[v] = dis[u] + weight if not in_queue[v]: cnt[v] += 1 # If a node is relaxed more than the number of nodes times, # then there must be a negative cycle. if cnt[v] >= num_nodes: return "Negative Cycle Detected" queue.append(v) in_queue[v] = True return "No Negative Cycles Found" ``` 在这个增强型函数里,我们引入了一个名为`cnt[]`的新列表跟踪各个节点经历过的放松迭代轮次。每当某个特定节点准备第二次加入工作序列之前都要先核查其对应统计数值是不是已经达到了预设界限——也就是等于总的节点个数N。如果是的话就意味着系统内部必然隐藏着某种形式上的面反馈闭现象发生,此时应该立刻停止后续计算动作并向外界发出警告信号表明遇到了非法情形[^4]。 ### 结论 综上所述,虽然原始形态下的SPFA并不自带针对形拓扑结构的有效甄别手段,不过借助简单的附加措施比如设立专门监控指标就可以轻松弥补这项缺陷进而构建更加健壮可靠的解决方案出来供人们日常开发实践当中选用。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值