一个我认为比较好的Spfa模板（使用邻接表和队列实现）

最新推荐文章于 2023-09-08 08:44:25 发布
原创 最新推荐文章于 2023-09-08 08:44:25 发布 · 2.2k 阅读 · 6 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Spfa #邻接表 #ACM

本文详细介绍了使用邻接表和队列实现的SPFA（Shortest Path Faster Algorithm）模板，包括全局变量的初始化、邻接表结构、添加边的函数以及SPFA核心算法的实现过程。通过SPFA可以找到图中从源点到各个点的最短路径，区别于Dijkstra算法，SPFA维护的是一个包含源节点的队列。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

全局准备工作 
int N, X;	//N为点数 X为源点
int head[MAXN];	//head[src]表示以head为出发点的邻接表表头在数组Adj中的位置，开始时所有元素初始化为-1
int nodeP;	//在邻接表和指向表头的head数组中定位用的记录指针，开始时初始化为0
int dist[MAXN];	//储存到源节点的距离，在Spfa()中初始化
bool vis[MAXN];	//这里vis作inqueue解释会更好，出于习惯使用了vis来命名，在Spfa()中初始化
 Node定义 

struct Node {
    int v, w, next;
}Adj[MAXM];
v即vertex，这里意思相当于被指向的点to，w相当于weight，代表边权，next用来指向在Adj中下一个从相同src出发的边指向的点 

 

 addEdge函数 

void addEdge(int src, int to, int weight)
{
    Adj[nodeP].v = to;
    Adj[nodeP].w = weight;
    Adj[nodeP].next = head[src];
    head[src] = nodeP++;
}
addEdge(a, b, w)作用是在数组Adj中留下一条记录了去向和边权的记录，且其next指向表中相同src指向的下一个点，同时更新了head表头 

 

 Spfa主体 

