spfa

program：#include<cstdio>using namespace std;struct node{int x; int value; int next;};node e[60000];int visited[1505],dis[1505],st[1505],queue[1000];int main(){  int n,m,u,v,w,start,h,r,cur;  freopen("c.in","r",stdin);  freopen("c.out","w",stdout);  while(scanf("%d%d",&n,&m)!=EOF)  {    for(int i=1;i<=1500;i++)      {visited[i]=0;       dis[i]=-1;       st[i]=-1;  //这个初始化给下边那个while循环带来影响      }    for(int i=1;i<=m;i++)      {       scanf("%d%d%d\n",&u,&v,&w);           e[i].x=v;            //记录后继节点    相当于链表中的创建一个节点，并使得数据域先记录       e[i].value=w;       e[i].next=st[u];     //记录顶点节点的某一个边表节点的下标，相当于在链表中吧该边表节点的next指针先指向他的后继边表节点       st[u]=i;                //把该顶点的指针指向边表节点，相当于链表中的插入中，头结点的指针改变      }    start=1;    visited[start]=1;    dis[start]=0;    h=0;    r=1;    queue[r]=start;    while(h!=r)     {      h=(h+1)%1000;      cur=queue[h];      int tmp=st[cur];      visited[cur]=0;         while(tmp!=-1)        {            if (dis[e[tmp].x]>dis[cur]+e[tmp].value)                      {                   dis[e[tmp].x]=dis[cur]+e[tmp].value;                    if(visited[e[tmp].x]==0)                      {                           visited[e[tmp].x]=1;                           r=(r+1)%1000;                            queue[r]=e[tmp].x;                       }            }         tmp=e[tmp].next;             }     }    printf("%d\n",dis[n]);  }  return 0;  }

1. SPFA(Shortest Path Faster Algorithm) [图的存储方式为邻接表]
2. 是Bellman-Ford算法的一种队列实现，减少了不必要的冗余计算。
3. 算法大致流程是用一个队列来进行维护。 初始时将源加入队列。 每次从队列中取出一个元素，
4. 并对所有与他相邻的点进行松弛，若某个相邻的点松弛成功，则将其入队。 直到队列为空时算法结束。
5. 它可以在O(kE)的时间复杂度内求出源点到其他所有点的最短路径，可以处理负边。
6. 
   
7. SPFA 在形式上和BFS非常类似，不同的是BFS中一个点出了队列就不可能重新进入队列，但是SPFA中
8. 一个点可能在出队列之后再次被放入队列，也就是一个点改进过其它的点之后，过了一段时间可能本
9. 身被改进，于是再次用来改进其它的点，这样反复迭代下去。
10. 
    
11. 判断有无负环：如果某个点进入队列的次数超过V次则存在负环（SPFA无法处理带负环的图）。
12. 
    
13. SPFA算法有两个优化算法 SLF 和 LLL：
14. SLF：Small Label First 策略，设要加入的节点是j，队首元素为i，若dist(j)<dist(i)，则将j插入队首，
15. 否则插入队尾。
16. LLL：Large Label Last 策略，设队首元素为i，队列中所有dist值的平均值为x，若dist(i)>x则将i插入
17. 到队尾，查找下一元素，直到找到某一i使得dist(i)<=x，则将i出对进行松弛操作。
18. 引用网上资料，SLF 可使速度提高 15 ~ 20%；SLF + LLL 可提高约 50%。
19. 在实际的应用中SPFA的算法时间效率不是很稳定，为了避免最坏情况的出现，通常使用效率更加稳定的Dijkstra算法。
20. */ 
21.  
22. //用数组实现邻接表存储，pnt[i,0]表示与i相邻的结点个数，pnt[i,1...k]存储与i相邻的点
    

int  pnt[MAXN][MAXN]; int  map[MAXN][MAXN]; //map[i,j]为初始输入的i到j的距离，并且map[i,i]=0;未知的map[i,j]=INF; int  dis[MAXN]; char vst[MAXN];  int SPFA(int n,int s) {     int i, pri, end, p, t;     memset(vst, 0, sizeof(vst));     for (i=1; i<=n; i++)         dis[i] = INF;     dis[s] = 0;     vst[s] = 1;     Q[0] = s; pri = 0; end = 1;     while (pri < end)     {         p = Q[pri];         for (i=1; i<=pnt[p][0]; i++)         {             t = pnt[p][i];             //先释放，释放成功后再判断是否要加入队列             if (dis[p]+map[p][t] < dis[t])             {                 dis[t] = dis[p]+map[p][t];                 if (!vst[t])                 {                     Q[end++] = t;                     vst[t] = 1;                 }             }         }         vst[p] = 0;         pri++;     }     return 1; }