spfa_队列

转自：http://www.cnblogs.com/pushing-my-way/archive/2012/08/05/2624271.html

spfa:
1.当给定的图存在负权边时，Dijkstra等算法便没有了用武之地，而Bellman-Ford算法的复杂度又过高，SPFA算法便派上用场了.
2.我们约定有向加权图G不存在负权回路，即最短路径一定存在
3.思路：
用数组d记录每个结点的最短路径估计值，而且用邻接表来存储图G。我们采取的方法是动态逼近法：设立一个先进先出的队列用来保存待优化的结点，优化时每次取出队首结点u，并且用u点当前的最短路径估计值对离开u点所指向的结点v进行松弛操作，如果v点的最短路径估计值有所调整，且v点不在当前的队列中，就将v点放入队尾。这样不断从队列中取出结点来进行松弛操作，直至队列空为止。
4.实现方法：
建立一个队列，初始时队列里只有起始点，在建立一个表格记录起始点到所有点的最短路径（该表格的初始值要赋为极大值，该点到他本身的路径赋为0）。然后执行松弛操作，用队列里有的点去刷新起始点到所有点的最短路，如果刷新成功且被刷新点不在队列中则把该点加入到队列最后。重复执行直到队列为空.
代码：

View Code 
 #include <iostream>
 #include <memory.h>
 #include <stdio.h>
 #include <queue>
 using namespace std;
 const int maxp=1000;
 const int maxe=1000;
 const int maxnum=1000;
 struct edge
 {
     int v;
     int w;
     int next;
 }edge[maxe];
 
 typedef struct
 {
     int d;
     int pre;
 }pp;
 pp point[maxp];
 int p,e;
 
 queue<int> q;
 bool use[maxp];
 
 void Init()
 {
     int i;
     for(i=1;i<=p;i++)
     {
         point[i].d=maxnum;
         point[i].pre=-1;
     }
     int u,v,w;
     int index=1;
     for(i=1;i<=e;i++)
     {
         cin>>u>>v>>w;
         edge[index].v=v;
         edge[index].w=w;
         edge[index].next=point[u].pre;
         point[u].pre=index;
         index++;
     }
 }
 
 void spfa(int s)
 {
     memset(use,false,sizeof(use));
     point[s].d=0;
     q.push(s);
     use[s]=true;
     int t,i;
     while(!q.empty())
     {
         t=q.front();
         use[t]=false;
         q.pop();
         for(i=point[t].pre;i!=-1;i=edge[i].next)
         {
             int v=edge[i].v;
             int w=edge[i].w;
             if(point[v].d>point[t].d+w)
             {
                 point[v].d=point[t].d+w;
                 if(!use[v])
                 {
                     q.push(v);
                     use[v]=true;
                 }
             }
         }
     }
 }
 
 int main()
 {
     cin>>p>>e;
     Init();
     spfa(1);
     int i;
     for(i=1;i<=p;i++)
         cout<<i<<" "<<point[i].d<<endl;
     return 0;
 }
 
 /*
 5 10
 1 2 10
 1 3 5
 2 3 2
 2 4 1
 3 2 3
 3 4 9
 3 5 2
 4 5 4
 5 1 7
 5 4 6
 */