[NOIP2017]逛公园

最新推荐文章于 2023-08-27 15:33:21 发布
最新推荐文章于 2023-08-27 15:33:21 发布
阅读量67 收藏
点赞数
原文链接：http://www.cnblogs.com/cjfdf/p/8898034.html
版权

题面在这里

description

策策同学特别喜欢逛公园。
公园可以看成一张\(N\)个点\(M\) 条边构成的有向图，且没有自环和重边。
其中\(1\)号点是公园的入口，\(N\)号点是公园的出口，
每条边有一个非负权值，代表策策经过这条边所要花的时间。
策策每天都会去逛公园，他总是从\(1\)号点进去，从\(N\)号点出来。

策策喜欢新鲜的事物，它不希望有两天逛公园的路线完全一样，同时策策还是一个 特别热爱学习的好孩子，它不希望每天在逛公园这件事上花费太多的时间。
如果\(1\)号点到\(N\)号点的最短路长为\(d\),那么策策只会喜欢长度不超过\(d+K\) 的路线。

策策同学想知道总共有多少条满足条件的路线，你能帮帮它吗？
为避免输出过大，答案对\(P\)取模。
如果有无穷多条合法的路线，请输出\(−1\)。

data range

\[1\le N\le 100000,1\le M\le 200000,1\le k\le 50\]

\[1 \le P \le 10^9,1 \le a_i,b_i \le N ,0 \le c_i \le 1000,1≤P≤10^9\]

solution

时隔近一年终于改掉了这道题
还是卡着时间AC的

30pts:最短路计数

在跑\(SPFA\)更新最短路的同时更新最短路的数量,
具体来说,如果最短路要更新就把其数量重置为其前驱最短路的数量，
如果最短路的值不变那么其数量叠加
但是这样是可能存在问题的
比如下面这张图
此处输入图片的描述
如果点2比点4先入队的话，
点3的最短路条数就会在第一次取出点2的时候更新一次，
点4的入队会导致点2第二次入队，那么点4又会被点2更新一次;
第一次更新时点2最短路条数为1,第二次更新时点2最短路条数为2
两次相加点4的最短路条数就是3,明显不对

于是我们需要改进我们的\(SPFA\)
笔者的做法是这样的:
我们记录一个\(top\)值表示当前节点最后一次更新的时候存的最短路条数,
在一次转移完成之后\(top=f\),转移的时候使用\(f-top\)转移,这样就不会算重啦

il void spfa(bool s){//s代表是否需要统计最短路
  memset(f,0,sizeof(f));
  memset(t,0,sizeof(t));
  while(!Q.empty())Q.pop();
  for(RG int i=1;i<=n;i++)dis[i]=inf,vis[i]=0;
  vis[1]=1;dis[1]=0;Q.push(1);f[1][0]=1;
  while(!Q.empty()){
    RG int u=Q.front();Q.pop();
    for(RG int i=head[u];i;i=nxt[i]){
      RG int v=to[i];
      if(!s){
    if(dis[v]>dis[u]+val[i]){
      dis[v]=dis[u]+val[i];
      if(!vis[v]){
        Q.push(v);vis[v]=1;
      }
    }
      }
      else{
    if(dis[v]>=dis[u]+val[i]){
      if(dis[v]>dis[u]+val[i]){
        dis[v]=dis[u]+val[i];
        f[v][0]=f[u][0];t[v]=0;
      }
      else if(dis[v]==dis[u]+val[i]){
        (f[v][0]+=(f[u][0]-t[u]+p)%p)%=p;
      }
      if(!vis[v]){
        Q.push(v);vis[v]=1;
      }
    }
      }
    }
    vis[u]=0;t[u]=f[u][0];
  }
}

60pts:DP

\(DP\)方程式是显然的,设\(f[k][u]\)表示点\(1\)到达\(u\)路径长度为\(dis[u]+k\)的方案数,
那么转移的途径只能是边对吧?
\[f[k][u]-_{each\ e(u,v)}>f[k+dis[u]+val[e]-dis[v]][v]\]
但是我们在\(DP\)的时候之前的\(f\)必须已经被计算好了,怎么办呢?
试想一个点只可能由\(dis\)比它小的点转移而来
因此我们需要从$ $最小的开始枚举边进行转移,这样就不会出问题啦

