NOIP2017Day1T3-逛公园

3. 逛公园

(park.cpp/c/pas)

题目描述

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

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

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

策策同学想知道总共有多少条满足条件的路线，你能帮帮它吗？

为避免输出过大，答案对$P$ 取模。

如果有无穷多条合法的路线，请输出−1。

输入输出格式

输入格式：

第一行包含一个整数 $T$ , 代表数据组数。

接下来$T$ 组数据，对于每组数据： 第一行包含四个整数 $N,M,K,P$ ，每两个整数之间用一个空格隔开。

接下来$M$ 行，每行三个整数$a_i,b_i,c_i$ ，代表编号为$a_i,b_i$ 的点之间有一条权值为 $c_i$ 的有向边，每两个整数之间用一个空格隔开。

输出格式：

输出文件包含 $T$ 行，每行一个整数代表答案。

【输入输出样例 1】

park.in
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

park.out

3

-1

见选手目录下的 park/park1.in 和 park/park1.ans。对于第一组数据，最短路为 3。

1 – 5, 1 – 2 – 4 – 5, 1 – 2 – 3 – 5 为 3 条合法路径。

【输入输出样例 2】

见选手目录下的 park/park2.in 和 park/park2.ans。

【数据规模与约定】

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

测试点编号	$T$	$N$	$M$	$K$	是否有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	是

对于 100%的数据, $1\le P\le 10^9,1\le a_i,b_i\le N,0\le c_i\le 1000$ 。

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

应该说是不太难的一道题。可惜我当时太菜啊，SPFA写挂了，dp没想出来，最后硬拿10分。往事不堪回首……

看看这道题，首先用跑一遍SPFA，求dis[i]表示1到i的最短路长度（这一步应该每个人都会除了我） 

然后就看见了dp。设f[i][j]表示从1到i的所有路径里，比dis[n]大j的路径条数。 

所以有f[i][j]=∑f[k][dis[i]−dis[k]+j−len[i][k]]（k是i所指向的所有的边）

所以我们从n开始倒着搜索，若dis[i]−dis[k]+j−len[i][k]＜0当然就跳过

并且若f[x][y]这个状态在一遍dfs里出现两次，那就是有0环，输出-1就好，开个数组标记。

最后ans=∑(0≤i≤k)f[n][i]。可以卡过。

Code:

#include<iostream>
#include<cstring>
#include<cstdio>
#include<queue>
#define N 200005
using namespace std;
int tot,head[N],Head[N],dis[N],b[N];
int f[N][55],flag[N][55],blog,n,m,p,k;
queue<int>Q;
struct edge
{
	int vet,next,len,Vet,Next,Len;
}edge[N];
int inline read()
{
	int x=0,f=1;char s=getchar();
	while(s<'0'||s>'9'){if(s=='-')f=-1;s=getchar();}
	while(s<='9'&&s>='0'){x=x*10+s-'0';s=getchar();}
	return x*f;
}
void add(int u,int v,int len)
{
	edge[++tot].vet=v;
	edge[tot].next=head[u];
	head[u]=tot;
	edge[tot].len=len;
	edge[tot].Vet=u;
	edge[tot].Next=Head[v];
	Head[v]=tot;
	edge[tot].Len=len;
}
int dfs(int x,int k)
{
	if(~f[x][k])return f[x][k];
	flag[x][k]=true;f[x][k]=0;
	for(int i=Head[x];i;i=edge[i].Next)
	{
		int v=edge[i].Vet;
		int t=dis[x]-dis[v]+k-edge[i].Len;
		if(t<0)continue;
		if(flag[v][t])blog=true;
		f[x][k]=(f[x][k]+dfs(v,t))%p;
	}
	flag[x][k]=false;
	return f[x][k];
}
int main()
{
	int T=read();
	while(T--)
	{
		n=read(),m=read(),k=read(),p=read();
		tot=0;
		memset(head,0,sizeof(head));
		memset(Head,0,sizeof(Head));
		for(int i=1;i<=m;i++)
		{
			int x=read(),y=read(),z=read();
			add(x,y,z);
		}
		memset(b,true,sizeof(b));
		memset(dis,0x3f,sizeof(dis));
		dis[1]=0,b[1]=false;Q.push(1);  
        while(!Q.empty())  
        {  
            int k=Q.front();  
            Q.pop();  
            b[k]=true;  
            for(int i=head[k];i;i=edge[i].next)  
            {  
                int v=edge[i].vet;  
                if(dis[v]>dis[k]+edge[i].len)  
                {  
                    dis[v]=dis[k]+edge[i].len;  
                    if(b[v])  
                    {  
                        b[v]=false;  
                        Q.push(v);  
                    }  
                }  
            }  
        }
		blog=false;
		memset(f,-1,sizeof(f));
		memset(flag,false,sizeof(flag));
		f[1][0]=1;int ans=0;
		for(int i=0;i<=k;i++)ans=(ans+dfs(n,i))%p;
		if(blog)puts("-1");else printf("%d\n",ans);
	}
	return 0;
}