noip2017 逛公园

洛谷P3953

loj2316

uoj331

做题记录：

花了3个小时写了个5K代码（如果是noip现场肯定时间不够了），本地跑大样例跑3秒一组？

结果交上去一看70分，最慢点800ms左右，所有有0边的都错了？

然而事实上这代码这么长大部分就是为了特判0边。。。看来即使noip发现码量不对也要尽快放弃

下数据一测...单组数据就A了？

调了1个小时，终于调出来了，就改了一行...

错误记录：241行上界错误，t2[0]写成n

---

自己的(假)做法：（说不定其实有错？）

先求最短路。设d[i]表示1到i的最短路

首先判-1。可以发现，如果存在一条从1到n过某点u的长度不超过d[n]+K的路径，且u在一个0环（由全0边组成的环）上面，就-1了，否则就不-1

（以上可以通过再求所有点到n最短路，以及对由仅保留0边得到的图做tarjan求强连通分量完成）

否则，考虑一个dp。an[i][j]表示到i点距离为d[i]+j的路径条数。跟最短路计数挺像。但是，可以发现转移顺序似乎有点问题？

考虑按j来划分“层”，尽量使得转移在层间进行，避免转移成环；要保证同层内按照转移的“拓扑序”进行；显然仅当d[u] + (u,v)边的长度 = d[v]时会发生u到v的同层转移

设(u,v)边的长度=dis(u,v)

首先，如果没有0权边，那么显然只要按照d[i]的值从小到大将各个点排序，同层内按这个顺序转移即可。因为此时如果d[u]+dis(u,v)=d[v]，那么d[u]<d[v]

如果有0权边，就不能这么干了。

对于任意两点u,v，它们间有边(u,v,w)，如果w>0，那么仍然满足上述条件；如果w=0，那么有两种情况：

1.d[u]>d[v]；此时u到v不可能发生同层转移

2.d[u]=d[v]；此时可能发生同层内转移，因此应当保证u在v之前转移

那么就明显了，对于d[i]相等的点，应该按照“只保留0边后的图的拓扑序中点的位置”从小到大排序

可是似乎不一定有这个拓扑序？首先，如果有一点满足u“存在一条从1到n过u的长度不超过d[n]+K的路径”，且u在一个0环上，那么就-1了，不用dp；如果u不满足这个条件，但u在一个0环上，那么可以不管这个u

设当且仅当'存在一条从1到n过u的长度不超过d[n]+K的路径'时，ok[u]=true；否则ok[u]=false

所以，“只保留0边后的图的拓扑序中点的位置”应该改为“只保留0边与所有满足ok[u]=true的点u后的图的拓扑序中点的位置”

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<vector>
#include<queue>
using namespace std;
#define fi first
#define se second
#define pb push_back
typedef long long ll;
typedef unsigned long long ull;
struct pii
{
    int fi,se;
    pii():fi(0),se(0){}
    pii(int a,int b):fi(a),se(b){}
};

bool operator<(const pii &a,const pii &b)
{
    return a.fi>b.fi;//||(a.fi==b.fi&&a.se<b.se);
}

