[NOIP2017 提高组] 逛公园

[NOIP2017 提高组] 逛公园

题目描述

策策同学特别喜欢逛公园。公园可以看成一张 $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

样例输入 #1

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

样例输出 #1

3
-1

提示

【样例解释1】

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

【测试数据与约定】

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

测试点编号	$T$	$N$	$M$	$K$	是否有 $0$ 边
$1$	$5$	$5$	$10$	$0$	否
$2$	$5$	$10^3$	$2\times 10^3$	$0$	否
$3$	$5$	$10^3$	$2\times 10^3$	$50$	否
$4$	$5$	$10^3$	$2\times 10^3$	$50$	否
$5$	$5$	$10^3$	$2\times 10^3$	$50$	否
$6$	$5$	$10^3$	$2\times 10^3$	$50$	是
$7$	$5$	$10^5$	$2\times 10^5$	$0$	否
$8$	$3$	$10^5$	$2\times 10^5$	$50$	否
$9$	$3$	$10^5$	$2\times 10^5$	$50$	是
$10$	$3$	$10^5$	$2\times 10^5$	$50$	是

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

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

---

• 2019.8.30 增加了一组 hack 数据 by @skicean
• 2022.7.21 增加了一组 hack 数据 by @djwj233

思路

1.首先用spfa求出1到每一点的最短路径，当然也可以用dijkstra。
不懂spfa的可以点这里

2.策策走的路径长度不会超过最短路径+看，所以我们可以枚举0到k,k的范围很小，不会超时。

3.枚举从0到k，从n开始跑反向图，这样就不会跑到些不能到达n的路径，每反向跑一条路径，并计算一次k还剩下多少可以跑，没有剩余并刚好反向跑到了1，则说明这条路是一个解，ans++(这里如果看不懂就看代码注释，画个图就能理解了）。

4.我们还要避免0环的情况，因为题目只说了权值是非负数，所以会有权值为0的情况，为0且又是环，可以跑无数次，这就很停不下了，所以我们可以用一个数组去记录该点是否以跑过，跑过了就不要重复跑了。

5.最后就是记忆搜索了，减少时间复杂度，用一个f数组存储，f[i][j]表示从n到i的距离<最短距离+k的方案数。

接下来看代码吧，注释比较详细了，参考了洛谷一位大佬的代码！

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+5;
int t,d[N],f[N][51],n,m,k,p; //f数组是用来记忆存储的 
bool working[N][51],vis[N];
struct node{
	int to,len;
}; 
vector<node>head[N]; //正向存图 
vector<node>h[N];  //方向存图 

//方向跑是因为可以减少跑死胡同的情况增加效率 ，一些不能到达n的路径就可以不用跑了 
int dp(int root,int l)  //root表示到哪个点了，l表示当前的k还有多少剩余 
{                        
	int ans=0;
	if(l<0||l>k) return 0;  //这种情况不符合题意 
	if(working[root][l])   //working数组是为了判断'0'环的情况，如果不判断会MLT 
	{                      //如果该点在此路径上跑过了，就可以跳出来了 
		working[root][l]=false;  //标记回去，下一条路径了 
		return -1;
	}
	if(f[root][l]!=-1)    //记忆搜索，已经搜过了就直接返回 
	return f[root][l];
	working[root][l]=true; //标记已经跑过 
	for(auto i:h[root])    //跑反图 
	{
		int val=dp(i.to,d[root]+l-d[i.to]-i.len);//d[root]+l-d[i.to]-i.len表示用当前这条边替换最短路径里的一条边，建议自己画图理解一下 
		if(val==-1)  //有环的情况 
		{
			working[root][l]=false;
			return -1;
		}
		ans=(ans+val)%p;
	}
	working[root][l]=false;
	if(root==1&&l==0) ans++; //只有root=1，l=0才是一个解 
	f[root][l]=ans;  //记录答案 
	return ans;
}
void solve()
{
	cin>>n>>m>>k>>p;
	for(int i=1;i<=n;i++)
	{
		head[i].clear();
		h[i].clear();
	}
	int u,v,w;
	for(int i=1;i<=m;i++)
	{
		cin>>u>>v>>w;
		node e;
		e.to=v;
		e.len=w;
		head[u].push_back(e); //正向存图 
		e.to=u;
		h[v].push_back(e);  //反向存图 
		
	}
	memset(d,0x3f,sizeof d);  //初始化 
	memset(f,-1,sizeof f);
	queue<int>q;            //sfpa求最短路径，没有负环的情况，所以不用判断负环 
	q.push(1),d[1]=0;
	vis[1]=1;
	while(q.size())
	{
		int x=q.front();
		q.pop();
		vis[1]=0;
		for(auto i:head[x])
		{
			if(d[i.to]>d[x]+i.len)  
			{
				d[i.to]=d[x]+i.len;
				if(!vis[i.to])
				vis[i.to]=1,q.push(i.to);    
			}
		}
	}
	int ans=0;
	for(int i=0;i<=k;i++)
	{
		int val=dp(n,i);
		if(val==-1) 
		{
			cout<<-1<<"\n";
			return;
		}
		ans=(ans+val)%p;
	}
	cout<<ans<<"\n";
}
int main()
{
	cin>>t;
	while(t--) solve();
	return 0;
}