SPFA最短路

B-F 

适用条件&范围

1. 单源最短路径(从源点s到其它所有顶点v);
2. 有向图&无向图(无向图可以看作(u,v),(v,u)同属于边集E的有向图);
3. 边权可正可负(如有负权回路输出错误提示);
4. 差分约束系统;

算法描述

1. 对每条边进行|V|-1次Relax ( 就是松弛操作 )操作;
2. 如果存在(u,v)∈E使得dis[u]+w<dis[v],则存在负权回路;否则dis[v]即为s到v的最短距离,pre[v]为前驱。

For i:=1 to |V|-1 do //v为顶点数
For 每条边(u,v)∈E do  //对每条边进行遍历
  Relax(u,v,w);
For每条边(u,v)∈E do
  If dis[u]+w<dis[v] Then Exit(False)

时空复杂度

算法时间复杂度O(VE)。因为算法简单，适用范围又广，虽然复杂度稍高，仍不失为一个很实用的算法。

 

算法的改进---> SPFA 复杂度O(KE)，k ≈ 2

 

算法简介

SPFA(Shortest Path Faster Algorithm)是Bellman-Ford算法的一种队列实现，减少了不必要的冗余计算。也有人说SPFA本来就是Bellman-Ford算法，现在广为流传的Bellman-Ford算法实际上是山寨版。

算法流程

算法大致流程是用一个队列来进行维护。 初始时将源加入队列。 每次从队列中取出一个元素，并对所有与他相邻的点进行松弛（见下文最后），若某个相邻的点松弛成功，则将其入队。 直到队列为空时算法结束。

这个算法，简单的说就是队列优化的bellman-ford,利用了每个点不会更新次数太多的特点发明的此算法

SPFA——Shortest Path Faster Algorithm，它可以在O(kE)的时间复杂度内求出源点到其他所有点的最短路径，可以处理负边。SPFA的实现甚至比Dijkstra或者Bellman_Ford还要简单：

设Dist代表S到I点的当前最短距离，Fa代表S到I的当前最短路径中I点之前的一个点的编号。开始时Dist全部为+∞，只有Dist[S]=0，Fa全部为0。

维护一个队列，里面存放所有需要进行迭代的点。初始时队列中只有一个点S。用一个布尔数组记录每个点是否处在队列中。

每次迭代，取出队头的点v，依次枚举从v出发的边v->u，设边的长度为len，判断Dist[v]+len是否小于Dist[u]，若小于则改进Dist[u]，将Fa[u]记为v，并且由于S到u的最短距离变小了，有可能u可以改进其它的点，所以若u不在队列中，就将它放入队尾。这样一直迭代下去直到队列变空，也就是S到所有的最短距离都确定下来，结束算法。若一个点入队次数>=n，则有负权环。

SPFA 在形式上和宽度优先搜索非常类似，不同的是宽度优先搜索中一个点出了队列就不可能重新进入队列，但是SPFA中一个点可能在出队列之后再次被放入队列，也就是一个点改进过其它的点之后，过了一段时间可能本身被改进，于是再次用来改进其它的点，这样反复迭代下去。设一个点用来作为迭代点对其它点进行改进的平均次数为k，有办法证明对于通常的情况，k在2左右

---

 

数组实现邻接表模板

