pat 1030

 1030 Travel Plan (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 specification

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 Specification:

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

 

 

题意：想从A地去B地旅行，要求找到从A到B的最短路径，如果有多条最短路径，选取其中花费最小的一条.
思路：根据所给的信息构建图，这里我是用邻接矩阵存储的。然后使用Dijkstra算法求解单源最短路径，这里的源点就是出发点A，注意到
最短路径有多条，因此需要用一个vector类型的变长数组记录某个顶点的前一个顶点（
这个顶点可能有多个，要加到vector后面）
。得到A到B的最短路径之后采用dfs算法，递归求出最短路径中花费最少的路径。

#include<cstdio>
#include<algorithm>
#include<vector>
#define inf 999999
using namespace std;
bool collected[505]={false};
vector<int> pre[505];
int dist[505];
int n,m,s,d;
typedef struct{
    int dis;
    int cost;
}node;
node G[505][505];
int minCost=inf;
vector<int> path,temppath;
void dfs(int v){
    temppath.push_back(v);
    if(v==s){
        int sum=0;
        for(int i=0;i<temppath.size()-1;i++){
            int a1=temppath[i];
            int a2=temppath[i+1];
            sum+=G[a1][a2].cost;
        }
        if(sum<minCost){
            path=temppath;
            minCost=sum;
        }
        temppath.pop_back();
        return;
    }
    for(int i=0;i<pre[v].size();i++){
        dfs(pre[v][i]);
    }
    temppath.pop_back();
}
int findMin(){
    int minV=-1;
    int minLength=inf;
    for(int i=0;i<n;i++){
        if(collected[i]==false&&dist[i]<minLength){
            minV=i;
            minLength=dist[i];
        }
    }
    return minV;
}
void dijkstra(){
    for(int i=0;i<n;i++){
        if(G[s][i].dis<inf){
            dist[i]=G[s][i].dis;
            pre[i].push_back(s);
        }
    }
    dist[s]=0;
    collected[s]=true;
    while(1){
        int v=findMin();
        if(v==-1)
            break;
        collected[v]=true;
        for(int i=0;i<n;i++){
            if(collected[i]==false&&G[v][i].dis<inf){
                if(G[v][i].dis+dist[v]<dist[i]){
                    dist[i]=G[v][i].dis+dist[v];
                    pre[i].clear();
                    pre[i].push_back(v);
                }
                else if(G[v][i].dis+dist[v]==dist[i]){
                    pre[i].push_back(v);
                }
            }
        }
    }

}
int main(){
    for(int i=0;i<505;i++){
        dist[i]=inf;
        for(int j=0;j<505;j++){
            G[i][j].cost=G[i][j].dis=inf;
            
        }
    } 

    int a,b,dis,cost;
    scanf("%d%d%d%d",&n,&m,&s,&d);
    for(int i=0;i<m;i++){
        scanf("%d%d%d%d",&a,&b,&dis,&cost);
        G[a][b].dis=G[b][a].dis=dis;
        G[a][b].cost=G[b][a].cost=cost;
    }
    dijkstra();
    dfs(d);
    int length=0;
    for(int i=path.size()-1;i>=0;i--){
        printf("%d ",path[i]);    
        if(i!=0)
        length+=G[path[i]][path[i-1]].dis;
    } 
    printf("%d ",length);
    printf("%d",minCost);
    return 0;
}