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 + , M = 2e5 + , Kmx = ;

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

 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 = , int nx = , int w = ):ed(ed), nx(nx), w(w) {    }
 }Edge;

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

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

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

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

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

 typedef class Node {
     public:
         int p, dis;

         Node(int p = , int dis = ):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 + ), _g.init(n + );
     for (int i = , 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 + , f + n + , inf);
     que.push(Node(, f[] = ));
     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 ;
     if (dif < )
         return ;
     assert(dif >= );
     if (vis[p][dif] & )
         return cir = true;
     if (vis[p][dif] & )
         return h[p][dif];
     vis[p][dif] |= , h[p][dif] = (p ==  && dif == );
     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 ;
     }
     vis[p][dif] ^= ;
     return h[p][dif];
 }

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

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