PAT A1087 All Roads Lead to Rome(30)

题意

• N个城市，给定起点终点，除起点外每个城市有一个点权，第一标尺，边权和最小（最短路径），第二标尺，点权和最大，第三标尺，平均点权和最大（不算起点）。同时还要输出第一标尺对应的路径数量和最后唯一的路径。

注意

1. 第三标尺可以转化为结点数量最小。
2. dijkstra更新路径里面要把这些逻辑都写上。
3. 城市名是个字符串，用map<string,int>就可以处理。

代码

#include <iostream>
#include <algorithm>
#include <climits>
#include <string>
#include <map>
using namespace std;

const int Nmax = 200;

struct City
{
    string name;
    int happy;
    int t_road;
    int t_cost;
    int t_happy;
    int t_node;
    int v;
};
City c[Nmax];

int road[Nmax][Nmax];
int N, K;
map<string, int> m;
bool S[Nmax];

void DiJkStRa()
{
    fill(S, S + N, false);
    c[0].t_cost = 0;
    c[0].t_happy = 0;
    c[0].t_node = 0;
    c[0].t_road = 1;
    for (int i = 0; i < N; i++)
    {
        int min = INT_MAX, k;
        for (int j = 0; j < N; j++)
        {
            if (!S[j] && c[j].t_cost < min)
            {
                min = c[j].t_cost;
                k = j;
            }
        }
        S[k] = true;
        for (int j = 0; j < N; j++)
        {
            if (!S[j] && road[k][j] != INT_MAX)
            {
                if (c[k].t_cost + road[k][j] < c[j].t_cost)
                {
                    c[j].t_cost = c[k].t_cost + road[k][j];
                    c[j].t_happy = c[k].t_happy + c[j].happy;
                    c[j].t_node = c[k].t_node + 1;
                    c[j].t_road = c[k].t_road;
                    c[j].v = k;
                }
                else if (c[k].t_cost + road[k][j] == c[j].t_cost)
                {
                    c[j].t_road += c[k].t_road;
                    if (c[j].t_happy < c[k].t_happy + c[j].happy)
                    {
                        c[j].t_happy = c[k].t_happy + c[j].happy;
                        c[j].t_node = c[k].t_node + 1;
                        c[j].v = k;
                    }
                    else if (c[j].t_happy == c[k].t_happy + c[j].happy)
                    {
                        if (c[j].t_node > c[k].t_node + 1)
                        {
                            c[j].t_node = c[k].t_node + 1;
                            c[j].v = k;
                        }
                    }
                }
            }
        }
    }
}

void print(int t)
{
    if (t == 0)
    {
        cout << c[0].name;
        return;
    }
    print(c[t].v);
    cout << "->" << c[t].name;
}

int main()
{
    cin >> N >> K >> c[0].name;
    m.insert(map<string, int>::value_type(c[0].name, 0));
    for (int i = 1; i < N; i++)
    {
        cin >> c[i].name >> c[i].happy;
        m.insert(map<string, int>::value_type(c[i].name, i));
        c[i].t_cost = INT_MAX;
    }
    string s1, s2;
    fill(road[0], road[0] + Nmax*Nmax, INT_MAX);
    for (int i = 0; i < K; i++)
    {
        cin >> s1 >> s2;
        cin >> road[m[s1]][m[s2]];
        road[m[s2]][m[s1]] = road[m[s1]][m[s2]];
    }
    DiJkStRa();
    cout << c[m["ROM"]].t_road << " " << c[m["ROM"]].t_cost << " " << c[m["ROM"]].t_happy << " " << c[m["ROM"]].t_happy / c[m["ROM"]].t_node << endl;
    print(m["ROM"]);

    return 0;
}