NC16416 [NOIP2017]逛公园

题目链接

题目

题目描述

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

输入描述

第一行包含一个整数 T, 代表数据组数。
接下来 T 组数据，对于每组数据：
第一行包含四个整数 N,M,K,P， 每两个整数之间用一个空格隔开。
接下来 M 行，每行三个整数 ai,bi,ci， 代表编号为 ai,bi 的点之间有一条权值为 ci 的有向边，每两个整数之间用一个空格隔开。

输出描述

输出文件包含 T 行，每行一个整数代表答案。

示例1

输入

2
5 7 2 10
1 2 1
2 4 0
4 5 2
2 3 2
3 4 1
3 5 2
1 5 3
2 2 0 10
1 2 0
2 1 0

输出

3
-1

说明

对于第一组数据，最短路为 3。
1 - 5, 1 - 2 - 4 - 5, 1 - 2 - 3 - 5 为 3 条合法路径。

备注

对于不同测试点，我们约定各种参数的规模不会超过如下

本题在noip数据外额外增加一组数据卡掉了一种错解

题解

知识点：最短路，计数dp，DAG上dp，记忆化搜索。

先把起点到每个点的最短路处理出来。随后，建一个反图用来跑dp。

这道题有个坑点，起点 $1$ 也有可能出现在 $0$ 环内，这时候起点本身的状态实际上应该是无穷个方案，但如果dp初始化 $f[1][0] = 1$ ，就默认起点是有限方案，但这个结果是错的。因此，我们额外加一个一定不在环内的点 $n+1$ 连接 $1$ ，初始化 $f[n+1][0] = 1$ ，把这个当作新起点即可，因为 $n+1 \to 1$ 的路径只有一条，所以方案数不会变多，对答案没影响。yi

设 $f[u][k]$ 为从起点到达 $u$ 点且比最短路长了 $k$ 时的方案数。通过反图，从终点记忆化搜索倒推。假设当前状态为 $f[u][k]$ ，如果有反图边 $u \to v$ 权值为 $w$ ，即原图 $v \to u$ ，那么可以设 $f[v][kk]$ 为上一个状态，有 $kk = k - (w-(dis[u]-dis[v]))$ ，即上一个状态的 $kk$ 比 $k$ 小了这条边权与实际最短路边权的差值 $w-(dis[u]-dis[v])$ 。这也是很好理解的，因为 $v \to u$ 多跑了点路，所以 $kk$ 应该比 $k$ 小一点。同时，应该注意 $kk \geq 0$ ，否则不合法。

对于 $u$ ，把所有可及点 $v$ 的方案数相加即 $f[u][k]$ 的值。最后， $\sum_{i=0}^{k} f[n][i]$ 的值即最终答案。

当然，还需要一个 $fvis[u][k]$ 来记录这个状态是否已在求解链中。如果一个状态已经是需要求解的，但又遇到了，说明这里有一个 $0$ 环循环求解，答案会是无穷大，用 $flag$ 记录跳出即可。

时间复杂度 $O((n+m)\log m + kn)$

空间复杂度 $O(kn+m)$

代码

#include <bits/stdc++.h>
#define ll long long
 
using namespace std;
 
const int N = 100007, M = 200007;
 
template<class T>
struct Graph {
    struct edge {
        int v, nxt;
        T w;
    };
    int idx;
    vector<int> h;
    vector<edge> e;
 
    Graph(int n, int m):idx(0), h(n + 1), e(m + 1) {}
 
    void clear() {
        idx = 0;
        h.assign(h.size(), 0);
        e.assign(e.size(), { 0,0,0 });
    }
 
    void add(int u, int v, T w) {
        e[++idx] = edge{ v,h[u],w };
        h[u] = idx;
    }
};
Graph<int> g1(N, M), g2(N, M);
int n, m, K, P;
 
int dis[N];
bool vis[N];
struct node {
    int v, w;
    friend bool operator<(const node &a, const node &b) {
        return a.w > b.w;
    }
};
priority_queue<node> pq;
void dijkstra(int s) {
    dis[s] = 0;
    pq.push({ s,0 });
    while (!pq.empty()) {
        int u = pq.top().v;
        pq.pop();
        if (vis[u]) continue;
        vis[u] = 1;
        for (int i = g1.h[u];i;i = g1.e[i].nxt) {
            int v = g1.e[i].v;
            int w = g1.e[i].w;
            if (dis[v] > dis[u] + w) {
                dis[v] = dis[u] + w;
                pq.push({ v,dis[v] });
            }
        }
    }
}
 
int f[N][57];//f[u][k]：到达u点且比最短路多k的方案数 
bool fvis[N][57];//维护一条dfs链上访问信息,用于碰撞0环
bool flag;
int dfs(int u, int k) {
    if (~f[u][k]) return f[u][k];
    f[u][k] = 0;
    fvis[u][k] = 1;
    for (int i = g2.h[u];i;i = g2.e[i].nxt) {
        int v = g2.e[i].v;
        int w = g2.e[i].w;
        int kk = dis[u] + k - dis[v] - w;
        if (kk < 0) continue;//不合法
        if (fvis[v][kk]) flag = 1;//待求解状态已在求解栈，产生求解回路，即0环
        if (flag) return 0;
        f[u][k] = (f[u][k] + dfs(v, kk)) % P;
    }
    fvis[u][k] = 0;
    return f[u][k];
}
 
bool solve() {
    cin >> n >> m >> K >> P;
 
    g1.clear();
    g2.clear();
    flag = 0;
    memset(dis, 0x3f, sizeof(dis));
    memset(vis, 0, sizeof(vis));
    memset(f, -1, sizeof(f));
    memset(fvis, 0, sizeof(fvis));
 
    for (int i = 1;i <= m;i++) {
        int u, v, w;
        cin >> u >> v >> w;
        g1.add(u, v, w);
        g2.add(v, u, w);
    }
    //加一个源点，避免源点在0环内
    g1.add(n + 1, 1, 0);
    g2.add(1, n + 1, 0);
 
    dijkstra(n + 1);
 
    f[n + 1][0] = 1;//g2中，如果1就在0环内，f[1][0] = 1的初始化会导致直接return，而f[1][0]可能就在0环内部，直接return就无法判断0环
    int ans = 0;
    for (int i = 0;i <= K;i++) {
        ans = (ans + dfs(n, i)) % P;
    }
    if (flag) return false;
    else cout << ans << '\n';
    return true;
}
 
int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--) {
        if (!solve()) cout << -1 << '\n';
    }
    return 0;
}