PAT 1087 All Roads Lead to Rome

#include <cstdio>
#include <climits>
#include <iostream>
#include <vector>
#include <string>
#include <queue>
#include <unordered_map>
#include <algorithm>

using namespace std;

typedef pair<int, int> P;

class City {
public:
    int        id;
    string     name;
    int     happiness;
    int     distance;
    vector<int> adj;
    City(string _name, int _happiness = 0, int _id = 0, int _distance = INT_MAX) :
        name(_name), happiness(_happiness), id(_id), distance(_distance) {}
};

class Solution {
public:
    int happiness;
    vector<int> path;
    Solution(int happy = 0) : happiness(happy) {}
};

bool solution_cmp_inv(const Solution& a, const Solution& b) {
    if (a.happiness > b.happiness) {
        return true;
    } else if (a.happiness < b.happiness) {
        return false;
    } else {
        return a.happiness / a.path.size() > b.happiness / b.path.size();
    }
}

int G[200][200];

vector<Solution> res;

void build_solution(vector<City*> &cities, Solution &s, int pos, int dst, int hap) {
    // we know that start city index must be zero
    // so when pos == 0, we get a solution
    if (pos == 0) {
        res.push_back(s);
        res.back().happiness= hap;
        return;
    }
    
    // we are now at the cities[pos] with left dst to the start city
    City* city = cities[pos];
    for (int i=0; i<city->adj.size(); i++) {
        City* adj = cities[city->adj[i]];
        
        // we could not go to this adj city, not on the shortest path
        if (adj->distance + G[pos][adj->id] != dst) {
            continue;
        }
        
        // here we can assume that the adj city is on the shortest path
        s.path.push_back(adj->id);
        build_solution(cities, s, adj->id, adj->distance, hap + adj->happiness);
        s.path.pop_back();
    }
}
int main() {
    vector<City*> cities;
    
    unordered_map<string, int> city_lookup;
    
    int        N, K;
    char    buf[10], buf2[10];
    
    scanf("%d%d%s", &N, &K, buf);
    
    City* start = new City(buf, 0, 0, 0);
    cities.push_back(start);
    city_lookup.insert(make_pair(start->name, 0));
    
    int tmp = 0;
    for (int i=1; i<N; i++) {
        scanf("%s%d", buf, &tmp);
        cities.push_back(new City(buf, tmp, cities.size()));
        city_lookup.insert(make_pair(buf, cities.back()->id));
    }
    
    tmp = 0;
    int ca = 0, cb = 0;
    
    for (int i=0; i<K; i++) {
        scanf("%s%s%d", buf, buf2, &tmp);
        
        ca = city_lookup.find(buf)->second;
        cb = city_lookup.find(buf2)->second;
        
        cities[ca]->adj.push_back(cb);
        cities[cb]->adj.push_back(ca);
        
        G[ca][cb] = G[cb][ca] =tmp;
    }
    
    priority_queue<P, vector<P>, greater<P>> cand_cities;
    cand_cities.push(make_pair(0, 0));
    
    while(!cand_cities.empty()) {
        P p = cand_cities.top();
        cand_cities.pop();
        
        City* sel_city = cities[p.second];
        
        if (sel_city->distance < p.first) continue;

        for (int i=0; i<sel_city->adj.size(); i++) {
            City* adj_city = cities[sel_city->adj[i]];
            
            int new_dst = sel_city->distance + G[sel_city->id][adj_city->id];
            
            if (adj_city->distance > new_dst) {
                adj_city->distance = new_dst;
                cand_cities.push(make_pair(new_dst, adj_city->id));
            }
        }
    }
    
    City* rom = cities[city_lookup.find("ROM")->second];
    
    Solution s;
    
    build_solution(cities, s, rom->id, rom->distance, rom->happiness);
    
    sort(res.begin(), res.end(), solution_cmp_inv);
    
    Solution& best = res[0];
    
    printf("%d %d %d %d
", res.size(), rom->distance, best.happiness, best.happiness / best.path.size());
    
    for (int i = best.path.size() - 1; i>=0; i--) {
        printf("%s->", cities[best.path[i]]->name.c_str());
    }
    printf("ROM
");
    return 0;
}

稍微有点烦, 不过思路比较简单,还是跟课本靠的比较近最短路径,然后再dfs扫出所有可能路径, 进行一个排序就ok了,感谢STL,用单纯的C写的话...