[NOIp2017提高组]逛公园

题目大意：
　　给你一个有向图，若用dis(u,v)表示从u到v的最短路长度，求从1到n的长度不超过dis(1,n)+k的路径数。

思路：
　　首先分别预处理出以1,n为起点的单、源最短路。
　　对于合法的边重构图，然后拓扑排序判环，
　　BFS时判断一下当前点是否在合法路径上，
　　如果最后一个点没有被搜到且在合法路径上，那么肯定是一个0环。
　　最后动态规划，f[i][j]表示长度为dis(1,i)+j的路径数量。

 #include<queue>
 #include<cstdio>
 #include<cctype>
 #include<vector>
 #include<cstring>
 #include<algorithm>
 #include<functional>
 #include<ext/pb_ds/priority_queue.hpp>
 inline int getint() {
     register char ch;
     while(!isdigit(ch=getchar()));
     register int x=ch^'';
     while(isdigit(ch=getchar())) x=(((x<<)+x)<<)+(ch^'');
     return x;
 }
 const int inf=0x7fffffff;
 const int N=,LIM=;
 int n,m,lim,mod;
 struct Edge {
     int to,w;
 };
 std::vector<Edge> e0[N],e1[N];
 inline void add_edge(const int &u,const int &v,const int &w) {
     e0[u].push_back((Edge){v,w});
     e1[v].push_back((Edge){u,w});
 }
 struct Vertex {
     int id,dis;
     bool operator > (const Vertex &another) const {
         return dis>another.dis;
     }
 };
 int dis0[N],dis1[N];
 inline void dijkstra(const int &s,int dis[],const std::vector<Edge> e[]) {
     static __gnu_pbds::priority_queue<Vertex,std::greater<Vertex> > q;
     static __gnu_pbds::priority_queue<Vertex,std::greater<Vertex> >::point_iterator p[N];
     for(register int i=;i<=n;i++) {
         p[i]=q.push((Vertex){i,dis[i]=i==s?:inf});
     }
     while(!q.empty()&&q.top().dis!=inf) {
         const int x=q.top().id;
         q.pop();
         for(register unsigned i=;i<e[x].size();i++) {
             const int &y=e[x][i].to,&w=e[x][i].w;
             if(dis[x]+w<dis[y]) {
                 q.modify(p[y],(Vertex){y,dis[y]=dis[x]+w});
             }
         }
     }
     while(!q.empty()) q.pop();
 }
 std::vector<int> top;
 inline bool check() {
     static int deg[N];
     static std::queue<int> q;
     memset(deg,,sizeof deg);
     for(register int x=;x<=n;x++) {
         for(register unsigned i=;i<e0[x].size();i++) {
             const int &y=e0[x][i].to,&w=e0[x][i].w;
             if(dis0[x]+w==dis0[y]) deg[y]++;
         }
     }
     for(register int x=;x<=n;x++) {
         if(!deg[x]) q.push(x);
     }
     while(!q.empty()) {
         const int x=q.front();
         q.pop();
         top.push_back(x);
         for(register unsigned i=;i<e0[x].size();i++) {
             const int &y=e0[x][i].to,&w=e0[x][i].w;
             if(dis0[x]+w!=dis0[y]) continue;
             if(!--deg[y]) q.push(y);
         }
     }
     for(register int x=;x<=n;x++) {
         if(deg[x]&&dis0[x]+dis1[x]<=dis0[n]+lim) return false;
     }
     return true;
 }
 inline int calc() {
     static int f[N][LIM];
     memset(f,,sizeof f);
     f[][]=;
     for(register int k=;k<=lim;k++) {
         for(register unsigned i=;i<top.size();i++) {
             const int &x=top[i];
             if(!f[x][k]) continue;
             for(register unsigned i=;i<e0[x].size();i++) {
                 const int &y=e0[x][i].to,&w=e0[x][i].w;
                 if(dis0[x]+k+w<=dis0[y]+lim) {
                     (f[y][dis0[x]+k+w-dis0[y]]+=f[x][k])%=mod;
                 }
             }
         }
     }
     int ans=;
     for(register int i=;i<=lim;i++) {
         ans=(ans+f[n][i])%mod;
     }
     return ans;
 }
 inline void reset() {
     for(register int i=;i<=n;i++) {
         e0[i].clear();
         e1[i].clear();
     }
     top.clear();
 }
 int main() {
     for(register int T=getint();T;T--) {
         n=getint(),m=getint(),lim=getint(),mod=getint();
         while(m--) {
             const int u=getint(),v=getint(),w=getint();
             add_edge(u,v,w);
         }
         dijkstra(,dis0,e0);
         dijkstra(n,dis1,e1);
         printf("%d\n",check()?calc():-);
         reset();
     }
     return ;
 }