il void DP(){//DP.
  for(RG int j=0;j<=k;j++)
    for(RG int s=1;s<=n;s++){
      RG int u=P[s].id;
      for(RG int i=head[u];i;i=nxt[i]){
    RG int v=to[i];
    if(dis[u]+j+val[i]-dis[v]>0&&dis[u]+j+val[i]-dis[v]<=k)
      (f[v][dis[u]+j+val[i]-dis[v]]+=f[u][j])%=p;
      }
    }
}

100pts:

\(0\)边真是个恐怖的存在,\(0\)环更不用说了;其实0边还好
首先我们考虑侥幸不存在\(0\)环的情况,如图所示:

这里我们的最短路计数不会出问题,但是$ \(都相等, 直接按照\) \(确定顺序的话可能会\)WA$
由于我们对于这些点\(DP\)的顺序和其在\(0\)边连接下的拓补序有关,
我们考虑把所有\(0\)边都加入一个新图,然后做一遍拓补排序即可

那如果有\(0\)环怎么办呢?
我们考虑一个\(0\)环什么时候才会影响到答案，
即是这个环上任意一点被算在了一条可行的路径中,
那么我们处理出\(dis\)和\(fdis(反图中点n的最短路)\),
由于不会存在负环,最短路是不会出现问题的;
在\(0\)环上的任意一点\(i\)满足\(dis[i]+fdis[i]\le dis[n]+k\)就可以输出\(-1\)了

code

#include<bits/stdc++.h>
#include<algorithm>
#include<iostream>
#include<cstdlib>
#include<iomanip>
#include<cstring>
#include<complex>
#include<vector>
#include<cstdio>
#include<string>
#include<bitset>
#include<cmath>
#include<queue>
#include<stack>
#include<map>
#include<set>
//#define TEST
#define FILE "park"
#define mp make_pair
#define pb push_back
#define RG register
#define il inline
using namespace std;
typedef unsigned long long ull;
typedef vector<int>VI;
typedef long long ll;
typedef double dd;
const int inf=1e9+7;
const int mod2=998244353;
const int rev2=332748118;
const int mod1=1e9+7;
const int N=100010;
const dd eps=1e-10;
const ll INF=1e18;
const int g=3;
il ll read(){
  RG ll data=0,w=1;RG char ch=getchar();
  while(ch!='-'&&(ch<'0'||ch>'9'))ch=getchar();
  if(ch=='-')w=-1,ch=getchar();
  while(ch<='9'&&ch>='0')data=data*10+ch-48,ch=getchar();
  return data*w;
}

il void file(){
  freopen(FILE".in","r",stdin);
  freopen(FILE".out","w",stdout);
}

int n,m,k,p,ans;
int head[N],nxt[N<<1],to[N<<1],val[N<<1],cnt;
il void add(int u,int v,int w){
  to[++cnt]=v;
  nxt[cnt]=head[u];
  val[cnt]=w;
  head[u]=cnt;
}

int fhead[N],fnxt[N<<1],fto[N<<1],fval[N<<1],fcnt;
il void fadd(int u,int v,int w){
  fto[++fcnt]=v;
  fnxt[fcnt]=fhead[u];
  fval[fcnt]=w;
  fhead[u]=fcnt;
}

int zhead[N],znxt[N<<1],zto[N<<1],zd[N],zcnt;
il void zadd(int u,int v){
  zto[++zcnt]=v;zd[v]++;
  znxt[zcnt]=zhead[u];
  zhead[u]=zcnt;
}

queue<int>Q;bool vis[N];int dis[N],f[N][52],t[N];
il void spfa(bool s){//s代表是否需要统计最短路
  memset(f,0,sizeof(f));
  memset(t,0,sizeof(t));
  while(!Q.empty())Q.pop();
  for(RG int i=1;i<=n;i++)dis[i]=inf,vis[i]=0;
  vis[1]=1;dis[1]=0;Q.push(1);f[1][0]=1;
  while(!Q.empty()){
    RG int u=Q.front();Q.pop();
    for(RG int i=head[u];i;i=nxt[i]){
      RG int v=to[i];
      if(!s){
    if(dis[v]>dis[u]+val[i]){
      dis[v]=dis[u]+val[i];
      if(!vis[v]){
        Q.push(v);vis[v]=1;
      }
    }
      }
      else{
    if(dis[v]>=dis[u]+val[i]){
      if(dis[v]>dis[u]+val[i]){
        dis[v]=dis[u]+val[i];
        f[v][0]=f[u][0];t[v]=0;
      }
      else if(dis[v]==dis[u]+val[i]){
        (f[v][0]+=(f[u][0]-t[u]+p)%p)%=p;
      }
      if(!vis[v]){
        Q.push(v);vis[v]=1;
      }
    }
      }
    }
    vis[u]=0;t[u]=f[u][0];
  }
}

