SPFA算法求最短路径

题目描述：

给你n个点，m条无向边，每条边都有长度d和花费p，给你起点s终点t，要求输出起点到终点的最短距离及其花费，如果最短距离有多条路线，则输出花费最少的。

输入：

输入n,m，点的编号是1~n,然后是m行，每行4个数 a,b,d,p，表示a和b之间有一条边，且其长度为d，花费为p。最后一行是两个数 s,t;起点s，终点t。n和m为0时输入结束。
(1<n<=1000, 0<m<100000, s != t)

输出：

输出 一行有两个数， 最短距离及其花费。

样例输入：

3 21 2 5 62 3 4 51 30 0

SPFA算法：

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

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

从名字我们就可以看出，这种算法在效率上一定有过人之处。

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

简洁起见，我们约定有向加权图G不存在负权回路，即最短路径一定存在。当然，我们可以在执行该算法前做一次拓扑排序，以判断是否存在负权回路，但这不是我们讨论的重点。

我们用数组d记录每个结点的最短路径估计值，而且用邻接表来存储图G。我们采取的方法是动态逼近法：设立一个先进先出的队列用来保存待优化的结点，优化时每次取出队首结点u，并且用u点当前的最短路径估计值对离开u点所指向的结点v进行松弛操作，如果v点的最短路径估计值有所调整，且v点不在当前的队列中，就将v点放入队尾。这样不断从队列中取出结点来进行松弛操作，直至队列空为止。

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

证明：每次将点放入队尾，都是经过松弛操作达到的。换言之，每次的优化将会有某个点v的最短路径估计值d[v]变小。所以算法的执行会使d越来越小。由于我们假定图中不存在负权回路，所以每个结点都有最短路径值。因此，算法不会无限执行下去，随着d值的逐渐变小，直到到达最短路径值时，算法结束，这时的最短路径估计值就是对应结点的最短路径值。（证毕）

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

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

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

（“算法编程后实际运算情况表明m一般没有超过2n.事实上顶点入队次数m是一个不容易事先分析出来的数,但它确是一个随图的不同而略有不同的常数.所谓常数,就是与e无关,与n也无关,仅与边的权值分布有关.一旦图确定,权值确定,原点确定,m就是一个确定的常数.所以SPFA算法复杂度为O(e)(证毕）[1]”——SPFA的论文

事实上这个证明是非常不严谨甚至错误的，事实上在bellman算法的论文中已有这方面的内容，所以国际上一般不承认SPFA算法）（摘自百度百科）

AC代码：

#include<cstdio>#include<vector>#include<queue>#define MAX 1010#define INF 0x0FFFFFFFusing namespace std;typedef struct Node{int adjvertex;int len;int cost;}Node;int visited[MAX];int distances[MAX];int costs[MAX];vector<Node> map[MAX];void SPFA(int start,int n){int i,j;queue<int> q;q.push(start);for(i=1;i<=n;i++){distances[i]=costs[i]=INF;visited[i]=0;}distances[start]=costs[start]=0;while(!q.empty()){int index;index=q.front();q.pop();visited[index]=1;for(i=0;i<map[index].size();i++){int t=map[index][i].adjvertex;int dis=map[index][i].len;int cost=map[index][i].cost;if(distances[t]==INF||distances[t]>distances[index]+dis){distances[t]=distances[index]+dis;costs[t]=costs[index]+cost;if(!visited[t]){q.push(t);visited[t]=1;//剪枝作用}}else if(distances[t]==distances[index]+dis){if(costs[t]>costs[index]+cost){costs[t]=costs[index]+cost;if(!visited[t]){q.push(t);visited[t]=1;}}}}}}int main(int argc,char *argv[]){int i,n,m;int start,end;while(scanf("%d%d",&n,&m)&&n&&m){for(i=0;i<MAX;i++)map[i].clear();for(i=0;i<m;i++){Node p,q;int index;scanf("%d",&index);        scanf("%d%d%d",&(p.adjvertex),&(p.len),&(p.cost));        map[index].push_back(p);        q.adjvertex=index;        q.len=p.len;        q.cost=p.cost;        map[p.adjvertex].push_back(q);    }    scanf("%d%d",&start,&end);    SPFA(start,n);    printf("%d %d\n",distances[end],costs[end]);}return 0;}

Dijkstra算法也可以解决：

#include<cstdio>#include<vector>#define MAX 1010#define INF 0x0FFFFFFFusing namespace std;typedef struct Node{int adjvertex;int len;int cost;}Node;int visited[MAX];int distances[MAX];int costs[MAX];vector<Node> map[MAX];void Dijkstra(int start,int n){int i,j,k,t;int dis,cost;int min=INF,t_cost;for(i=1;i<=n;i++){distances[i]=INF;costs[i]=0;visited[i]=0;}for(i=0;i<map[start].size();i++){int index;index=map[start][i].adjvertex;distances[index]=map[start][i].len;costs[index]=map[start][i].cost;}distances[start]=0;visited[start]=1;for(i=1;i<n;i++){min=INF;for(j=1;j<=n;j++){if(!visited[j]&&distances[j]<min){k=j;min=distances[j];t_cost=costs[j];}}visited[k]=1;for(j=1;j<=n;j++){for(t=0;t<map[k].size();t++){if(map[k][t].adjvertex!=j)continue;elsebreak;}if(t!=map[k].size()){dis=map[k][t].len;cost=map[k][t].cost;}else{dis=INF;cost=INF;}if(!visited[j]&&distances[j]>dis+min){distances[j]=dis+min;costs[j]=t_cost+cost;}else if(!visited[j]&&distances[j]==dis+min&&costs[j]>cost+t_cost){distances[j]=dis+min;costs[j]=t_cost+cost;}}}}int main(int argc,char *argv[]){int i,n,m;int start,end;while(scanf("%d%d",&n,&m)&&n&&m){for(i=0;i<MAX;i++)map[i].clear();for(i=0;i<m;i++){Node p,q;int index;scanf("%d",&index);        scanf("%d%d%d",&(p.adjvertex),&(p.len),&(p.cost));        map[index].push_back(p);        q.adjvertex=index;        q.len=p.len;        q.cost=p.cost;        map[p.adjvertex].push_back(q);    }    scanf("%d%d",&start,&end);    Dijkstra(start,n);    printf("%d %d\n",distances[end],costs[end]);}return 0;}

用二维数组解决Dijkstra问题会比较方便，用STL使程序看起来略显繁琐，算了，不想再优化了，就这样吧。。。