SPFA 算法总结

回顾一下使用邻接表的 SPFA 的算法

 

如上图所示：

假设原点是 1 ，也就是说 1 在队列中

将与 1 节点连接的节点放入队列中

此时更新 d[2]=3 , d[3]=9 , d[4]=7 , d[5]=3

将以上节点放入队列中

---

此时队列里有 2，3，4，5 节点

然后 2 出队，发现与 2 连接的有 3 号节点，更新 d[3]=5, 但是 3 节点在队列中，所以不再进行操作

---

 之后 3 号节点出队，与 3 号节点连接的只有 4 号节点，但此时 d[4]=7<9+4，选择不跟新

---

 4 号节点出队，与谁都不连接，过

---

最后是 5 号节点，与 4 号节点连接，更新 d[4]=5, 4 号节点再次入队，结束

---

 

更具上述过程，我们需要几个数组进行维护：

head[i]：存储前驱节点，个人理解为以 i 为起点的向后延伸的边的最大标号

cnt[i]：存储 i 节点入队的次数  //上述过程没有提到，判断负环使用

d[i]：原点 s 到 i 点的最短距离

vis[i]：i 是否在队列中

struct edge
{
    int to;      //边的终点
    int next;    //上一条边的标号
    int w;       //边权
}E[N];

SPFA 的过程类似于 BFS

主要在于建立邻接表。

int cnt=0;//num_egde
void add(int u,int v,int w)//建立一条边起点为 u ，终点为 v ，边权为 w
{
    E[cnt].to=v;
    E[cnt].w=w;
    E[cnt].next=head[u];
    head[u]=cnt++;
}

比如说有：1 -> 3  ,  1 -> 4  ,  1 -> 2  三条有向边

再插入边的过程中:

E[0].next=head[1]=-1;

head[1]=cnt=0;

cnt=1;

---

E[1].next=head[1]=0;

head[1]=cnt=1;

cnt=2;

---

E[2].next=head[1]=1;

head[1]=cnt=2

cnt=3

根据上图模拟，首先节点 1 进入队列

然后将 3，4，2 依次放入队列

定义 u=1 

for(i=head[u];i!=-1;i=E[i].next)

{

       v=E[i].to;

       push(v);  // 队列操作

}

SPFA 的全过程： 

void SPFA(int s)
{
    for(int i=0;i<N;i++) vis[i]=0,d[i]=inf;
    d[s]=0; vis[s]=1;
    queue<int> q;
    q.push(s);

    while(!q.empty()){
        int u=q.front();
        q.pop();
        vis[u]=0;
        for(int i=head[u];i!=-1;i=G[i].next){
            int v=E[i].to;
            int w=E[i].w;
            if(d[v]>d[u]+w){
                d[v]=d[u]+w;
                if(!vis[v]){
                    vis[v]=1;
                    q.push(v);
                }
            }
        }
    }

}