最短路+拓扑排序+dp NOIP 2017 逛公园

让我们一起来%forever_shi神犇

题意：
给你一个$n$个点$m$条边的有向带权图，设$1$号点到$n$号点的最短路是$dis$，给你一个$k(k<=50)$，求所有$1$到$n$的路径中长度不超过$dis+k$的数量。

题解：
显然我们要先处理出最短路，如果$k=0$，就是最短路计数了。要做计数，我们不难想到要在图上$dp$。我们发现只要有一个边权全部是$0$的环，那么我们的满足题意的路径就会有无数条，因为可以在环里转任意多圈之后再出来。那么我们要判断是否有无穷多解就是去找有没有全部是$0$的环。

我们可以先处理出一个最短路图，最短路图的含义是由所有$dis[x]+w[x][y]=dis[y]$的边连成的图，最短路图的一个性质：如果边权都是正数，那么最短路图是一个DAG。DAG是可以拓扑排序的，如果最后每个点入度都是$0$，就不存在权值全是$0$的环，否则就是有权值全是$0$的环，因为权值是$0$的边一定不会让两点之间的最短路变长，所以其就一定会在最短路图上，而形成环的话是没法有其中某一个点的入度是$0$，因此判断拓扑排序后的入度即可。

对图拓扑排序后根据图的拓扑序在DAG上$dp$也是一个经典套路，这里我们就会采用这个套路。我们设$dp[i][j]$表示对于点$i$比$dis[i]$大$j$的路径数，那么对于路径$x->y$，状态转移方程即为：$dp[y][j+w(x,y)-(dis[y]-dis[x])]+=dp[x][j]$。

那么我们枚举$j$，然后按照拓扑序枚举$x$，再枚举从$x$出发的所有边，进行$dp$。注意外层是枚举$j$，因为在$dp$的过程中如果外层枚举$x$的话DAG上是没有环的，但是这里的边是枚举原图的边，所以可能之后会有环再回到$x$，得到答案就是错误的了。还有就是这个$dp$看似枚举的层数很多，但是其实复杂度并不高，因为所有边都只会被枚举到一次，所有点都只会被枚举$k+1(0到k)$次，所以总的复杂度是$O(n\ast k)$的。

最后答案就是${\sum }_{i=0}^{k}dp[n][i]了$

(吸氧苟过去QAQ)

#include<bits/stdc++.h>
#define ll long long
#define rint register int
using namespace std;
const int maxn=201000;
struct node
{
    int next,to,dis,from;
}e[maxn],a[maxn];
int head[maxn],head1[maxn],num,num1,i;
int dis[maxn],n,m,T,K,p,rd[maxn],numm[maxn];
int que[maxn],ji,u,v,d;
ll dp[200200][55],ans;
bool book[maxn];
priority_queue<pair<int,int> > q;
int read()
{
    int x=0,y=1;
    char c;
    c=getchar();
    while((c<'0'||c>'9')&&c!='0')
    c=getchar();
    if(c=='-')
    {
        y=-1;
        c=getchar();
    }
    while(c>='0'&&c<='9')
    {
        x=(x<<1)+(x<<3)+c-'0';
        c=getchar();
    }
    return x*y;
}
void add(int from,int to,int dis)
{
    e[++num].next=head[from];
    e[num].to=to;
    e[num].from=from;
    e[num].dis=dis;
    head[from]=num;
}
void add1(int from,int to,int dis)
{
    a[++num1].next=head1[from];
    a[num1].to=to;
    a[num1].dis=dis;
    head1[from]=num1;
}
void dij(int s)
{
    for(rint i=1;i<=n;++i)
        dis[i]=999999999;
    dis[s]=0;
    q.push(make_pair(0,s));
    while(!q.empty())
    {
        int x=q.top().second;
        q.pop();
        if(book[x])
            continue;
        book[x]=1;
        for(rint i=head[x];i;i=e[i].next)
        {
            int v=e[i].to;
            if(dis[v]>dis[x]+e[i].dis)
            {
                dis[v]=dis[x]+e[i].dis;
                q.push(make_pair(-dis[v],v));
            }
        }
    }
}
void topsort()
{
    int h=1,t=0;
    for(rint i=1;i<=n;++i)
        if(!rd[i])
            que[++t]=i;
    while(h<=t)
    {
        int x=que[h];
        numm[++ji]=x;
        for(rint i=head1[x];i;i=a[i].next)
        {
            int v=a[i].to;
            rd[v]--;
            if(!rd[v])
                que[++t]=v;
        }
        h++;
    }
}
int main()
{
    cin>>T;
    while(T--)
    {
        memset(book,0,sizeof(book));
        memset(head,0,sizeof(head));
        memset(head1,0,sizeof(head1));
        memset(a,0,sizeof(a));
        memset(e,0,sizeof(e));
        memset(rd,0,sizeof(rd));
        memset(dp,0,sizeof(dp));
        memset(numm,0,sizeof(numm));
        memset(que,0,sizeof(que));
        num=0,num1=0,ji=0,ans=0;
        bool flag=0;
        scanf("%d%d%d%d",&n,&m,&K,&p);
        int u,v,d;
        for(rint i=1;i<=m;++i)
        {
            u=read();
            v=read();
            d=read();
            add(u,v,d);
        }
        dij(1);
        for(rint i=1;i<=num;++i)
        {
            if(dis[e[i].from]+e[i].dis==dis[e[i].to])
            {
                add1(e[i].from,e[i].to,e[i].dis);
                rd[e[i].to]++;
            }	
        }
        topsort();
        for(rint i=1;i<=n;++i)
            if(rd[i])
            {
                flag=1;
                break;
            }
        if(flag)
        {
            printf("-1\n");
            continue;
        }
        dp[1][0]=1;
        for(rint k=0;k<=K;++k)
            for(rint i=1;i<=n;++i)
            {
                int x=numm[i];
                for(rint j=head[x];j;j=e[j].next)
                {
                    int v=e[j].to;
                    int len=k+e[j].dis-(dis[v]-dis[x]);
                    if(len<=K)
                        dp[v][len]=(dp[x][k]+dp[v][len])%p;
                }
            }
        for(rint i=0;i<=K;++i)
            ans=(ans%p+dp[n][i]%p)%p;
        printf("%d\n",ans);
    }
    return 0;
}