#define N 100004
const int INF = (1<<30);
int n,m;//n是最后一个点的编号
struct edge{
    int u,v,w;
    int next;//同一起点的下一条边存储在edge数组中的位置（理解了这个静态邻接表就可以了）
}e[N*10];
int head[N];//以该点为起点的第一条边存储在e数组中的位置
int dis[N];//记录与源点距离
bool vis[N];//记录顶点是否在队列中，SPFA算法可以入队列多次
int cnt[N];//记录顶点入队列次数
int ecnt;
void init(){
    ecnt = 0;
    memset(head,-1,sizeof(head));
}
void add(int u,int v,int w){
    e[ecnt].u = u;
    e[ecnt].v = v;
    e[ecnt].w = w;
    e[ecnt].next = head[u];
    head[u] = ecnt++;//位置更新
}
bool SPFA(int s){//s是源点编号
    queue<int>  qq;
    int i;
    for(i=1;i<=n;++i){
        dis[i] = INF;        //将除源点以外的其余点的距离设置为无穷大
        vis[i] = 0;
        cnt[i] = 0;
    }
    dis[s]=0;              //源点的距离为0
    vis[s] = 1;
    cnt[s]++;            //源点的入队列次数增加
    qq.push(s);
    int u,v;
    while(!qq.empty()){
        u = qq.front();
        qq.pop();
        vis[u] = 0;
        for(i=head[u];i!=-1;i = e[i].next){
            v = e[i].v;
            int cost = e[i].w;
            if(dis[v] > cost+dis[u]){
                dis[v] = cost+dis[u];
                if(!vis[v]){
                    vis[v] = 1;
                    qq.push(v);
                    cnt[v]++;
                    if(cnt[v] >= n)return false;
                }
            }
        }
    }
    return true;
}

vector实现邻接表模板

#define N 50001 
const int INF = 0x7fffffff;
int n,m;
typedef struct edge
{   
    int to;   
    int w;
}edge,temp;
vector<edge> adjmap[N]; //vector实现邻接表
int d[N];
bool vis[N];          //记录顶点是否在队列中，SPFA算法可以入队列多次
int cnt[N];             //记录顶点入队列次数
void SPFA()
{     
    queue<int> 
    myqueue;     
    int i;     
    for(i=2;i<=n;++i)            
        d[i] = INF;        //将除源点以外的其余点的距离设置为无穷大     
    memset(vis,0,sizeof(vis));     
    memset(cnt,0,sizeof(cnt));     
    d[1]=0;              //源点的距离为0     
    vis[1] = true;     
    cnt[1]++;            //源点的入队列次数增加     
    myqueue.push(1);     
    int topint;     
    while(!myqueue.empty())     
    {         
        topint = myqueue.front();         
        myqueue.pop();         
        vis[topint] = false;         
        for(i=0;i<adjmap[topint].size();++i)         
        {             
            int to = adjmap[topint][i].to;             
            if(d[topint]<INF && d[to]>d[topint]+ adjmap[topint][i].w)             
            {                  
                d[to] = d[topint]+ adjmap[topint][i].w;                  
                if(!vis[to])                  
                {                      
                    vis[to] = true;                      
                    cnt[to]++;                      
                    if(cnt[to]>=n)   //当一个点入队的次数>=n时就证明出现了负环。                        
                    return ;                      
                    myqueue.push(to);                  
                }         
            }     
         }             
      } printf("%d/n",d[n]);

}
int main()
{    
    freopen("a.txt","r",stdin);    
    scanf("%d%d",&n,&m);    
    int i;    
    int s,e,w;    
    edge temp;    
    for(i=1;i<n+1;++i)       //此处特别注意对邻接表清空        
    adjmap[i].clear();    
    for(i=0;i<m;++i)         //双向    
    {        
        cin>>s>>e>>w;        
        temp.to = e;        
        temp.w = w;        
        adjmap[s].push_back(temp);        
        temp.to = s;        
        adjmap[e].push_back(temp);   
     }    
     SPFA();    
     return 0;
}

数组版

int map[N][N],dist[N],vis[N];
void SPFA(int s){
    int i,j;
    for(i=0;i<=n;i++){
        dist[i] = maxsum;
        vis[i] = 0;
    }
    queue<int> q;
    dist[s]=0;
    q.push(s);
    vis[s]=1;
    while(!q.empty()){
        int x=q.front();
        q.pop();
        vis[x]=0;
        for(i=1;i<=n;i++){
            if(map[x][i] != INF && dist[x]+map[x][i]<dist[i]){
                dist[i]=dist[x]+map[x][i];
                if(!vis[i]){
                    vis[i]=1;
                    q.push(i);
                }
            }
        }
    }
}

如果要记录最短路径的话就需要开多一个数组pre[i]，当且仅当dis[i]+map[i][j]<dis[j]时更新pre[j] = i