int fdis[N];
il void fspfa(){
  while(!Q.empty())Q.pop();
  for(RG int i=1;i<=n;i++)fdis[i]=inf,vis[i]=0;
  vis[1]=1;fdis[n]=0;Q.push(n);
  while(!Q.empty()){
    RG int u=Q.front();Q.pop();
    for(RG int i=fhead[u];i;i=fnxt[i]){
      RG int v=fto[i];                    
      if(fdis[v]>fdis[u]+fval[i]){
    fdis[v]=fdis[u]+fval[i];
    if(!vis[v]){
      Q.push(v);vis[v]=1;
    }
      }
    }
    vis[u]=0;
  }   
}

bool inz[N],incal[N];int dfn[N],low[N],tott,cal[N],top;
il void tarjan(int u){//check 0-circle
  dfn[u]=low[u]=++tott;incal[cal[++top]=u]=1;
  for(RG int i=zhead[u];i;i=znxt[i]){
    RG int v=zto[i];
    if(!dfn[v]){
      tarjan(v);
      low[u]=min(low[u],low[v]);
    }
    else if(incal[v])low[u]=min(low[u],dfn[v]);
  }
  if(dfn[u]==low[u]){
    if(cal[top]==u){incal[cal[top--]]=0;return;}
    while(cal[top]!=u){
      incal[cal[top]]=0;inz[cal[top]]=1;top--;
    }
    incal[cal[top]]=0;inz[cal[top]]=1;top--;
  }
}

struct node{int id,dis,zt;}P[N];
bool cmp(node x,node y){
  return x.dis==y.dis?x.zt<y.zt:x.dis<y.dis;
}
int totz;
il void bfs_z(){//tuopu 0 dag,make a order
  while(!Q.empty())Q.pop();   
  for(RG int i=1;i<=n;i++)
    if(!zd[i])Q.push(i);
  while(!Q.empty()){
    RG int u=Q.front();Q.pop();P[u].zt=++totz;
    for(RG int i=zhead[u];i;i=znxt[i]){
      RG int v=zto[i];
      if(!(--zd[v]))Q.push(v);
    }
  }
}

il void DP(){//DP.
  for(RG int j=0;j<=k;j++)
    for(RG int s=1;s<=n;s++){
      RG int u=P[s].id;
      for(RG int i=head[u];i;i=nxt[i]){
    RG int v=to[i];
    if(dis[u]+j+val[i]-dis[v]>0&&dis[u]+j+val[i]-dis[v]<=k)
      (f[v][dis[u]+j+val[i]-dis[v]]+=f[u][j])%=p;
      }
    }
}

il void solve(){
  n=read();m=read();k=read();p=read();
  memset(head,0,sizeof(head));cnt=0;
  memset(fhead,0,sizeof(fhead));fcnt=0;
  memset(zhead,0,sizeof(zhead));zcnt=0;
  memset(zd,0,sizeof(zd));
  for(RG int i=1,u,v,w;i<=m;i++){
    u=read();v=read();w=read();
    if(!w)zadd(u,v);add(u,v,w);fadd(v,u,w);
  }
  spfa(0);fspfa();

  memset(inz,0,sizeof(inz));
  memset(dfn,0,sizeof(dfn));
  memset(low,0,sizeof(low));tott=0;
  for(RG int i=1;i<=n;i++)if(!dfn[i])tarjan(i);
  for(RG int i=1;i<=n;i++)
    if(inz[i]&&dis[i]+fdis[i]<=dis[n]+k){
      puts("-1");return;
    }
  //-1
  spfa(1);

  totz=ans=0;bfs_z();
  for(RG int i=1;i<=n;i++){
    P[i].id=i;P[i].dis=dis[i];
  }
  sort(P+1,P+n+1,cmp);
  DP();

  for(RG int i=0;i<=k;i++)(ans+=f[n][i])%=p;
  printf("%d\n",ans);
  //DP
}

