Luogu P3953【NOIP2017】逛公园【最短路+拓扑排序+动态规划】

#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
#define travel(x, i) for (int i = fir[x]; i; i = e[i].nxt)
using namespace std;

namespace fastIO {
#define buf_size 1000000
  bool error;
  inline char gc() {
    static char buf[buf_size + 1], *l = buf, *r = buf;
    if (l == r) {
      l = buf;
      r = buf + fread(buf, 1, buf_size, stdin);
      if (l == r) {error = 1; return -1;}
    }
    return *l ++;
  }
  inline bool isnum(char ch) {
    return (‘0‘ <= ch && ch <= ‘9‘) || ch == ‘-‘;
  }
  inline void read(int &x) {
    char ch; x = 0;
    while (!isnum(ch = gc()) && !error);
    if (error) return;
    do {x = (x << 1) + (x << 3) + ch - ‘0‘;} while (isdigit(ch = gc()) && !error);
  }
#undef buf_size
}
using namespace fastIO;


typedef pair <int, int> pii;
const int N = 1e5 + 5;
const int M = 2e5 + 5;

int n, m, k, mod;
int ans[N][52];

namespace Graph1 {
  struct edge {
    int nxt, to, len;
  } e[M];
  int fir[N], dis[N], cnt;
  bool in[N];

  inline void clear() {memset(fir, 0, sizeof fir); cnt = 0;}
  inline void add(int x, int y, int l) {
    e[++ cnt] = (edge){fir[x], y, l};
    fir[x] = cnt;
  }
  inline void dijkstra() {
    memset(dis, -1, sizeof dis);
    memset(in, 0, sizeof in);
    priority_queue <pii, vector <pii>, greater <pii> > Q;
    Q.push(make_pair(0, 1));
    dis[1] = 0;
    pii cur;
    int x;
    while (!Q.empty()) {
      cur = Q.top(); Q.pop();
      x = cur.second;
      if (in[x]) continue;
      in[x] = 1;
      travel(x, i)
        if (!in[e[i].to] && (dis[x] + e[i].len < dis[e[i].to] || dis[e[i].to] == -1)) {
          dis[e[i].to] = dis[x] + e[i].len;
          Q.push(make_pair(dis[e[i].to], e[i].to));
        }
    }
  }
}

namespace Graph2 {
  struct edge {
    int nxt, to, len;
  } e[M];
  int fir[N], dis[N], cnt;
  bool in[N];
        
  inline void clear() {memset(fir, 0, sizeof fir); cnt = 0;}        
  inline void add(int x, int y, int l) {
    e[++ cnt] = (edge){fir[x], y, l};
    fir[x] = cnt;
  }
  inline void dijkstra() {
    memset(dis, -1, sizeof dis);
    memset(in, 0, sizeof in);
    priority_queue <pii, vector <pii>, greater <pii> > Q;
    Q.push(make_pair(0, n));
    dis[n] = 0;
    pii cur;
    int x;
    while (!Q.empty()) {
      cur = Q.top(); Q.pop();
      x = cur.second;
      if (in[x]) continue;
      in[x] = 1;
      travel(x, i)
        if (!in[e[i].to] && (dis[x] + e[i].len < dis[e[i].to] || dis[e[i].to] == -1)) {
          dis[e[i].to] = dis[x] + e[i].len;
          Q.push(make_pair(dis[e[i].to], e[i].to));
        }
    }
  }
}

namespace Graph3 {
  struct edge {
    int nxt, to;
  } e[M];
  int fir[N], cnt = 0, tot;
  int ord[N], deg[N];
    
  inline void clear() {
    memset(fir, 0, sizeof fir);
    memset(deg, 0, sizeof deg);
    cnt = 0;
  }
  inline void add(int x, int y) {
    e[++ cnt] = (edge){fir[x], y};
    fir[x] = cnt;
    deg[y] ++;
  }
  inline void topo() {
    queue <int> Q;
    for (int i = 1; i <= n; i ++)
      if (!deg[i]) Q.push(i);
    int x; tot = 0;
    while (!Q.empty()) {
      x = Q.front(); Q.pop();
      ord[++ tot] = x;
      travel(x, i) {
        deg[e[i].to] --;
        if (!deg[e[i].to]) Q.push(e[i].to);
      }
    }
  }
}

namespace Graph4 {
  struct edge {
    int nxt, to;
  } e[M];
  int fir[N], deg[N], cnt;
        
  inline void clear() {
    memset(fir, 0, sizeof fir);
    memset(deg, 0, sizeof deg);
    cnt = 0;
  }
  inline void add(int x, int y) {
    e[++ cnt] = (edge){fir[x], y};
    fir[x] = cnt;
    deg[y] ++;
  }
  inline bool topo() {
    queue <int> Q;
    for (int i = 1; i <= n; i ++)
      if (!deg[i]) Q.push(i);
    int x;
    while (!Q.empty()) {
      x = Q.front(); Q.pop();
      travel(x, i) {
        deg[e[i].to] --;
        if (!deg[e[i].to]) Q.push(e[i].to);
      }
    }
    for (int i = 1; i <= n; i ++)
      if (deg[i] && Graph1 :: dis[i] + Graph2 :: dis[i] <= Graph1 :: dis[n] + k) return 0;
    return 1;
  }
}

int x[M], y[M], l[M];

inline void modadd(int &x, int y) {
  if ((x += y) >= mod) x -= mod;
}

using namespace Graph1;

inline void solve(int T) {
  clear();
  Graph2 :: clear();
  Graph3 :: clear();
  Graph4 :: clear();
  read(n); read(m); read(k); read(mod);
  for (int i = 1; i <= m; i ++) {
    read(x[i]); read(y[i]); read(l[i]);
    add(x[i], y[i], l[i]);
    Graph2 :: add(y[i], x[i], l[i]);
  }
  dijkstra();
  Graph2 :: dijkstra();
  for (int i = 1; i <= m; i ++) {
    if (dis[x[i]] == -1 || Graph2 :: dis[y[i]] == -1) continue;
    if (dis[x[i]] + l[i] == dis[y[i]]) Graph3 :: add(x[i], y[i]);
    if (l[i] == 0) Graph4 :: add(x[i], y[i]);
  }
  if (Graph4 :: topo() == 0) return (void)puts("-1");
  Graph3 :: topo();
  memset(ans, 0, sizeof ans);
  ans[1][0] = 1;
  int w, xx, g = Graph3 :: tot;
  for (int i = 0; i <= k; i ++) {
    for (int j = 1; j <= g; j ++) {
      xx = Graph3 :: ord[j];
      if (dis[xx] == -1) continue;
      travel(xx, p) {
        w = dis[xx] + i + e[p].len - dis[e[p].to];
        if (0 <= w && w <= k) modadd(ans[e[p].to][w], ans[xx][i]);
      }
    }
  }
  int Ans = 0;
  for (int i = 0; i <= k; i ++) modadd(Ans, ans[n][i]);
  printf("%d\n", Ans);
}

int main() {
  int T;
  read(T);
  while (T --) solve(T);
  return 0;
}