洛谷P3953 逛公园【记忆化搜索】

题目描述

策策同学特别喜欢逛公园。公园可以看成一张$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 $行，每行一个整数代表答案。

说明

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

测试点编号	$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$
数据保证：至少存在一条合法的路线。

---

题目分析

用$d[u]$表示1到u的最短路
用$dp[u][k]$表示1到u长度不超过$d[u]+k$的路径总数

记搜时需要在反向图上跑
若$d[u]+k-dis(u,v_i)-d[v_i]>=0$
则$dp[u][k]+=dp[v_i][d[u]+k-dis(u,v_i)-d[v_i]]$
当$u==1$时，令$dp[u][k]=1$

对于判0环
只要在记搜时用栈判断就好
向下搜索前先记录二元组$(u,k)$入栈
若在搜索中遇到当前二元组已在栈中，则可判定有0环

---

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<vector>
using namespace std;
typedef long long lt;

int read()
{
    int x=0,f=1;
    char ss=getchar();
    while(ss<'0'||ss>'9'){if(ss=='-')f=-1;ss=getchar();}
    while(ss>='0'&&ss<='9'){x=x*10+ss-'0';ss=getchar();}
    return x*f;
}

const int maxn=100010;
int t,n,m,k,p;
struct node{int v,dis,nxt;}E[2][maxn<<1];
int head[2][maxn],tot[2];
int d[maxn],vis[maxn];
priority_queue< pair<int,int> > q;
int dp[maxn][55],ins[maxn][55];

void add(int u,int v,int dis,int d)
{
    E[d][++tot[d]].nxt=head[d][u];
    E[d][tot[d]].v=v; E[d][tot[d]].dis=dis;
    head[d][u]=tot[d]; 
}

void dij()
{
    memset(vis,0,sizeof(vis));
    memset(d,111,sizeof(d)); d[1]=0;
    q.push(make_pair(0,1));
    
    while(!q.empty())
    {
        int u=q.top().second; q.pop();
        if(vis[u]) continue;
        vis[u]=1;
        for(int i=head[0][u];i;i=E[0][i].nxt)
        {
            int v=E[0][i].v,dis=E[0][i].dis;
            if(d[v]>d[u]+dis)
            {
                d[v]=d[u]+dis;
                q.push( make_pair(-d[v],v) );
            }
        }
    }
}

int DP(int u,int tk)
{
    if(ins[u][tk]) return -1;
    if(dp[u][tk]) return dp[u][tk];
    ins[u][tk]=1;
    if(u==1) dp[u][tk]=1;
    for(int i=head[1][u];i;i=E[1][i].nxt)
    {
        int v=E[1][i].v,dis=E[1][i].dis;
        if(d[u]+tk-dis-d[v]>=0)
        {
            int tt=DP(v,d[u]+tk-dis-d[v]);
            if(tt==-1) return dp[u][tk]=-1;
            dp[u][tk]=(dp[u][tk]+tt)%p;
        }
    }
    ins[u][tk]=0;
    return dp[u][tk];
}

void init()
{
    tot[0]=tot[1]=0;
    memset(head,0,sizeof(head));
    memset(dp,0,sizeof(dp));
    memset(ins,0,sizeof(ins));
}

int main()
{
    t=read();
    while(t--)
    {
    	n=read();m=read();k=read();p=read();
    	init();
    	for(int i=1;i<=m;++i)
    	{
    		int u=read(),v=read(),dis=read();
    		add(u,v,dis,0); add(v,u,dis,1);
        }
        dij(); 
        printf("%d\n",DP(n,k));
    }
    return 0;
}