洛谷3953 逛公园

主要思路：记忆化搜索，最短路

观察数据范围发现K规模较小，可以当做状态

N值较大，使用前向星链式存边

无限种方案，简单的分析可以得到：

如果没有回路（环），在不考虑路程的情况下只有有限的方案

在有回路的情况下，积累路径权，仍然是有限的方案

综上无限方案是路径长度为0组成的环

两组dfs，void dfs0(long long int x)用作查找0环，dfs(int x,int sum)查找方案； 正反两遍迪杰斯特拉，方便剪枝和查找0环。

在dfs0的扩展状态中，只有边权为0，且距离点1距离相等才扩展状态。

以下巨长奇丑代码

#include 
#include 
#include 
#include 
#define ce cout<
using namespace std;
const long long int maxn=100001,maxm=200001,INF=2002102020;
const long long int NONE=0;
long long int en,T,n,m,e0,x,y,l,k,p;
long long int head[maxn],mdis[maxn],mdisf[maxn],ans,mlen,last[maxn+2][55];
bool vis[maxn],v0[maxn],fl;
int qread(){
    int x=0;char ch=getchar();
     while(ch>'9'||ch<'0')ch=getchar();
     while('0'<=ch&&ch<='9'){
        x=x*10+ch-'0';
        ch=getchar();
     }
    return x;
}//读入优化
struct edg{
    int fr,to,len,nxt;
};
edg e[maxm];
void adg( long long int x, long long int y, long long int l){
    en++;
    e[en].fr=x;e[en].to=y;e[en].len=l;
    e[en].nxt=head[x];
    head[x]=en;
}//添加边
void dfs0( long long int x){
    if(fl)return;
    //cout<
    if(mdisf[x]==INF)return;
    if(!v0[x]){
        fl=true;//fl标记是否有零环，当某结点两次被查找时，它处在一个零环
        return;
    }
    v0[x]=false;
    //值得注意的是，如果零环无法到达，那么它不会影响结果。因此若距离是无穷大，则无须扫描
    for( long long int i=head[x];i>0;i=e[i].nxt){
        if(e[i].len||(mdis[x]!=mdis[e[i].to]))continue;
        //if(v0[e[i].to]){
            dfs0(e[i].to);

        //}
    }
    v0[x]=true; 
}
void dfs( long long int x,long long int sum){
    if(sum-mdis[x]<0||sum-mdis[x]>50) return;
    //记忆化搜索，如果曾经搜到这个状态，直接ans+对应值
    if(sum+mdisf[x]>mlen)return;
    if(sum-mdis[x]>k)return;
    //mdis，mdisf分别存储1-i，n-i的最短路。
    if(sum-mdis[x]>=0&&sum-mdis[x]<=50)
    if(last[x][sum-mdis[x]]>-1){
        ans=(last[x][sum-mdis[x]]+ans)%p;
        return;
    }

    int rec=ans;
    if(x==n)ans=(ans+1)%p;
    //cout<
     for(int i=head[x];i>0;i=e[i].nxt){
        dfs(e[i].to,sum+e[i].len);
     }
     last[x][sum-mdis[x]]=(ans-rec)%p;
     //新增的ans值就是记忆化数组中的存储
}
 int main(){
 // freopen("3953_tle.txt","r",stdin);
     T=qread();
      while(T--){
        ans=0;
        fl=false;
        en=e0=0;
         n=qread();m=qread();k=qread();p=qread();

         memset(head,-1,sizeof(head));
         memset(mdis,0x3f,sizeof(mdis));
         memset(vis,1,sizeof(vis));
         memset(v0,1,sizeof(v0));
          for(int i=1;i<=m;i++){
            x=qread();y=qread();l=qread();
            adg(x,y,l);
             }  
            mdis[1]=0;
            int f=0;
            while(f//正向求最短路
                f++;
                int minn=INF,t;
                 for(int i=1;i<=n;i++){
                    if((mdis[i]false;
                 for(int i=head[t];i>0;i=e[i].nxt){
                    if(vis[e[i].to]&&(e[i].len+minn0;
            memset(head,-1,sizeof(head));
            for(int i=1;i<=m;i++){
                adg(e[i].to,e[i].fr,e[i].len);
            }//把所有边翻转
            for(int i=1;i<=n;i++){
                mdisf[i]=INF;vis[i]=true;
            }
            mdisf[n]=0;
             f=1;//反向求最短路
            while(fint minn=INF,t;
                for(int i=1;i<=n;i++){
                if(vis[i]&&(mdisf[i]false;
               for(int i=head[t];i>0;i=e[i].nxt)
                 if(vis[e[i].to]&&mdisf[e[i].to]>minn+e[i].len)mdisf[e[i].to]=minn+e[i].len;

            }
          for(int i=1;(i<=n)&&(!fl);i++){
            if((mdis[i]!=INF)&&(mdisf[i])!=INF){
                 dfs0(i);
                 //cout<
              }
          }
          if(fl){
            cout<<-1<continue;
          }
         en=0;
          memset(head,-1,sizeof(head));
         for(int i=1;i<=m;i++){
            adg(e[i].to,e[i].fr,e[i].len);
        }
        mlen=mdis[n]+k;
        memset(last,-1,sizeof(last));
        dfs(1,0);
        cout<return 0;
 }