逛公园 [NOIP2017 D1T3] [记忆化搜索]

Description

策策同学特别喜欢逛公园。公园可以看成一张N个点M条边构成的有向图，且没有自环和重边。其中1号点是公园的入口，N号点是公园的出口，每条边有一个非负权值，代表策策经过这条边所要花的时间。

策策每天都会去逛公园，他总是从1号点进去，从N号点出来。

策策喜欢新鲜的事物，他不希望有两天逛公园的路线完全一样，同时策策还是一个特别热爱学习的好孩子，他不希望每天在逛公园这件事上花费太多的时间。如果1号点到N号点的最短路长为d，那么策策只会喜欢长度不超过d+K的路线。

策策同学想知道总共有多少条满足条件的路线，你能帮帮他吗? 为避免输出过大，答案对P取模。如果有无穷多条合法的路线，请输出−1。

Input

第一行包含一个整数 T, 代表数据组数。接下来T组数据，对于每组数据：

第一行包含四个整数 N，M，K，P，每两个整数之间用一个空格隔开。

接下来M行，每行三个整数ai，bi，ci，代表编号为ai、bi的点之间有一条权值为ci的有向边，每两个整数之间用一个空格隔开。

Output

包含T行，每行一个整数代表答案。

Sample Input

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

Sample Output

3
-1

说明

【样例解释1】

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

【测试数据与约定】

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

测试点编号	TT	NN	MM	KK	是否有0边
1	5	5	10	0	否
2	5	1000	2000	0	否
3	5	1000	2000	50	否
4	5	1000	2000	50	否
5	5	1000	2000	50	否
6	5	1000	2000	50	是
7	5	100000	200000	0	否
8	3	100000	200000	50	否
9	3	100000	200000	50	是
10	3	100000	200000	50	是

数据保证：至少存在一条合法的路线。

分析
我真的是太弱了，考场上写了一个A星，结果过的全是K=0的,然后就只有30分了(t1t2已让我心态爆炸)

我们看数据，K≤50，我们可以比较容易地想到dp，如何设状态？

我们记dis[u]为u点到n的最短路，我们走完一条方案希望整个距离不超过dis[1]+K

那我们就记录下到每个点的剩余额度rem，我们希望剩余额度尽可能大，就有更多精力走更多的路

　　对于一条边edge(u,v,val)

　　如果不走这条边，从u出发的最小代价为dis[u]（记录最小代价就是为了剩余额度尽可能大，到下个路口有更多的选择）

　　如果我们走了这条边，从u出发的最小代价为val+dis[v]

　　那么剩余额度就是rem-(dis[v]+val-dis[u])，如果(dis[v]+val-dis[u])>rem　此方案无效

那么我们看出来方案数和当前所在的点u和剩余额度rem有关，那么我们记录方案数为dp[u][rem]，根据上面分析可以知道dp[u][rem]+=dp[v][rem-(dis[v]+val-dis[u])]，记忆化搜索即可。

到了终点不论剩余额度是多少，一开始给了k的额度，只要最后的额度≥0即可。

如何对付0边？记录下状态vis[u][rem]即可，如果再次访问就返回-1

代码

 #include<set>

 #include<map>

 #include<queue>

 #include<stack>

 #include<cmath>

 #include<cstdio>

 #include<cstring>

 #include<iostream>

 #include<algorithm>

 #define RG register int

 #define rep(i,a,b)    for(RG i=a;i<=b;++i)

 #define per(i,a,b)    for(RG i=a;i>=b;--i)

 #define ll long long

 #define inf (1<<29)

 #define maxn 100005

 #define maxm 200005

 #define add(x,y,z) e[++cnt]=(E){y,head[x],z},head[x]=cnt

 using namespace std;

 int T,n,m,K,p,cnt,ans,flg;

 int head[maxn],vis[maxn][],dp[maxn][],dis[maxn];

 struct E{

     int v,next,val;

 }e[maxm];

 inline int read()

 {

     int x=,f=;char c=getchar();

     while(c<''||c>''){if(c=='-')f=-;c=getchar();}

     while(c>=''&&c<=''){x=x*+c-'';c=getchar();}

     return x*f;

 }

 void init()

 {

     memset(head,,sizeof(head));

     memset(dis,,sizeof(dis));

     memset(vis,,sizeof(vis));

     memset(dp,,sizeof(dp));

     cnt=ans=flg=;

 }

 inline int mod(int a){return a>=p?a-p:a;}

 namespace PRE{

 int head[maxn],vis[maxn],cnt;

 struct E{

     int v,next,val;

 }e[maxm];

 void ad(int x,int y,int z) {e[++cnt]=(E){y,head[x],z},head[x]=cnt;}

 void init(){memset(head,,sizeof(head));cnt=;}

 void spfa()

 {

     queue<int> que;que.push(n),dis[n]=;

     RG u,v;

     while(!que.empty())

     {

         u=que.front(),que.pop();

         for(RG i=head[u];i;i=e[i].next)

         {

             v=e[i].v;

             if(dis[v]>dis[u]+e[i].val)

             {

                 dis[v]=dis[u]+e[i].val;

                 if(!vis[v])    vis[v]=,que.push(v);

             }

         }

         vis[u]=;

     }

 }

 }

 int dfs(int u,int rem)

 {

     if(dp[u][rem])    return dp[u][rem];

     if(vis[u][rem])    return dp[u][rem]=-;

     vis[u][rem]=-;

     int res,v,ret;

     if(u==n)    dp[u][rem]=;

     for(int i=head[u];i;i=e[i].next)

     {

         v=e[i].v;

         res=dis[v]+e[i].val-dis[u];

         if(res>rem)    continue;

         if((ret=dfs(v,rem-res))==-)    return dp[u][rem]=-;

         dp[u][rem]=mod(ret+dp[u][rem]);

     }

     vis[u][rem]=;

     return dp[u][rem];

 }

 int main()

 {

     freopen("data7.in","r",stdin);

     T=read();

     while(T--)

     {

         init();PRE::init();

         n=read(),m=read(),K=read(),p=read();

         for(RG i=,u,v,val;i<=m;i++) u=read(),v=read(),val=read(),add(u,v,val),PRE::ad(v,u,val);

         PRE::spfa();

         memset(vis,,sizeof(dp));

         ans=dfs(,K);printf("%d\n",ans);

     }

     return ;

 }