void Spfa()
{
    queue<int> que;
    int i;
    for(i = 1; i <= N; i++) {
        dist[i] = NIL;
        vis[i] = false;
    }
  

                

        

    

    
  


        

            

                      
                        最低0.47元/天 解锁文章
                        

                          
200万优质内容无限畅学

                          
                        

                      
            

        


    



                



	

		

			

				
					
SPFA算法之邻接表实现

				
			

			

				

					Rocking_Bee's Blog
				

				

					08-16
					
					923
					
				

			

		

		

			
				
SPFA（Shortest Path Fast Algorithm）

			
		

	



                

            
              



	

		

			

				
					
邻接表实现 单源最短路径SPFA算法 poj1511

				
			

			

				

					大神养成中.....
				

				

					01-16
					
					7251
					
				

			

		

		

			
				
首先讲邻接表的实现，以前一直遇到题目都是用vector模拟，今天遇到一个题目vector超时，于是学习了用数组模拟实现邻接表，新学的数据结构，搞的不是很透彻，记录一下。
其实就是头插发，首先用一个结构体E记录节点的信息，指向那个节点，以及指向节点的权值等信息，给E结构体设置一个next，让它指向H数组，H数组初始化为-1，初始化为-1是为了方便判断某个点直接相连点是否找完了，自己还不是很透彻了，

			
		

	



              


  
              

                


	

		

			

				
					
SPFA + 静态邻接表 模板

				
			

			

				

					
				

				

					11-14
					
					125
					
				

			

		

		

			
				
　　SPFA — shotest path faster algorithm，是一个效率很高的求最短路径的算法，也可以说是bellman-ford算法的优化版。

 具体做法是先把起点放入一个队列中。每次取出队顶元素，并pop，看跟该点相邻的其他点是否能够松弛，如果可以松弛，改变数值，如果该点不在队列中，则把能该点push到队列中，直到队列为空。
 为了速度更快...

			
		

	





	

		

			

				
					
spfa算法邻接表实现

				
			

			

				

					qq_42140101的博客
				

				

					12-02
					
					264
					
				

			

		

		

			
				
“东信杯”广西大学第一届程序设计竞赛（同步赛）

• 题意：在有向图选取一条路径使得路径中边权乘积最短，其中边
权必定为2的正整数次幂。
• 考虑最短路模型是边权相加，那么我们只需要将乘法转化为加法
也就是将边权对2取对数，再计算最短路得到最短长度ans，最后
我们的答案就是2^ans % (1e9+7)，最后计算幂时会溢出，所以暴
力ans次乘以2，每次都对其取模即可


//题意：
//在有向...

			
		

	



		

			
		



	

		

			

				
					
SPFA队列模板

				
			

			

				

					weixin_30662539的博客
				

				

					05-01
					
					84
					
				

			

		

		

			
				
#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string.h>
#include<string>
#include<queue>

using namespace std;
const int maxn=2010;

struct ...

			
		

	





	

		

			

				
					
spfa (跟be ford比多了模拟邻接表+队列)

				
			

			

				

					m0_57422141的博客
				

				

					04-03
					
					135
					
				

			

		

		

			
				
http://t.csdn.cn/AXRRU


			
		

	





	

		

			

				
					
cpp代码-SPFA模板

				
			

			

				

					07-14
				

			

		

		

			
				
总之，`cpp代码-SPFA模板`是一个用于解决单源最短路径问题的程序，它利用了队列数据结构和松弛操作，适用于可能存在负权边的图。通过理解和应用这个模板，开发者可以解决各种图论问题，尤其是在网络流、路由算法等...

			
		

	





	

		

			

				
					
最短路径—SPFA算法教程（邻接矩阵+链式前向星+邻接表实现）

				
			

			

				

					pursuit的博客
				

				

					07-30
					
					1743
					
				

			

		

		

			
				
最短路径—SPFA算法教程（邻接矩阵+链式前向星+邻接表实现）

			
		

	





	

		

			

				
					
算法队列SPFA算法详解

				
			

			

				

					weixin_34375251的博客
				

				

					05-07
					
					158
					
				

			

		

		

			
				
文章结束给大家来个程序员笑话：[M]
    处理存在负环的图的单源最短路径，bellman-ford算法是比拟经典的一个，但是大家都道知，这个算法的效率其实不咋的，因为它只道知要求单源最短路，至多做|v|（j图的点结数）次松懈作操，觉感有点目盲吧，这里分析一个有西南交通大学段凡丁1994年明发的一个算法即SPFA，很大程度上化优了bellman-ford算法(议建没有学过的，先去解了一下这个算...

			
		

	





	

		

			

				
					
SPFA算法模版+邻接表实现

				
			

			

				

					ZhouRush
				

				

					05-30
					
					821
					
				

			

		

		

			
				
http://hi.baidu.com/jipyjyxfkubhtxq/item/e3ea343dd7767bd06d15e9b0



[Zz]SPFA算法模版+邻接表实现


SPFA即shotest path faster
algorithm，由意思就可以看出该算法效率比较高。

其实SPFA就是bellman-ford算法的一个优化。

具体做法是用一个队列保存待松弛的点，然后对于每个出队

			
		

	





	

		

			

				
					
SPFA模版

				
			

			

				

					
				

				

					07-16
					
					607
					
				

			

		

		

			
				
本文转自http://blog.youkuaiyun.com/candy20094369/article/details/6717282SPFA算法模板1：(邻接矩阵)

const int nMax = 1000;           //  顶点的数量上限。
const int eMax = 2000;           //  边的数量上限。
const int inf = 0xffffff;
 
i

			
		

	





	

		

			

				
					
SPFA算法-邻接表存图

				
			

			

				

					hnjzsyjyj的专栏
				

				

					10-16
					
					420
					
				

			

		

		

			
				
【算法简介】
SPFA 算法是Bellman-Ford算法的队列优化算法的别称，通常用于求含负权边的单源最短路径，以及判负权环。
SPFA算法通过判断图中是否存在一个顶点入队次数超过顶点总数n，来判断图中是否存在负权环。
最短路径算法中普遍使用的松弛操作的原理源自于著名的定理：“三角形两边之和大于第三边”
在数学及信息学中，我们称它为三角不等式。
所谓对结点i，j进行松弛，就是判定是否成立dis[...

			
		

	





	

		

			

				
					
SPFA的邻接表算法<java> 01

				
			

			

				

					weixin_38035852的博客
				

				

					03-23
					
					349
					
				

			

		

		

			
				
本文借鉴http://www.cnblogs.com/liuzhen1995/p/6535025.html 算法原理，想要理解SPFA的原理的话可以先去了解一下，这里提供的是一种基于邻接矩阵的SPFA实现代码，利用java语言。package Dijkstra_有权_spfa;
/*
 *这个邻接矩阵 spfa 
 */
import java.util.LinkedList;
import ja

			
		

	





	

		

			

				
					
【Java模板】SPFA模板

				
			

			

				

					Tizzi的博客
				

				

					07-26
					
					478
					
				

			

		

		

			
				
基于邻接表（链表形式）实现。
import java.util.*;
public class SPFA模板 {
	static int N = 1005;
	static int len; //有向边个数 
	static int[] head = new int[N];
	static edge[] e = new edge[N];
	static int[] dis = new int[N]...

			
		

	





	

		

			

				
					
【最短路】【模板】Bellman-Ford 队列优化/spfa

				
			

			

				

					swqeaaa的博客
				

				

					08-03
					
					266
					
				

			

		

		

			
				

/*Bellman-Ford*/
#include&lt;cstdio&gt;
#include&lt;cstring&gt;
#include&lt;queue&gt;
using namespace std;

const int M=500005;
const int INF=2000000000;
class node
{
public:
    int v,next,w;
} edge...

			
		

	





	

		

			

				
					
SPFA  模板

				
			

			

				

					cjl的博客
				

				

					01-21
					
					428
					
				

			

		

		

			
				
SPFA模板

SPFA 算法是 Bellman-Ford算法 的队列优化算法的别称，通常用于求含负权边的单源最短路径，以及判负权环。
SPFA最坏情况下复杂度和朴素 Bellman-Ford 相同，为 O(VE)。
一般时间复杂度为O(ke)  k是2左右的常数。
spfa具有灵活性强的优点

bfs版
void SPFA()
{
	memset(dis,127,sizeof(dis));
	m...

			
		

	





	

		

			

				
					
spfa模板

				
			

			

				

					qq_73541957的博客
				

				

					09-08
					
					123
					
				

			

		

		

			
				
【代码】spfa模板。

			
		

	





	

		

			

				
					
SPFA算法模板

				
			

			

				

					每一次AC都是一种感动
				

				

					07-27
					
					379
					
				

			

		

		

			
				
int spfa(int s,int t)
{
    int d[maxn];
    int vis[maxn];
    memset(vis,0,sizeof vis);
    queueque;
    que.push(s);
    vis[s]=1;

    for(int i=1; i<=20; i++) d[i]=INF;
    d[s]=0;

    while(qu

			
		

	





	

		

			

				
					
SPFA 算法详解(  强大图解，不会都难！)

					
热门推荐

				
			

			

				

					muxi@Achilles的专栏
				

				

					08-22
					
					4万+
					
				

			

		

		

			
				
适用范围：给定的图存在负权边，这时类似Dijkstra等算法便没有了用武之地，而Bellman-Ford算法的复杂度又过高，SPFA算法便派上用场了。 我们约定有向加权图G不存在负权回路，即最短路径一定存在。当然，我们可以在执行该算法前做一次拓扑排序，以判断是否存在负权回路，但这不是我们讨论的重点。

算法思想：我们用数组d记录每个结点的最短路径估计值，用邻接表来存储图G。我们采取的方法是动态

			
		

	





	

		

			

				
					
帮我写一个spfa算法模板

					
最新发布

				
			

			

				

					09-13
				

			

		

		

			
				
### 回答1：
好的，这是一份 SPFA 算法模板：

```
#include<bits/stdc++.h>
using namespace std;
const int N=1e5+10;
const int M=1e5+10;
const int INF=0x3f3f3f3f;
int head[N],tot,n,m,s,dis[N];
bool vis[N];
struct node{
    int next,to,w;
}e[M];
inline void add(int from,int to,int w){
    e[++tot].to=to;
    e[tot].w=w;
    e[tot].next=head[from];
    head[from]=tot;
}
inline void SPFA(int s){
    queue<int> q;
    memset(dis,0x3f,sizeof dis);
    memset(vis,0,sizeof vis);
    dis[s]=0;
    vis[s]=1;
    q.push(s);
    while(!q.empty()){
        int u=q.front();
        q.pop();
        vis[u]=0;
        for(int i=head[u];i;i=e[i].next){
            int to=e[i].to;
            if(dis[to]>dis[u]+e[i].w){
                dis[to]=dis[u]+e[i].w;
                if(!vis[to]){
                    q.push(to);
                    vis[to]=1;
                }
            }
        }
    }
}
int main(){
    cin>>n>>m>>s;
    for(int i=1;i<=m;i++){
        int from,to,w;
        cin>>from>>to>>w;
        add(from,to,w);
    }
    SPFA(s);
    for(int i=1;i<=n;i++) cout<<dis[i]<<" ";
    return 0;
}
```

请注意，这份代码仅仅是一个模板，需要根据实际需求进行修改。  

### 回答2：
SPFA（Shortest Path Faster Algorithm）是一种用于求解最短路径的算法，下面给出一个SPFA算法的模板：

```python
import queue

# 定义图的节点类
class Node:
    def __init__(self, index):
        self.index = index
        self.next = None
        self.weight = None

# SPFA算法函数
def spfa(start, end, graph):
    # 初始化距离数组和队列
    dist = [float('inf')] * len(graph)
    dist[start] = 0
    q = queue.Queue()
    q.put(start)
  
    # 利用队列进行广度优先搜索
    while not q.empty():
        u = q.get()
        node = graph[u]
        while node:
            v = node.index
            w = node.weight
            # 松弛操作
            if dist[u] + w < dist[v]:
                dist[v] = dist[u] + w
                q.put(v)
            node = node.next

    # 返回最短路径长度
    return dist[end]

# 测试数据
if __name__ == "__main__":
    # 初始化图的邻接表
    graph = [None] * 5
    graph[0] = Node(1)
    graph[0].next = Node(2)
    graph[0].next.next = Node(4)
    graph[0].weight = 2
    graph[0].next.weight = 4
    graph[0].next.next.weight = 1
    graph[1] = Node(2)
    graph[1].next = Node(3)
    graph[1].weight = 6
    graph[1].next.weight = 3
    graph[2] = Node(3)
    graph[2].weight = 2
    graph[4] = Node(3)
    graph[4].weight = 3

    start = 0
    end = 3
    result = spfa(start, end, graph)
    print("最短路径长度：", result)
```

该模板中，首先定义了一个节点类表示图的节点，包含节点索引、指向的下一个节点和边的权重信息。

然后，实现了SPFA算法的函数`spfa`，其中利用队列实现广度优先搜索，对于每个节点，根据当前节点的距离更新相邻节点的距离值。

最后，在主函数中，根据测试数据初始化图的邻接表，并设定起点和终点，最后调用`spfa`函数求解最短路径长度并输出结果。

希望对你有帮助！  

### 回答3：
SPFA算法，即适用于求解单源最短路径的 Bellman-Ford 算法的一种优化算法，全称为 Shortest Path Faster Algorithm。下面是一个SPFA算法的模板：

```python
import collections

def spfa(graph, start):
    # 初始化距离数组和队列
    distance = [float('inf')] * len(graph)
    distance[start] = 0
    queue = collections.deque([start])
    in_queue = [False] * len(graph)
    in_queue[start] = True

    while queue:
        curr_node = queue.popleft()
        in_queue[curr_node] = False

        for neighbor, weight in graph[curr_node]:
            new_distance = distance[curr_node] + weight
            if new_distance < distance[neighbor]:
                distance[neighbor] = new_distance
                if not in_queue[neighbor]:
                    queue.append(neighbor)
                    in_queue[neighbor] = True
    
    return distance
```

其中，`graph`为表示图的邻接表形式，包含了节点及其邻居节点及边的权重信息。`start`表示起始节点的索引。

算法运行开始时，将起始节点加入队列，并设置距离数组中起始节点的距离为0。进入循环，每次从队列中取出一个节点，并更新其连接节点的最短距离。如果发现某个节点的最短距离有更新，则将该节点加入队列中继续扩展，并将其标记为在队列中。

最后，返回得到的各个节点到起始节点的最短距离数组 `distance`。如果某个节点的最短距离为初始时设置的 `float('inf')`，则表示该节点不可到达。

这是一个简单的SPFA算法模板，适用于解决不含负权环的最短路径问题。需要注意的是，如果图中存在负权环，该算法将无法得到正确结果，因为它没有负权环的停止条件。

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		
评论 2

	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值