SPFA求最短路径和最小cost

SPFA

SPFA是一种单源最短路搜索算法，类似于Dijkstra和BFS的小结合，具体可以参考一下相关介绍:

http://www.360doc.com/content/13/1208/22/14357424_335569176.shtml

题目描述

给你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 2
1 2 5 6
2 3 4 5
1 3
0 0

输出例子:
9 11

C++实现

由于数据结构采用了邻接表，因此，对于两点间存在复边的图，该代码无法计算

//
//  main.cpp
//  250
//
//  Created by Wen Yang on 2017/3/24.
//  Copyright © 2017年 Wen Yang. All rights reserved.
//

#include <iostream>
#include <vector>
#include <queue>

using namespace std;

vector< vector<int> > adjst;//存储两点间的距离
vector< vector<int> > costAdj;//存储两点间的花费
vector<int> pre;
vector<int> dist;
vector<int> cost;

queue<int> q;

void SPFA(int& minLength, int& minCost, const int& src, const int& des){

    //初始化
    dist[src] = 0;//源点的距离为0
    cost[src] = 0;//cost也为0


    q.push(src);
    while(!q.empty()){
        int curNode = q.front();
        q.pop();
        //遍历当前点的所有邻接顶点
        for(int i=0; i<adjst.size(); ++i){
            if(adjst[curNode][i] > 0){
                //如果源点到下个i点的距离，比当前点到i点的距离要远，则替换掉原来的距离
                if(dist[i]>dist[curNode]+adjst[curNode][i]){
                    dist[i] = dist[curNode]+adjst[curNode][i];
                    pre[i] = curNode;
                    cost[i] = cost[curNode] + costAdj[curNode][i];
                    q.push(i); //把距离减少的点加入到队列中
                }
                //如果源点到下个i点的距离，等于当前点到i点的距离，则比较两者的cost，若cost更小，则替换
                else if(dist[i]==dist[curNode]+adjst[curNode][i]){
                    if(cost[i] > cost[curNode] + costAdj[curNode][i]){
                        cost[i] = cost[curNode] + costAdj[curNode][i];
                        pre[i] = curNode;
                        q.push(i);//把花费减少的点加入到队列中
                    }
                }
            }
        }
    }
    minLength = dist[des];
    minCost = cost[des];

}

int main(int argc, const char * argv[]) {

    int n, m;
    cin>>n>>m;
    adjst = vector< vector<int> >(n, vector<int>(n, 0)); // 初始化邻接矩阵
    costAdj = vector< vector<int> >(n, vector<int>(n, 0));  //初始化邻接Cost矩阵
    pre = vector<int>(n,0);
    dist = vector<int>(n,999999);
    cost = vector<int>(n,999999);


    int from, to, length, cost;
    for(int i=0; i<m; ++i){
        cin>>from>>to>>length>>cost;
        //统一下标减一，与数组下标保持一致
        adjst[from-1][to-1] = length;
        costAdj[from-1][to-1] = cost;
    }

    int src, des;//源点，汇点
    cin>>src>>des;


    int minCost=0, minLength=0;
    SPFA(minLength, minCost, src-1, des-1);
    cout<<minLength<<" "<<minCost<<endl;

    return 0;
}