2018 天梯赛 L3-1 直捣黄龙（Floyd+打印路径+打印解的个数）

题目大意

给出无向带权图，确定起点和终点，特殊地每个点都有点权。现在需要求出一条起点到终点的最短路并打印路径，该路径满足：起点到终点的距离最短；若最短路不唯一选择经过节点最多的路径；若路径仍然不唯一选择点权和最大的路径。

此外还需要求出最短路的数量（这里指广义的最短路，只考虑距离）。

解题思路

这种多种条件限制的“最短路”之前见过几次，写法就是当前一个条件为相等时，那么考虑后一个条件。

• 对于经过节点数，设置数组$cnt[i][j]$表示$i\to j$经过的节点数目，若有$cnt[i][j]<cnt[i][k]+cnt[k][j]-1$，显然要更新$cnt[i][j]$，之所以减一是因为$k$点重复统计了。初始化为$cnt[i][j]=(i==j?1:2)$。

• 对于点权之和，设置数组$num[i][j]$表示$i\to j$的点权之和，若有$num[i][j]<num[i][k]+num[k][j]-val[k]$，显然要更新$num[i][j]$，之所以减$val[k]$是因为$k$点的权值重复统计了。初始化为$num[i][j]=(i==j?val[i]:val[i]+val[j])$。

关于打印最短路的数目：

最终从终点到起点的所有最短路构成的是一颗搜索树，那么我们只需沿着终点开始搜到起点。对于边$u-v$，如果起点到$u$的最短路等于起点到$v$的最短路加上$w(u,v)$，那么就可以继续搜索，每搜到一次起点答案加一。

代码

//
// Created by Happig on 2020/11/21
//
#include <bits/stdc++.h>
#include <unordered_map>

using namespace std;
#define ENDL "\n"
#define lowbit(x) (x&(-x))
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
const double eps = 1e-8;
const double pi = acos(-1.0);
const int inf = 0x3f3f3f3f;
const double dinf = 1e300;
const ll INF = 1e18;
const int Mod = 1e9 + 7;
const int maxn = 2e5 + 10;

map<string, int> id;
map<int, string> toStr;

int n, m, tot = 0, all = 0;
int val[505];
int g[505][505], G[505][505], path[505][505], cnt[505][505], num[505][505];

void getID(string s) {
    if (!id[s]) {
        id[s] = ++tot;
        toStr[tot] = s;
    }
}

void init() {
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            g[i][j] = G[i][j] = (i == j ? 0 : inf);
            cnt[i][j] = (i == j ? 1 : 2);
            num[i][j] = (i == j ? val[i] : val[i] + val[j]);
            path[i][j] = j;
        }
    }
}

void dfs(int u) {
    if (u == 1) {
        all++;
        return;
    }
    for (int i = 1; i <= n; i++) {
        if (i != u && G[u][i] < inf && g[1][u] == g[1][i] + G[u][i]) {
            dfs(i);
        }
    }
}

void Floyd() {
    for (int k = 1; k <= n; k++) {
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                if (g[i][j] > g[i][k] + g[k][j]) {
                    g[i][j] = g[i][k] + g[k][j];
                    cnt[i][j] = cnt[i][k] + cnt[k][j] - 1;
                    num[i][j] = num[i][k] + num[k][j] - val[k];
                    path[i][j] = path[i][k];
                } else if (g[i][j] == g[i][k] + g[k][j]) {
                    if (cnt[i][j] < cnt[i][k] + cnt[k][j] - 1) {
                        cnt[i][j] = cnt[i][k] + cnt[k][j] - 1;
                        num[i][j] = num[i][k] + num[k][j] - val[k];
                        path[i][j] = path[i][k];
                    } else if (cnt[i][j] == cnt[i][k] + cnt[k][j] - 1) {
                        if (num[i][j] < num[i][k] + num[k][j] - val[k]) {
                            num[i][j] = num[i][k] + num[k][j] - val[k];
                            path[i][j] = path[i][k];
                        }
                    }
                }
            }
        }
    }
}

void PrintPath(int u, int v) {
    if (u == v) {
        cout << toStr[v] << ENDL;
        return;
    }
    cout << toStr[u] << "->";
    PrintPath(path[u][v], v);
}

int main() {
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    //ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    string s, e;
    int x, y, u, v, w;
    cin >> n >> m >> s >> e;
    getID(s), getID(e);
    x = id[s], y = id[e];
    for (int i = 1; i < n; i++) {
        cin >> s;
        getID(s);
        cin >> val[id[s]];
    }
    init();
    while (m--) {
        cin >> s >> e >> w;
        u = id[s], v = id[e];
        g[u][v] = g[v][u] = G[u][v] = G[v][u] = w;
    }
    Floyd();
    dfs(y);
    PrintPath(x, y);
    cout << all << " " << g[x][y] << " " << num[x][y] << ENDL;
    return 0;
}