LuoguP3953 逛公园(最短路+dp)

逛公园

题目：

策策同学特别喜欢逛公园。公园可以看成一张 \(N\) 个点 \(M\) 条边构成的有向图，且没有 自环和重边。其中 \(1\) 号点是公园的入口，\(N\) 号点是公园的出口，每条边有一个非负权值， 代表策策经过这条边所要花的时间。
策策每天都会去逛公园，他总是从 \(1\) 号点进去，从 \(N\) 号点出来。策策喜欢新鲜的事物，它不希望有两天逛公园的路线完全一样，同时策策还是一个 特别热爱学习的好孩子，它不希望每天在逛公园这件事上花费太多的时间。如果 \(1\) 号点 到 \(N\) 号点的最短路长为 \(d\)，那么策策只会喜欢长度不超过 \(d + K\) 的路线。
策策同学想知道总共有多少条满足条件的路线，你能帮帮它吗？为避免输出过大，答案对 \(P\) 取模。如果有无穷多条合法的路线，请输出 \(-1\)。

思路：

因为题目保证了从 \(1\) 到 \(N\) 一定是可以到达的，而且同时还要知道最短路的长 \(d\) ，就不难想到要跑一遍最短路,但是我们要知道其他能够到达 \(n\) 的方案的路径长度，所以连边的时候不能够用无向边来存储，需要建两个图(正图，反图)， 正图用来跑出来 \(1 \rightarrow N\) 的最短路的长度，反图用来处理相差不超过 \(K\) 的方案。

    int n, m, k, p;
    std::cin >> n >> m >> k >> p;
    //建出正反图
    std::vector<std::vector<std::array<int, 2>>> g1(n + 1);
    std::vector<std::vector<std::array<int, 2>>> g2(n + 1);
    for (int i = 0; i < m; i++) {
        int u, v, w;
        std::cin >> u >> v >> w;
        g1[u].push_back({v, w});
        g2[v].push_back({u, w});
    }

    // Dijkstra算法
    std::priority_queue<std::array<int, 2>, std::vector<std::array<int, 2>>, std::greater<std::array<int, 2>>> q;
    q.push({0, 1});
    std::vector<int> dist(n + 1, 1E9);
    std::vector<bool> vis(n + 1);
    dist[1] = 0;
    while(q.size()) {
        auto [w, u] = q.top(); q.pop();
        if (vis[u]) continue;
        vis[u] = true;

        for (auto& [v, ww] : g1[u]) {
            if (dist[v] > dist[u] + ww) {
                dist[v] = dist[u] + ww;
                q.push({dist[v], v});
            }
        }
    }

由于最终要求的是方案数，并且同样有相差不超过 \(K\) 的额外限制，所以考虑用 \(dp\) 来求解方案数。定义状态为 \(dp[u][k]\) 代表从 \(1 \rightarrow u\) 的路径中长度为 \(dist_u + k\) 的方案数。现在考虑状态的转移，假设现在要从 \(u \rightarrow v\) ,也就是 \(dp[u][k] \rightarrow dp[v][x]\) 也就是 \(dist_v + x + w(u, v) = dist_u + k \Rightarrow x = dist_u - dist_v + k - w(u, v)\) 。这样 \(dp[u][k]\) 就可以从 \(dp[v][dist_u - dist_v + k - w(u, v)]\) 转移过来。在反图上跑一遍 \(dp\) ，用记忆化搜索的方式会比较好写，

    std::vector<std::vector<bool>> st(n + 1, std::vector<bool> (k + 1));
    std::vector<std::vector<int>> dp(n + 1, std::vector<int> (k + 1));

    int f = 0;
    std::function<int(int, int)> dfs = [&](int u, int now) -> int {
        if (now < 0) return 0;
        if (st[u][now]) { f = 1; return 0; }
        if (dp[u][now]) return dp[u][now];
        st[u][now] = true;

        int ans = 0;
        for (auto& [v, w] : g2[u]) {
            ans = (ans + dfs(v, dist[u] - dist[v] + now - w)) % p;
            if (f) return 0;
        }
        st[u][now] = false;
        return dp[u][now] = ans;
    };

    dfs(1, 0);
    dp[1][0] = 1;
    int ans = 0;
    for (int i = 0; i <= k; i++) {
        ans = (ans + dfs(n, i)) % p;
    }

    if (f == 1) return void(std::cout << "-1\n");
    std::cout << ans << "\n";