/*
bool operator>(const pii &a,const pii &b)
{
    return a.fi<b.fi;//||(a.fi==b.fi&&a.se>b.se);
}
*/
typedef priority_queue<pii> pq;
struct E
{
    int to,d,nxt;
}e[200010];
int f1[100010],ne;
int n,m,K,md;
bool ok[100010];
//inline int mul(int x,int y){return ll(x)*y%md;}
//inline int add(int x,int y){return (x+y)%md;}
inline void add(int &x,int y){(x+=y)%=md;}
namespace OK
{

int dfn[100010],dfc;
int s[100010],tp;
int sccnum[100010],cnt;
int sz[100010];
int dfs(int u)
{
    int lowu=dfn[u]=++dfc,lowv,v,k;
    s[++tp]=u;
    for(k=f1[u];k;k=e[k].nxt)
        if(e[k].d==0)
        {
            v=e[k].to;
            if(!dfn[v])
            {
                lowv=dfs(v);
                lowu=min(lowu,lowv);
            }
            else if(!sccnum[v])
                lowu=min(lowu,dfn[v]);
        }
    if(lowu==dfn[u])
    {
        ++cnt;
        while(tp&&s[tp]!=u)    sccnum[s[tp--]]=cnt;
        sccnum[s[tp--]]=cnt;
    }
    return lowu;
}
void work()
{
    int i;
    dfc=0;tp=0;
    memset(dfn+1,0,sizeof(dfn[0])*n);
    memset(sccnum+1,0,sizeof(sccnum[0])*n);
    memset(sz+1,0,sizeof(sz[0])*cnt);
    cnt=0;
    for(i=1;i<=n;++i)
        if(!dfn[i])
            dfs(i);
    for(i=1;i<=n;++i)
        ++sz[sccnum[i]];
}

}
namespace Dij1
{

pq q;
int d[100010];
bool vis[100010];
void dij()
{
    int k,u,v;pii t;
    memset(d+1,0x3f,sizeof(d[0])*n);
    memset(vis+1,0,sizeof(vis[0])*n);
    q.push(pii(0,1));d[1]=0;
    while(!q.empty())
    {
        t=q.top();q.pop();
        u=t.se;
        if(vis[u])    continue;
        vis[u]=1;
        for(k=f1[u];k;k=e[k].nxt)
        {
            v=e[k].to;
            if(d[v]>d[u]+e[k].d)
            {
                d[v]=d[u]+e[k].d;
                q.push(pii(d[v],v));
            }
        }
    }
}

}
namespace Dij2
{

E e[200010];
int f1[100010],ne;
void me(int x,int y,int z)
{
    e[++ne].to=y;e[ne].nxt=f1[x];f1[x]=ne;e[ne].d=z;
}
pq q;
int d[100010];
bool vis[100010];
void dij()
{
    int k,u,v;pii t;
    memset(d+1,0x3f,sizeof(d[0])*n);
    memset(vis+1,0,sizeof(vis[0])*n);
    q.push(pii(0,n));d[n]=0;
    while(!q.empty())
    {
        t=q.top();q.pop();
        u=t.se;
        if(vis[u])    continue;
        vis[u]=1;
        for(k=f1[u];k;k=e[k].nxt)
        {
            v=e[k].to;
            if(d[v]>d[u]+e[k].d)
            {
                d[v]=d[u]+e[k].d;
                q.push(pii(d[v],v));
            }
        }
    }
}

}
namespace DP
{

int t2[100010];
namespace T
{

queue<int> q;
int in[100010];
void work()
{
    int i,k,u;
    memset(in+1,0,sizeof(in[0])*n);
    t2[0]=0;
    for(i=1;i<=n;++i)
        if(ok[i])
        {
            for(k=f1[i];k;k=e[k].nxt)
                if(ok[e[k].to]&&e[k].d==0)
                    ++in[e[k].to];
        }
    for(i=1;i<=n;++i)
        if(ok[i]&&!in[i])
            q.push(i);
    while(!q.empty())
    {
        u=q.front();q.pop();
        t2[++t2[0]]=u;
        for(k=f1[u];k;k=e[k].nxt)
            if(ok[e[k].to]&&e[k].d==0)
            {
                --in[e[k].to];
                if(!in[e[k].to])    q.push(e[k].to);
            }
    }
}

}
int ps[100010];
int t1[100010];
using Dij1::d;
bool c1(int a,int b)
{
    return d[a]<d[b]||(d[a]==d[b]&&ps[a]<ps[b]);
}
int an[100010][51];
namespace E2
{

E e[200100];
int f1[100010],ne;
void me(int x,int y,int z)
{
    e[++ne].to=y;e[ne].nxt=f1[x];f1[x]=ne;e[ne].d=z;
}
void work()
{
    int i,j,k,u,v,y;
    //printf("1t%d
",t1[1]);
    an[1][0]=1;
    for(j=0;j<=K;++j)
    {
        for(i=1;i<=t1[0];++i)
        {
            u=t1[i];
            for(k=f1[u];k;k=e[k].nxt)
            {
                v=e[k].to;
                if(d[u]+j+e[k].d<=d[v]+K)
                {
                    y=d[u]+j+e[k].d-d[v];
                    add(an[v][y],an[u][j]);
                }
            }
        }
    }
}

}
void dp()
{
    int i,j,k;
    memset(an+1,0,sizeof(an[0])*n);
    memset(ps+1,0,sizeof(ps[0])*n);
    T::work();
    for(i=1;i<=t2[0];++i)//
        ps[t2[i]]=i;
    t1[0]=0;
    for(i=1;i<=n;++i)
        if(ok[i])
            t1[++t1[0]]=i;
    sort(t1+1,t1+t1[0]+1,c1);
    memset(E2::f1+1,0,sizeof(E2::f1[0])*n);
    E2::ne=0;
    for(i=1;i<=n;++i)
        if(ok[i])
        {
            for(k=f1[i];k;k=e[k].nxt)
                if(ok[e[k].to])
                {
                    E2::me(i,e[k].to,e[k].d);
                }
        }
    E2::work();
    int ans=0;
    for(j=0;j<=K;++j)
        add(ans,an[n][j]);
    printf("%d
",ans);
}

}
/*
namespace DP
{

queue<int> q;
using Dij::d;
//点的定义：(i,j)表示从1走d[i]+j的距离到i
int an[100010][51];//an[i][j]表示到(i,j)的路径条数
bool vis[100010][51];
void dp()
{
    memset(vis+1,0,sizeof(vis[0])*n);
    memset(an+1,0,sizeof(an[0])*n);
    int x,u,v;
    while(!q.empty())
    {
        u=q.front();q.pop();
        for(k=f1[u];k;k=e[k].nxt)
        {
            v=e[k].to;
            if(d[u]+e[k].d<=d[v]+K)
            {
                y=d[u]+e[k].d-d[v];
                add(an[v][y],an[u][x]);
            }
        }
    }
    for(j=1;j<=K;++j)
    {
        
        while(!q.empty())
        {
            t=q.front();q.pop();
            u=t.fi;x=t.se;
            for(k=f1[u];k;k=e[k].nxt)
            {
                v=e[k].to;
                if(d[u]+x+e[k].d<=d[v]+K)
                {
                    y=d[v]+K-d[u]-x-e[k].d;
                    add(an[v][y],an[u][x]);
                }
            }
        }
}

}
*/
int T;
int main()
{
    //freopen("/tmp/test1.in","r",stdin);
    //freopen("/tmp/park6.in","r",stdin);
    //freopen("/tmp/ex_park2.out","w",stdout);
    int i,x,y,z;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d%d%d",&n,&m,&K,&md);
        memset(f1+1,0,sizeof(f1[0])*n);
        memset(ok+1,0,sizeof(ok[0])*n);
        ne=0;
        memset(Dij2::f1+1,0,sizeof(Dij2::f1[0])*n);
        Dij2::ne=0;
        for(i=1;i<=m;++i)
        {
            scanf("%d%d%d",&x,&y,&z);
            e[++ne].to=y;e[ne].nxt=f1[x];f1[x]=ne;e[ne].d=z;
            Dij2::me(y,x,z);
        }
        OK::work();
        Dij1::dij();Dij2::dij();
        {
            int *d1=Dij1::d,*d2=Dij2::d;
            for(i=1;i<=n;++i)
                if(d1[i]+d2[i]<=d1[n]+K)
                {
                    ok[i]=1;
                    if(OK::sz[OK::sccnum[i]]>1)
                    {
                        puts("-1");
                        goto xx1;
                    }
                }
        }
        DP::dp();
xx1:;
    }
    return 0;
}

---

一查题解，发现貌似只要按照上面类似的方法建一个分层图，直接对这个分层图跑拓扑排序以及判环就行了？