PAT_A_1030. Travel Plan (30)—迪杰斯特拉求解最短路径

求多条最短路径中花费最少的一条、

 

<span style="color:#006600;">#include <iostream>
#include <cstdio>
#include <vector>
#include <stack>
using namespace std;

const int MAXN = 510;
const int MAX = 1000000;

int Cost[MAXN][MAXN];
int map[MAXN][MAXN];
int Dis[MAXN];
int final[MAXN];
vector<int> way_p;

stack< vector<int> > shortest_way; //保存其中一条最短路径
stack< vector<int> > final_result_way;//保存所有最短路径

int N,M,S,D;


void mul_short(int sce,int des) {
    vector<int> way1;
    way1.push_back(des);//将终点加入最短路径

    shortest_way.push(way1);
    int cur_v;

    while (!shortest_way.empty()) {//开始求解所有最短路径的循环 从终点开始往回探索

        vector<int> way2 = shortest_way.top();
        shortest_way.pop();
        cur_v = way2[way2.size()-1];
        if (cur_v == sce) {//若已走到起点
            //保存所求解到的最短路径
            final_result_way.push(way2);
        }
        else {
            //否则 考察每一个和cur_V相关联的点
            for (int i = 0; i < N; i++) {
                //若该点到起点的最短路径值加上该点到cur_v最短路径值等于cur_v到起点的最短路径值
                if (map[i][cur_v] < MAX && Dis[i]+map[i][cur_v] == Dis[cur_v]) {
                    //则将点i加入最短路径集合
                    vector<int> way3 = way2;
                    way3.push_back(i);
                    //目前所求到的不完整最短路径集合入栈保存
                    shortest_way.push(way3);
                }
            }
        }
    }
}


void DIJ(int s,int d) {//求最短路径
     Dis[s] = 0;
     for (int i = 0; i < N; i++) {
          int cur_v,min = MAX;
          for (int j = 0; j < N; j++) {
               if (!final[j] && Dis[j] < min) {
                    cur_v = j;
                    min = Dis[j];
               }
          }
          final[cur_v] = 1;
          for (int k = 0; k < N; k++) {
               if (!final[k] && Dis[cur_v] + map[cur_v][k] < Dis[k]) {
                    Dis[k] = Dis[cur_v] + map[cur_v][k];
                    if (k == d) way_p.push_back(cur_v);
               }
          }
     }
     way_p.push_back(d);
}

int main() {
    cin >> N >> M >> S >> D;

    for (int i = 0; i < N; i++) {
          final[i] = 0;
          Dis[i] = MAX;
          for (int j = 0; j < N; j++)
               map[i][j] = MAX;
    }

    for (int i = 0; i < M; i++) {
          int a,b,c,d;
          scanf("%d%d%d%d",&a,&b,&c,&d);
          map[a][b] = c; map[b][a] = c;
          Cost[a][b] = d; Cost[b][a] = d;
    }
    DIJ(S,D);
    int ans = MAX;

    mul_short(S,D);

    while (!final_result_way.empty()) {//求花费最少的一套路径
          int sum = 0;
          vector<int> temp = final_result_way.top();
          final_result_way.pop();
          for (int i = 0; i < temp.size()-1; i++) {
               int a = temp[i],b = temp[i+1];
               sum += Cost[a][b];
          }
          if (sum < ans) {
                    ans = sum;
                    way_p = temp;
               }
    }
    //输出结果
    for (int i = way_p.size()-1; i >= 0; i--) {
          cout << way_p[i] << " ";
    }
    cout << Dis[D] << " " << ans << endl;
    return 0;
}</span><span style="color:#ff0000;">
</span>