NOIP 2017 逛公园 - 动态规划 - 最短路

题目传送门

　　传送门

题目大意

　　给定一个$n$个点$m$条边的带权有向图，问从$1$到$n$的距离不超过最短路长度$K$的路径数。

　　跑一遍最短路。

　　一个点拆$K + 1$个点，变成一个DAG上路径计数问题。直接拓扑排序加动态规划，如果有一个$n$号点的剩余度数非0，就一个合法的路径上存在零环（这样可以无线走了）。

　　于是成功T掉了。

　　把拓扑排序变成不建图，从$n$开始记忆化搜索，然后就过了。

　　我居然把模数P打错成M调了一个上午，果然我菜啊。。。

　　下面这份代码获得了 97 分的好成绩，我也不知道发生了什么。

Code

/**
 * Uoj
 * Problem#331
 * Accepted
 * Time: 2392ms
 * Memory: 28196k
 */
#include <iostream>
#include <cassert>
#include <cstdlib>
#include <cstdio>
#include <vector>
#include <queue>
using namespace std;
typedef bool boolean;

typedef pair<int, int> pii;

const int N = 1e5 + 5, M = 2e5 + 5, Kmx = 52;

const signed int inf = (signed) (~0u >> 1);

template <typename T>
void pfill(T* pst, const T* ped, T val) {
    for ( ; pst != ped; *(pst++) = val);
}

typedef class Edge {
    public:
        int ed, nx, w;

        Edge(int ed = 0, int nx = 0, int w = 0):ed(ed), nx(nx), w(w) {    }
}Edge;

typedef class MapManager {
    public:
        int *h;
        vector<Edge> es;

        MapManager(int n) {
            h = new int[(n + 1)];
        }

        void init(int n) {
            pfill(h + 1, h + n + 1, -1);
            es.clear();
        }    

        void addEdge(int u, int v, int w) {
            es.push_back(Edge(v, h[u], w));
            h[u] = (signed) es.size() - 1;        
        }

        Edge& operator [] (int p) {
            return es[p];
        }
}MapManager;

typedef class Node {
    public:
        int p, dis;

        Node(int p = 0, int dis = 0):p(p), dis(dis) {    }

        boolean operator < (Node b) const {
            return dis > b.dis;
        }
}Node;

int n, m, K, P;
MapManager g(N), _g(N);

int add(int a, int b) {
    return ((a += b) >= P) ? (a - P) : (a);
}

inline void init() {
    scanf("%d%d%d%d", &n, &m, &K, &P);
    g.init(n + 1), _g.init(n + 1);
    for (int i = 1, u, v, w; i <= m; i++) {
        scanf("%d%d%d", &u, &v, &w);
        g.addEdge(u, v, w);
        _g.addEdge(v, u, w);
    }
}

int f[N];
priority_queue<Node> que;

int& operator * (Node p) {
    return f[p.p];
}

void dijstra() {
    pfill(f + 1, f + n + 1, inf);
    que.push(Node(1, f[1] = 0));
    while (!que.empty()) {
        Node e = que.top();
        que.pop();
        if (*e != e.dis)
            continue;
        for (int i = g.h[e.p]; ~i; i = g[i].nx)
            if (*e + g[i].w < f[g[i].ed])
                que.push(Node(g[i].ed, f[g[i].ed] = *e + g[i].w));
    }
}

int h[N][Kmx];
unsigned char vis[N][Kmx];
boolean cir = false;
int dp(int p, int dif) {
    if (dif > K)
        return 0;
    if (dif < 0)
        return 0;
    assert(dif >= 0);
    if (vis[p][dif] & 2)
        return cir = true;
    if (vis[p][dif] & 1)
        return h[p][dif];
    vis[p][dif] |= 3, h[p][dif] = (p == 1 && dif == 0);
    for (int i = _g.h[p], e, nd; ~i; i = _g[i].nx) {
        e = _g[i].ed;
        if (f[e] == inf)
            continue;
        nd = f[p] + dif - _g[i].w - f[e];
        h[p][dif] = add(h[p][dif], dp(e, nd));
        if (cir)
            return 0;
    }
    vis[p][dif] ^= 2;
    return h[p][dif];
}

inline void solve() {
    dijstra();
    if (f[n] == inf) {
        puts("0");
        return;
    }
    cir = false;
    pfill(vis[1], vis[n + 1], (unsigned char)0);
    int rt = dp(n, 0);
    for (int i = 1; i <= K && !cir; i++)
        rt = add(rt, dp(n, i));
    printf("%d\n", (cir) ? (-1) : (rt));
}

int T;
int main() {
    scanf("%d", &T);
    while (T--) {
        init();
        solve();
    }
    return 0;
}