dijkstra的简单应用（pat中等题）

acwing：1507. 旅行计划

给定一张地图，包含 N个城市，M 条高速公路。

城市之间都能相互连通。

每条高速公路的长度和走该条公路的花费都是已知的，高速公路都是双向的。

现在要从地图中的某个城市前往另一个城市。

请你确定最短路径，当最短路径不唯一时，请你选取花费最小的路径（保证唯一）。

输入格式

第一行包含四个整数 N,M,S,D，分别表示城市数量，公路数量，起点城市编号，终点城市编号。

城市编号从 0 到 N−1。

接下来 M 行，每行包含四个整数 a,b,c,d表示城市 a 和城市 b之间存在一条公路，长度为 c，花费为 d。

输出格式

共一行，首先输出从起点城市到终点城市的最短路径（花费最少的）经过的所有城市，然后输出最短路径的距离以及最小的花费。

 

 题解：（堆优化的dijkstra）

#include<bits/stdc++.h>
using namespace std;
const int N = 510, M = 610;
int h[N], e[2 * M], ne[2 * M], w1[2 * M], w2[2 * M], idx;
int fee[N], dis[N];
int last[N],path[N];
bool st[N];
typedef pair<int, int>PII;
int n, m, S, D;
void add(int a, int b, int c, int d) {
    e[idx] = b, w1[idx] = c, w2[idx] = d, ne[idx] = h[a], h[a] = idx++;
}
void dijkstral() {
    for (int i = 0;i <= n;i++) {
        last[i] = 505;
    }
    memset(fee, 0x3f, sizeof(fee));
    memset(dis, 0x3f, sizeof(dis));
    dis[S] = 0, fee[S] = 0;
    priority_queue<PII, vector<PII>, greater<PII>> q;
    q.push({ 0,S });
    while (q.size())
    {
        auto t = q.top();
        q.pop();
        int v = t.first;
        int u = t.second;
        if (st[u]) {
            continue;
        }
        st[u] = true;
        for (int i = h[u];i != -1;i = ne[i]) {
            int j = e[i];
            if (dis[u] + w1[i] < dis[j]) {
                dis[j] = dis[u] + w1[i];
                fee[j] = fee[u] + w2[i];
                q.push({ dis[j],j });
                last[j] = u;
            }
            else if (dis[u] + w1[i] == dis[j]) {
                if (fee[j] > fee[u] + w2[i]) {
                    
                        fee[j] = fee[u] + w2[i];
                        q.push({ dis[j],j });
                        last[j] = u;
                    
                }
            }
        }
    }
}
void solve() {
    memset(h, -1, sizeof(h));
    cin >> n >> m >> S >> D;
    for (int i = 0;i < m;i++) {
        int a, b, c, d;
        cin >> a >> b >> c >> d;
        add(a, b, c, d);
        add(b, a, c, d);
    }
    dijkstral();
    int cnt = 0;
    for (int i = D;i!=S;i=last[i]) {
        path[cnt++] = last[i];
    }
    for (int i = cnt-1;i >=0;i--) {
        cout << path[i] << " ";
    }
    cout << D << " ";
    cout << dis[D] << " " << fee[D] << endl;

}
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);
    int t = 1;
    while (t--) {
        solve();
    }
}

acwing：1577. 条条大路通罗马

从我们的城市到达罗马有许多不同的旅游路线。

请你在成本最低的旅游路线之中，找到使得游客幸福感最强的路线。

输入格式

第一行包含两个整数 N 和 K，分别表示总城市数量，城市之间道路数量，还包含一个城市名字，表示初始城市。

接下来 N−1行，每行包含一个城市名和一个整数，表示到达该城市（初始城市除外）可以获得的幸福感。

接下来 K行，每行包含一个道路的信息，格式为 City1 City2 Cost，表示两个城市之间的道路行走的花费，道路是双向的。

城市都是由三个大写字母构成的字符串。

我们的目的地始终都是罗马 ROM。

输出格式

我们应该找到成本最低的路线。

如果这样的路线不是唯一的，那么选取使人们获得最大幸福感的路线。

如果这样的路线仍然不是唯一的，那么我们选择平均幸福感最大的路线，数据保证这种路线唯一。

平均幸福感 = 总幸福感 / 经过的城市数量（初始城市不算）

第一行输出四个整数，最小成本的路线数量，最小成本，幸福感，平均幸福感（只取整数部分）。

第二行，按照 City1->City2->...->ROM 的格式输出路线。

题解：（堆优化的dijkstra+哈希表）

#include<bits/stdc++.h>
#include<unordered_map>
using namespace std;
const int N = 210, M = 260;
typedef pair<int, int>PII;
int h[N], e[M * 2], ne[M * 2], w[M * 2], idx;
int dis[N], happy[N], cnt[N];
int sum[N], ha[N];
int path[N];
bool st[N];
unordered_map<int, string> th;
unordered_map<string ,int> ht;
int n, m;
string start;
void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}
void dijkstra(int u)
{
    memset(dis, 0x3f, sizeof(dis));
    priority_queue<PII, vector<PII>, greater<PII>> q;
    sum[u] = 1, cnt[u] = 1;
    happy[u] = 0;
    q.push({ 0,u });
    dis[u] = 0;
    while (q.size()) {
        auto t = q.top();
        int v = t.second;
        q.pop();
        if (st[v]) {
            continue;
        }
        st[v] = true;
        for (int i = h[v];i != -1;i = ne[i]) {
            int j = e[i];
            if (dis[j] > dis[v] + w[i]) {
                dis[j] = dis[v] + w[i];
                q.push({ dis[j],j });
                happy[j] = happy[v] + ha[j];
                cnt[j] = cnt[v] + 1;
                sum[j] = sum[v];
                path[j] = v;
            }
            else if (dis[j] == dis[v] + w[i]) {
                sum[j]+=sum[v];
                if (happy[j] < happy[v] + ha[j]) {
                    happy[j] = happy[v] + ha[j];
                    cnt[j] = cnt[v] + 1;
                    q.push({ dis[j],j });
                    path[j] = v;
                }
                else if (happy[j] == happy[v] + ha[j]) {
                    if (cnt[j] > cnt[v] + 1) {
                        cnt[j] = cnt[v] + 1;
                        path[j] = v;
                        q.push({ dis[j],j });
                    }
                }
            }
        }

    }
}
void solve()
{
    memset(h, -1, sizeof(h));
    cin >> n >> m >> start;
    th[0] = start;
    ht[start] = 0;
    for (int i = 1;i < n;i++) {
        string s;
        int a;
        cin >> s >> a;
        th[i] = s;
        ht[s] = i;
        ha[i] = a;
    }
    for (int i = 1;i <= m;i++) {
        string a, b;
        int c;
        cin >> a >> b >> c;
        add(ht[a], ht[b], c);
        add(ht[b], ht[a], c);
    }
    dijkstra(0);
    int ed = ht["ROM"];
    cout << sum[ed]<<" " << dis[ed] <<" "<< happy[ed]<<" " << happy[ed] / (cnt[ed] - 1) << endl;
    int Path[N];
    int Cnt=0;
    for(int i=ed;i!=0;i=path[i]){
        Path[Cnt++]=path[i];
    }
    for(int i=Cnt-1;i>=0;i--){
        cout<<th[Path[i]]<<"->";
    }
    cout<<"ROM";

}
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);
    int t = 1;
    while (t--) {
        solve();
    }
    return 0;
}