PATA1087题解

最短路径dijkstra + DFS模版题

//
//  main.cpp
//  PATA1087
//
//  Created by Phoenix on 2018/2/19.
//  Copyright © 2018年 Phoenix. All rights reserved.
//

#include <iostream>
#include <cstdio>
#include <map>
#include <string>
#include <vector>
using namespace std;
const int maxn = 210;
const int inf = 1000000000;
int n, k, st, ed, num = 0;      //n,k,st,ed,num分别为城市个数，道路数，起点，终点（ROM），代价最小道路数
int G[maxn][maxn];
int d[maxn], c[maxn] = {0};     //c[maxn]为幸福指数
bool vis[maxn] = {false};
vector<int> pre[maxn];          //记录前驱城市号

map<string, int> mp1;           //城市名与城市号映射
map<int, string> mp2;           //城市号与城市名映射

void dijkstra() {               //寻求起点到每个城市的最短路径与前驱节点
    fill(d, d + maxn, inf);
    d[0] = 0;
    for(int i = 0; i < n; i++) {
        int u = -1, MIN = inf;
        for(int j = 0; j < n; j++) {
            if(vis[j] == false && d[j] < MIN) {
                u = j;
                MIN = d[j];
            }
        }
        if(u == -1) return;
        vis[u] = true;
        for(int v = 0; v < n; v++) {
            if(vis[v] == false && G[u][v] != inf) {
                if(d[u] + G[u][v] < d[v]) {
                    pre[v].clear();
                    d[v] = d[u] + G[u][v];
                    pre[v].push_back(u);
                } else if(d[u] + G[u][v] == d[v]) {
                    pre[v].push_back(u);
                }
            }
        }
    }
}

vector<int> temp, path;
int optvalue = -1;
void DFS(int v) {           //记录最小代价的路径数目，并寻找幸福指数和最大且通过城市最少的路径
    if(v == st) {
        temp.push_back(v);
        num++;
        int value = 0;
        for(int i = 0; i < temp.size(); i++) {  //记录幸福指数和
            value += c[temp[i]];
        }
        if(value > optvalue) {                  //选择幸福指数和大的路径
            optvalue = value;
            path = temp;
        } else if(value == optvalue) {          //如果两条路幸福指数和相同，选择通过城市数目少的路径
            if(temp.size() < path.size()) {
                path = temp;
            }
        }
        temp.pop_back();
    }
    temp.push_back(v);
    for(int i = 0; i < pre[v].size(); i++) {
        DFS(pre[v][i]);
    }
    temp.pop_back();
}

int main(int argc, const char * argv[]) {
    string start, city;
    cin >> n >> k >> start;
    mp1[start] = 0;
    mp2[0] = start;
    for(int i = 1; i < n; i++) {        //建立城市名与城市号之间的映射
        cin >> city >> c[i];            //记录城市的幸福指数
        if(city == "ROM") ed = i;
        mp1[city] = i;
        mp2[i] = city;
    }
    fill(G[0], G[0] + maxn * maxn, inf);
    for(int i = 0; i < k; i++) {        //记录代价矩阵
        int a, b, dis;
        string c1, c2;
        cin >> c1 >> c2 >> dis;
        a = mp1[c1];
        b = mp1[c2];
        G[a][b] = G[b][a] = dis;
    }
    dijkstra();
    DFS(ed);
    printf("%d %d %d %d\n", num, d[ed], optvalue, optvalue / (path.size() - 1));    //分别输出代价最小路径条数，最小代价，幸福指数和最大值，平均幸福指数最大值
    for(int i = path.size() - 1; i >= 0; i--) {     //输出从起点到终点的路径
        cout << mp2[path[i]];
        if(i > 0) printf("->");
    }
    return 0;
}