int main()
{
  RG int T=read();while(T--)solve();return 0;
}

转载于:https://www.cnblogs.com/cjfdf/p/8898034.html

weixin_30412013
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
NOIP2017 逛公园
weixin_30426957的博客
09-27 93
传送门 这个题听说是NOIP2017最难的题？反正我当时啥也不会爆零…… 首先我们看送的分，直接跑最短路计数有30pts。 之后就不会了hhhhh…… 我们仔细观察题目之后发现，这个题k的数据范围特别小，只有50，也就是说我们最多只会统计比最短路径长50的所有路径条数，那我们其实完全是可以这样DP的。 具体操作如下，我们首先建出正图，在正图上跑一遍dij，记录起点到每个点的最短距离。之后...
[NOIP2017 提高组] 逛公园 （题解）
又又大柚纸的博客
04-09 462
最短路计数，可以参考 [NOI2007] 社交网络。
[NOIP2017 提高组] 逛公园
最新发布
m0_64092297的博客
08-27 227
策策同学特别喜欢逛公园。公园可以看成一张N个点M条边构成的有向图，且没有 自环和重边。其中1号点是公园的入口，N号点是公园的出口，每条边有一个非负权值， 代表策策经过这条边所要花的时间。策策每天都会去逛公园，他总是从1号点进去，从N号点出来。策策喜欢新鲜的事物，它不希望有两天逛公园的路线完全一样，同时策策还是一个 特别热爱学习的好孩子，它不希望每天在逛公园这件事上花费太多的时间。如果1号点 到N号点的最短路长为d，那么策策只会喜欢长度不超过d+K的路线。
NOIP2017 逛公园（最短路+记忆化搜索）
qq_44719030的博客
05-09 379
Description Input Output Example input 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 output 3 -1 思路 本题题意为求长度为d,d+1,d+2......,d+kd,d+1,d+2......,d+kd,d+1,d+2......,d+k的路线数量，我们发现kkk的范围非常小，可以枚举kkk的值。 对于一个点xxx，到终点的最短距离为dis[x]di
洛谷 P3953 [NOIP2017 提高组] 逛公园
m0_56280274的博客
04-18 407
开始刷题单啦~，这部分的洛谷好题作为个人训练记录和以后复习用，有兴趣的可以一起做做 题目链接：P3953 [NOIP2017 提高组] 逛公园 题意都是中文就不翻译了 题解：这是一道记忆化+搜索的题目，我们可以先用迪杰斯特拉求出每个点距离起点1的最短距离，然后建反向边（e_f），因为k很小，所以我们可以枚举k，从终点往起点搜索，因为每个点距离1的最短路径都已经求出来了，那么假设当前枚举的是x，和最短路径相差len,用dis数组表示每个点距离起点的最短距离，那么有转移如下：dfs(x,len)->
NOIP2017官方测试数据
11-01
noip2017 、官方测试数据、包含普及组和提高组两个组别的测试数据。
NOIP2017普及组参考答案
05-02
NOIP2017普及组参考答案
NOIP2017普及组C++试题(无水印版).zip_2017C++真题_noip 2017普及组_noip2017_noip2
07-14
Noip2017年普及组初赛c++试题（无水印）
1.rar（noip2017测试数据）
07-06
noip测试数据 noip2017提高组复赛
NOIP2017_day1.pdf
11-11
最新出炉NOIP2017提高组复赛day1试题，有志者速下载！
NOIP2017DAY1T3——逛公园
weixin_30896825的博客
11-03 157
输入 第一行包含一个整数 T, 代表数据组数。 接下来T组数据，对于每组数据： 第一行包含四个整数 n, m, k, p， 每两个整数之间用一个空格隔开。 接下来m行，每行三个整数ai,bi, ci， 代表编号为ai, bi的点之间有一条权值为 ci的有 向边，每两个整数之间用一个空格隔开 输出 输出文件包含 T行，每行一个整数代表答案。 样例输...
【NOIP 2017 提高组】逛公园
forever_dreams的博客
11-04 1177
算法标签：最短路+DP+记忆化搜索
[NOIP2017]逛公园 最短路图 拓扑序DP
weixin_30399797的博客
10-17 82
～～～题面～～～ 题解： 　　挺好的一道题。 　　首先我们将所有边反向，跑出n到每个点的最短路，然后f[i][j]表示从i号节点出发，路径长比最短路大j的方案数。 　　观察到，如果图中出现了0环，那么我们可以通过在环上走无数次来获得无数条不同路径，因此这就无解了。 　　如果没有0环，当且仅当这张图的最短路图是一个DAG(可以画图思考一下)，因为如果没有0环，而最短路图中出现了环，那么意味...
NOIP2017提高组D1T3[逛公园]
HHzzkk2003的博客
11-22 915
题意： 给定一个有向图，设1到n的最短路径长度为d，问有多少从1到n长度在d~d+k（k给定）之间的路径（mod p）。 题解： 先两边Dijkstra算出最短路径树，然后在最短路径树上拓扑排序，若不能排序（意味着有0环）则有无数条满足要求的路径，否则排完序后按拓扑序DP得到答案。 代码： #include #include #include #include #include
【NOIP2017】逛公园 最短路+DP
diaoyoutun2652的博客
10-10 96
诶，去年场上不会处理$0$的环，只拿了$60$有点可惜。 我们先不管边边权为$0$的边。 我们先跑一次最短路，令$dis[u]$表示从$1$至$u$的最短路的长度。 那么根据题目的要求，从起点走到$u$号点的路径长度只可能在区间$[dis[u],dis[u]+k]$中。 令$f[i][j]$表示当前从起点走到$i$，行走的路程为$dis[i]+j$的方案数。 不妨发现这个东西可...
LOJ 2316「NOIP2017」逛公园 dijkstra+dp
mysterynoip的博客
09-25 242
题面 题目传送门 解法 开始认认真真学习NOIP原题 讲两种不同的做法吧： 第一种做法：求出从111号点到其它所有点的距离和nnn号点到其它所有点的距离(这个需要建出反向边之后来跑)，然后我们设f[i][j]f[i][j]f[i][j]表示从111走到点iii且当前走过的路径长度比111到iii的最短路大jjj的方案数 考虑这种做法如何转移，我们现在需要确定fff数组的更新顺序。当存在长度为00...
JZOJ5475.【NOIP2017提高组】day1T3逛公园
路人黑的纸巾
11-21 3844
problemDescription 策策同学特别喜欢逛公园。公园可以看成一张��个点��条边构成的有向图，且没有自环和重边。其中1号点是公园的入口，��号点是公园的出口，每条边有一个非负权值，代表策策经过这条边所要花的时间。 策策每天都会去逛公园，他总是从1号点进去，从��号点出来。 策策喜欢新鲜的事物，他不希望有两天逛公园的路线完全一样，同时策策还是一个特别热爱学习的好孩子，他不
noip2017逛公园
weixin_30664615的博客
11-05 102
题解： 之前知道正解并没有写过。。 #include <bits/stdc++.h> using namespace std; #define rint register int #define IL inline #define rep(i,h,t) for (int i=h;i<=t;i++) #define dep(i,t,h) for (int i=...
NOIP2017逛公园 记忆化搜索+判环+最短路
Loging的博客
10-08 407
题目链接：洛谷-3953 主要思路： 由于这道题K的数值范围较小，故可以直接枚举K来求答案。答案就是起点到终点的为d,d+1,d+2,...,d+K的路径的条数总合。            联想到之前一些在路径上有消耗的图论题，我们可以把这个K也当做是一个被消耗的东西，就像钱一样（以下就当钱讲好了）。故我们可以定义dp[i][j]为从i这个点出发走比他到终点的最短距离大j的路径有多少条。接下...
[NOIP2017]时间复杂度
07-27
对于一个算法的时间复杂度，可以用大O符号来表示。大O表示法描述了算法在最坏情况下的运行时间增长率。 常见的时间复杂度有： - O(1)：常数时间复杂度，表示算法的执行时间不随输入规模增加而增加。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值