最短路—SPFA

求单源最短路的SPFA算法的全称是：Shortest Path Faster Algorithm。

SPFA算法是西南交通大学段凡丁于1994年发表的.

很多时候，给定的图存在负权边，这时类似Dijkstra等算法便没有了用武之地，而Bellman-Ford算法的复杂度又过高，SPFA算法便派上用场了。

    我们用数组d记录每个结点的最短路径估计值，而且用邻接表来存储图G。

我们采取的方法是动态逼近法：设立一个先进先出的队列用来保存待优化的结点，优化时每次取出队首结点u，并且用u点当前的最短路径估计值对离开u点所指向的结点v进行松弛操作，如果v点的最短路径估计值有所调整，且v点不在当前的队列中，就将v点放入队尾。

这样不断从队列中取出结点来进行松弛操作，直至队列空为止。

　　 定理: 只要最短路径存在，上述SPFA算法必定能求出最小值。

    期望的时间复杂度O(ke)， 其中k为所有顶点进队的平均次数，可以证明k一般小于等于2。 

    实现方法：建立一个队列，初始时队列里只有起始点，再建立一个表格记录起始点到所有点的最短路径（该表格的初始值要赋为极大值，该点到他本身的路径赋为0）。然后执行松弛操作，用队列里有的点去刷新起始点到所有点的最短路，如果刷新成功且被刷新点不在队列中则把该点加入到队列最后。

重复执行直到队列为空

判断有无负环：如果某个点进入队列的次数超过N次则存在负环（SPFA无法处理带负环的图）

模版：

 

 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstring>
 4 using namespace std;
 5 typedef struct node
 6 {
 7     long adj,data;/*adj为邻接点，data为边的权值*/
 8     struct node *next;
 9 }node;
10 node *g[1000];
11 long dis[1000],flag[1000],q[1000],n,e;/*dis记录最短路径值，flag做出入队标记，q为队列*/
12 void spfa(long st)
13 {
14     long i,k,front,rear;
15     node *p;
16     for(i=0;i<n;i++) 
17         dis[i]=0x7fffffff;/*初始化路径为长整型最大数*/
18     memset(flag,0,sizeof(flag));/*入队标记初始化为0*/
19     front=0;
20     rear=1;
21     /*将起始点入队*/
22     dis[st]=0;/*到自己距离为0*/
23     q[rear]=st;/*入队*/ 
24     flag[st]=1;/*置入队标记*/
25     while(front!=rear)/*当队列不为空时*/
26     {     
27         front=(front+1)%1000;/*出队，注意使用循环队列*/
28         k=q[front];/*记下出队点号*/
29         flag[k]=0;/*置出队标记*/
30         p=g[k];/*找到以出队点为头的邻接链表，考察由出队点中转至各邻接点路径是否更短*/
31         while(p)
32         {
33             if(dis[k]+p->data<dis[p->adj])
34             { 
35                 dis[p->adj]=dis[k]+p->data;/*路径更短，更新路径值*/
36                 if(!flag[p->adj])/*若其邻接点未入队*/
37                 { 
38                     rear=(rear+1)%1000;/*入队*/
39                     q[rear]=p->adj;
40                     flag[p->adj]=1;/*置入队标记*/
41                 }
42             }
43             p=p->next;/*记得改变循环变量，考察下一个邻接点*/
44         }
45     }  
46 }
47 int main()
48 {
49     long i,x,y,z;
50     node *p;
51     scanf("%ld%ld",&n,&e);/*读入点数，边数*/
52     memset(g,0,sizeof(g));/*初始化图*/
53     for(i=1;i<=e;i++)/*读入边的信息，左点、右点、权值*/
54     {
55         scanf("%ld%ld%ld",&x,&y,&z);
56         p=(node*)malloc(sizeof(node));/*创建链表*/
57         p->data=z;
58         p->adj=y;
59         p->next=g[x];/*尾插法*/
60         g[x]=p;
61     }
62     spfa(0);/*计算由起始点到各点的最短路径*/
63     for(i=0;i<n;i++)
64         printf("%ld ",dis[i]);
65     printf("\n");
66     return 0;
67 }

 

POJ 3259

 

  1 #include <iostream>
  2 #include <cstring>
  3 #include <cstdlib>
  4 #include <cstdio>
  5 #include <queue>
  6 using namespace std;
  7 
  8 const int N=501;
  9 const int NN=100001;
 10 const int inf=0x7fffffff;
 11 queue<int> qu;
 12 int n,nu;
 13 
 14 typedef struct node
 15 {
 16     int adj,val;
 17     struct node *next;
 18 }node;
 19 node node[NN],*p[N];
 20 
 21 int SPFA()
 22 {
 23     int x,i,a,b;
 24     int vis[N],dis[N],num[N];
 25     struct node *head[N];
 26     for(i=1;i<=n;i++)
 27     {
 28         vis[i]=0;
 29         num[i]=0;
 30         dis[i]=inf;
 31         head[i]=p[i];
 32     }
 33     dis[1]=0;
 34     vis[1]=1; 
 35     num[1]++;
 36     qu.push(1);
 37     while(!qu.empty())
 38     {
 39         x=qu.front();
 40         qu.pop();
 41         vis[x]=0;
 42         head[x]=p[x];
 43         while(head[x])
 44         {
 45             a=head[x]->adj;
 46             b=head[x]->val;
 47             if(dis[a]>dis[x]+b)
 48             {
 49                 dis[a]=dis[x]+b;
 50                 if(!vis[a])
 51                 {
 52                     qu.push(a);
 53                     vis[a]=1;
 54                     num[a]++;
 55                     if(num[a]>=n)//如果入队的次数超过总数，说明存在回路 
 56                         return 1;
 57                 }
 58             }
 59             head[x]=head[x]->next; 
 60         }
 61     }
 62     return 0;
 63 }
 64 
 65 int main()
 66 {
 67     int t,i,m,w,a,b,c;
 68     scanf("%d",&t);
 69     while(t--)
 70     {
 71         while(!qu.empty()) 
 72             qu.pop();
 73         memset(node,0,sizeof(node));
 74         memset(p,0,sizeof(p));
 75         nu=0;
 76         scanf("%d%d%d",&n,&m,&w);
 77         for(i=0;i<m;i++)
 78         {
 79             scanf("%d%d%d",&a,&b,&c);
 80             node[nu].adj=b;  
 81             node[nu].val=c;
 82             node[nu].next=p[a];  
 83             p[a]=&node[nu];  
 84             nu++;  
 85             node[nu].adj=a;  
 86             node[nu].val=c;  
 87             node[nu].next=p[b];  
 88             p[b]=&node[nu];  
 89             nu++; 
 90         }
 91         for(i=0;i<w;i++)
 92         {
 93             scanf("%d%d%d",&a,&b,&c);
 94             node[nu].adj=b;  
 95             node[nu].val=-c;
 96             node[nu].next=p[a];
 97             p[a]=&node[nu];  
 98             nu++;  
 99         }
100         if(SPFA()) 
101             puts("YES");
102         else 
103             puts("NO");
104     }
105     return 0;
106 }