PAT1030

1030. Emergency (30)

题目：

A traveler’s map gives the distances between cities along the highways, together with the cost of each highway. Now you are supposed to write a program to help a traveler to decide the shortest path between his/her starting city and the destination. If such a shortest path is not unique, you are supposed to output the one with the minimum cost, which is guaranteed to be unique.

Input

Each input file contains one test case. Each case starts with a line containing 4 positive integers N, M, S, and D, where N (<=500) is the number of cities (and hence the cities are numbered from 0 to N-1); M is the number of highways; S and D are the starting and the destination cities, respectively. Then M lines follow, each provides the information of a highway, in the format:

City1 City2 Distance Cost

where the numbers are all integers no more than 500, and are separated by a space.

Output

For each test case, print in one line the cities along the shortest path from the starting point to the destination, followed by the total distance and the total cost of the path. The numbers must be separated by a space and there must be no extra space at the end of output.

Sample Input

4 5 0 3

0 1 1 20

1 3 2 30

0 3 4 10

0 2 2 20

2 3 1 20

Sample Output

0 2 3 3 40

题目连接

题目描述：

　　有 N 个城市、M 条道路(无向边)，给出 M 条道路的属性个花费，给定起点 S 和终点 D ，求从起点到终点的最短路径、最短距离及花费。

注意：如果有多条最短路径，应选择花费最小的那条。

分析

　　除了求最短路径外，还应保证花费最小，可以先把所有的最短路径保存下来，然后遍历每条路径找出花费最小的那条；或者在求最短路径的时候就把花费考虑进去一并解决

代码

    #include <iostream>
    #include <vector>
    using namespace std;
    const int maxn = 500 + 5;
    const int INF = 1000000000;
    int G[maxn][maxn];              //图的邻接矩阵
    int cost[maxn][maxn];       //花费矩阵
    bool visit[maxn] = {false};
    int dis[maxn];
    int n,m,s,d,minCost;
    vector <int> pre[maxn];         //保存前驱结点
    vector <int> path,tempPath;//临时路径和最优路径

    void Dijkstra(int v){
        for(int i = 0;i < maxn;i++){
            dis[i] = INF;
        }
        dis[v] = 0;

        for(int i = 0;i < n;i++){
            int u = -1,min = INF;
            for(int j = 0;j < n;j++){
                if(!visit[j] && dis[j] < min){
                    u = j;
                    min = dis[j];
                }
            }
            if(u == -1) return;
            visit[u] = true;
            for(int j = 0;j < n;j++){
                if(!visit[j] && G[u][j] != INF){
                    if(dis[u] + G[u][j] < dis[j]){
                        dis[j] = dis[u] + G[u][j];
                        pre[j].clear();                             //清空
                        pre[j].push_back(u);        //u为j的前驱
                    }
                    else if(dis[u] + G[u][j] == dis[j]){//找到相同距离的路径时
                        pre[j].push_back(u);        //u为j的前驱之一
                    }
                }
            }
        }
    }
    void DFS(int v){
        if(v == s){
            tempPath.push_back(v);
            int tempCost = 0;
            for(int i = tempPath.size()-1;i > 0;i--){       //求最小的边权
                int id = tempPath[i],idNext = tempPath[i-1];
                tempCost += cost[id][idNext];
            }
            if(tempCost < minCost){                     //保存最小的边权值
                minCost = tempCost;
                path = tempPath;                        //保存路径
            }
            tempPath.pop_back();
            return;
        }

        tempPath.push_back(v);

        for(int i = 0;i < pre[v].size();i++){
            DFS(pre[v][i]);                         //搜索前驱结点
        }
        tempPath.pop_back();
    }
    int main(void){
        ios::sync_with_stdio(false);

        minCost = INF;
        for(int i = 0;i < maxn;i++)
            for(int j = 0;j < maxn;j++)
                G[i][j] = INF;

        cin>>n>>m>>s>>d;        //顶点数、边数、起点、终点

        int v1,v2;
        for(int i = 0;i < m;i++){
            cin>>v1>>v2;
            cin>>G[v1][v2];
            cin>>cost[v1][v2];

            G[v2][v1] = G[v1][v2];
            cost[v2][v1] = cost[v1][v2];
        }

        Dijkstra(s);
        DFS(d);             //因为前面保存的是前驱结点，所以直接从终点寻找其前驱结点遍历路径

        for(int i = path.size()-1;i >= 0;i--)
            cout<<path[i]<<" ";
        cout<<dis[d]<<" "<<minCost<<endl;

        return 0;
    }