题目描述

小c同学认为跑步非常有趣,于是决定制作一款叫做《天天爱跑步》的游戏。«天天爱跑步»是一个养成类游戏,需要玩家每天按时上线,完成打卡任务。

这个游戏的地图可以看作一一棵包含 nn个结点和 n-1n−1条边的树,
每条边连接两个结点,且任意两个结点存在一条路径互相可达。树上结点编号为从11到nn的连续正整数。

现在有mm个玩家,第ii个玩家的起点为 S_iS​i​​,终点为 T_iT​i​​ 。每天打卡任务开始时,所有玩家在第00秒同时从自己的起点出发,
以每秒跑一条边的速度, 不间断地沿着最短路径向着自己的终点跑去, 跑到终点后该玩家就算完成了打卡任务。 (由于地图是一棵树, 所以每个人的路径是唯一的)

小C想知道游戏的活跃度, 所以在每个结点上都放置了一个观察员。 在结点jj的观察员会选择在第W_jW​j​​秒观察玩家,
一个玩家能被这个观察员观察到当且仅当该玩家在第W_jW​j​​秒也理到达了结点 jj 。
小C想知道每个观察员会观察到多少人?

注意: 我们认为一个玩家到达自己的终点后该玩家就会结束游戏, 他不能等待一 段时间后再被观察员观察到。 即对于把结点jj作为终点的玩家:
若他在第W_jW​j​​秒重到达终点,则在结点jj的观察员不能观察到该玩家;若他正好在第W_jW​j​​秒到达终点,则在结点jj的观察员可以观察到这个玩家。

输入输出格式

输入格式:

第一行有两个整数nn和mm 。其中nn代表树的结点数量,
同时也是观察员的数量, mm代表玩家的数量。

接下来 n-
1n−1行每行两个整数uu和 vv,表示结点 uu到结点 vv有一条边。

接下来一行 nn个整数,其中第jj个整数为W_jW​j​​ ,
表示结点jj出现观察员的时间。

接下来 mm行,每行两个整数S_iS​i​​,和T_iT​i​​,表示一个玩家的起点和终点。

对于所有的数据,保证1\leq
S_i,T_i\leq n, 0\leq W_j\leq n1≤S​i​​,T​i​​≤n,0≤W​j​​≤n 。

输出格式:

输出1行 nn个整数,第jj个整数表示结点jj的观察员可以观察到多少人。

输入输出样例

输入样例#1:

6 3
2 3
1 2
1 4
4 5
4 6
0 2 5 1 2 3
1 5
1 3
2 6
输出样例#1:

2 0 0 1 1 1 
输入样例#2:

5 3
1 2
2 3
2 4
1 5
0 1 0 3 0
3 1
1 4
5 5
输出样例#2:

1 2 1 0 1 

说明

【样例1说明】

对于1号点,W_i=0W​i​​=0,故只有起点为1号点的玩家才会被观察到,所以玩家1和玩家2被观察到,共有2人被观察到。

对于2号点,没有玩家在第2秒时在此结点,共0人被观察到。

对于3号点,没有玩家在第5秒时在此结点,共0人被观察到。

对于4号点,玩家1被观察到,共1人被观察到。

对于5号点,玩家1被观察到,共1人被观察到。

对于6号点,玩家3被观察到,共1人被观察到。

【子任务】

每个测试点的数据规模及特点如下表所示。 提示: 数据范围的个位上的数字可以帮助判断是哪一种数据类型。

【提示】

如果你的程序需要用到较大的栈空问 (这通常意味着需要较深层数的递归), 请务必仔细阅读选手日录下的文本当rumung:/stact.p″, 以了解在最终评测时栈空问的限制与在当前工作环境下调整栈空问限制的方法。

在最终评测时,调用栈占用的空间大小不会有单独的限制,但在我们的工作

环境中默认会有 8 MB 的限制。 这可能会引起函数调用层数较多时, 程序发生

栈溢出崩溃。

我们可以使用一些方法修改调用栈的大小限制。 例如, 在终端中输入下列命

令 ulimit -s 1048576

此命令的意义是,将调用栈的大小限制修改为 1 GB。

例如,在选手目录建立如下 sample.cpp 或 sample.pas

将上述源代码编译为可执行文件 sample 后,可以在终端中运行如下命令运

行该程序

./sample

如果在没有使用命令“ ulimit -s 1048576”的情况下运行该程序, sample

会因为栈溢出而崩溃; 如果使用了上述命令后运行该程序,该程序则不会崩溃。

特别地, 当你打开多个终端时, 它们并不会共享该命令, 你需要分别对它们

运行该命令。

请注意, 调用栈占用的空间会计入总空间占用中, 和程序其他部分占用的内

存共同受到内存限制。

题解

一个晚上,三个多小时,终于把NOIP最难一题拿下,时隔一年,NOIP2016全满AK

25分算法


直接暴力,跟着人走,当发现当前节点满足条件就统计

S为根节点部分分

S为根节点,如果节点i可以观测到人,那么首先要满足w[i]==deep[i],然后以i为根节点的子树包含多少个终点,i节点的答案就是几

T为根节点

对于i节点,深度为deep[i]+w[i]的起点才会产生贡献。那就dfs树上统计呗:
1、开一个桶bac[x]表示当前深度为x的起点有多少个
2、对于节点i,访问时先记录当时的bac[deep[i]+w[i]],再往下递归,递归完后检查bac[deep[i]+w[i]],增加了v就说明它的子树有v个这样的起点,i的答案就是v

退化为链部分分

退化为链你能想到什么?
所有的路径要么左走要么右走
我们只考虑左走【右走类似】
右走时,对于节点i,只有节点i-w[i]为起点时才会产生贡献。
那就向右扫一遍:
1、同样开一个桶bac[x]表示扫到现在以x为起点的还未走完的路径有多少个
2、记录当前点i的答案bac[i-w[i]]
3、对于在该点结束的路径的bac[S]--

满分算法

满分算法其实就是综上所述。。
先把树进行lca,路径分为向上和向下走

1、对于向上走的路径,在i节点,当deep[i]+w[i]==deep[S]时才会产生贡献
借用以T为根节点的思想,开一个桶来差分统计就好了

2、对于向下走的路径,在i节点,当deep[i]-w[i]==deep[T]-dis[S,T]-pret[T]时才会产生贡献【dis表示路径长,pret表示若该路径起点为lca,则走到lca时是什么时刻,若该路径起点为自然起点,则pret=0】

3、进行同样的统计,到i节点时把向上路径的起点S_up和向下路径的终点T_up【起点在上面的终点】的对应的bac[ ]++【例如T_up就是bac[deep[T]-dis[S,T]-pret[T]]++】,在访问结束时将向下路径的起点S_down和向上路径的终点T_up对应的另一个端点的统计撤销【类似于链状部分分的算法,看不明白可以参照一下】

4、若该点为lca且该点产生了贡献,贡献值应该-1,因为统计了两次


总的来说要注意的地方还是很多的,细节处理要特别注意,3个小时终于A了QAQ,膜拜那些考场AK的dalao  orzorz

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
#define LL long long int
using namespace std;
const int maxn=700005,maxm=2000100,INF=2000000000,P=1000000007;
//快速读入
inline int read(){
int out=0,flag=1;char c=getchar();
while(c<48||c>57) {if(c=='-') flag=-1;c=getchar();}
while(c>=48&&c<=57){out=out*10+c-48;c=getchar();}
return out*flag;
}
//边信息建立
int head[maxn],nedge=0;
struct EDGE{
int to,next;
}edge[maxm]; inline void build(int a,int b){
edge[nedge]=(EDGE){b,head[a]};
head[a]=nedge++;
edge[nedge]=(EDGE){a,head[b]};
head[b]=nedge++;
}
//lca询问信息建立
int Head[maxn],nlca=0;
struct LCA{
int to,flag,next;
}Lca[maxm]; inline void link(int a,int b){
Lca[nlca]=(LCA){b,0,Head[a]};
Head[a]=nlca++;
Lca[nlca]=(LCA){a,0,Head[b]};
Head[b]=nlca++;
} int N,M,w[maxn],rt=0,Siz[maxn],disrt=INF;
//数据读入
void init(){
fill(head,head+maxn,-1);
fill(Head,Head+maxn,-1);
N=read();M=read();
int a,b;
for(int i=1;i<N;i++) build(read(),read());
for(int i=1;i<=N;i++) w[i]=read();
for(int i=1;i<=M;i++){a=read();b=read();link(a,b);}
}
//重心为根
void dfs1(int u,int f){
int to,Min=INF,Max=-INF;
Siz[u]=1;
for(int k=head[u];k!=-1;k=edge[k].next)
if((to=edge[k].to)!=f){
dfs1(to,u);
Siz[u]+=Siz[to];
if(Siz[to]<Min) Min=Siz[to];
if(Siz[to]>Max) Max=Siz[to];
}
if(Min==INF) return;
if(N-Siz[u]<Min&&f) Min=N-Siz[u];
if(N-Siz[u]>Max) Max=N-Siz[u];
if(Max-Min<disrt){disrt=Max-Min;rt=u;}
} void focus(){
dfs1(1,0);
if(!rt) rt=1;
//cout<<rt<<endl;
} vector<int> Su[maxn],Sd[maxn],Tu[maxn],Td[maxn];
int pre[maxn],dep[maxn],dis[maxn],S[maxn],T[maxn],pret[maxn],pathi=0,temp;
int lca0[maxn];
bool vis[maxn]; inline int find(int u){
return u==pre[u] ? u:pre[u]=find(pre[u]);
}
//tarjan_lca算法割路径
void dfs2(int u,int f){
int to;
pre[u]=u;
dep[u]=dep[f]+1;
vis[u]=true;
for(int k=head[u];k!=-1;k=edge[k].next){
if((to=edge[k].to)!=f){
dfs2(to,u);
pre[to]=u;
}
}
for(int k=Head[u];k!=-1;k=Lca[k].next){
if(!Lca[k].flag&&vis[to=Lca[k].to]){
Lca[k].flag=Lca[k^1].flag=true;
int flag=0,m=find(to);
if(!(k&1)) {flag=1;to^=u^=to^=u;}
pathi++;
if(to==m){
S[pathi]=to;T[pathi]=u;dis[pathi]=dep[u]-dep[to];
pret[pathi]=0;
Sd[to].push_back(pathi);Tu[u].push_back(pathi);
}else if(u==m){
S[pathi]=to;T[pathi]=u;dis[pathi]=dep[to]-dep[u];
Td[u].push_back(pathi);Su[to].push_back(pathi);
}else{
lca0[pathi]=m;
S[pathi]=to;T[pathi]=m;dis[pathi]=dep[to]-dep[m];
Su[to].push_back(pathi);Td[m].push_back(pathi);
S[++pathi]=m;T[pathi]=u;dis[pathi]=dep[u]-dep[m];
pret[pathi]=dep[to]-dep[m];
Sd[m].push_back(pathi);Tu[u].push_back(pathi);
}
if(flag) u=to;
}
}
} void tarjan_lca(){
dfs2(rt,0);
/*for(int i=1;i<=pathi;i++){
printf("%d %d %d\n",S[i],T[i],dis[i]);
}*/
} int cntS[maxm],cntT[maxm],ans[maxn];
//树上统计
void dfs(int u,int f){
int dS=dep[u]+w[u]+maxn,oriS=cntS[dS],dT=dep[u]-w[u]+maxn,oriT=cntT[dT],to;
for(unsigned i=0;i<Su[u].size();i++){
cntS[dep[S[Su[u][i]]]+maxn]++;
}
for(unsigned i=0;i<Tu[u].size();i++){
cntT[dep[T[Tu[u][i]]]-dis[Tu[u][i]]-pret[Tu[u][i]]+maxn]++;
}
for(int k=head[u];k!=-1;k=edge[k].next){
if((to=edge[k].to)!=f){
dfs(to,u);
}
}
ans[u]=cntS[dS]-oriS+cntT[dT]-oriT;
for(unsigned i=0;i<Td[u].size();i++){
cntS[dep[S[Td[u][i]]]+maxn]--;
//if(u==2) cout<<"lca:"<<lca0[Td[u][i]]<<endl;
if(lca0[Td[u][i]]==u&&dep[S[Td[u][i]]]+maxn==dS) ans[u]--;
}
for(unsigned i=0;i<Sd[u].size();i++){
cntT[dep[T[Sd[u][i]]]-dis[Sd[u][i]]-pret[Sd[u][i]]+maxn]--;
}
}
//打印答案
void print(){
printf("%d",ans[1]);
for(int i=2;i<=N;i++) printf(" %d",ans[i]);
printf("\n");
} int main(){
init();
focus();
tarjan_lca();
dfs(rt,0);
print();
return 0;
}

NOIP2016天天爱跑步 题解报告【lca+树上统计(桶)】的更多相关文章

  1. [NOIP2016]天天爱跑步 题解(树上差分) (码长短跑的快)

    Description 小c同学认为跑步非常有趣,于是决定制作一款叫做<天天爱跑步>的游戏.<天天爱跑步>是一个养成类游戏,需要 玩家每天按时上线,完成打卡任务.这个游戏的地图 ...

  2. 【NOIP2016】天天爱跑步 题解(LCA+桶+树上差分)

    题目链接 题目大意:给定一颗含有$n$个结点的树,每个结点有一个权值$w$.给定$m$条路径,如果一个点与路径的起点的距离恰好为$w$,那么$ans[i]++$.求所有结点的ans. 题目分析 暴力的 ...

  3. [NOIP2016]天天爱跑步-题解

    题面传送门 解答 设第\(j\)号玩家在\(V_j\)时刻出发. 弱化问题:如果树退化成了一条链.则在\(j\)处的观察员能观察到的\(i\)号玩家当且仅当 \[ i玩家经过j,且 \begin{ca ...

  4. [Noip2016]天天爱跑步 LCA+DFS

    [Noip2016]天天爱跑步 Description 小c同学认为跑步非常有趣,于是决定制作一款叫做<天天爱跑步>的游戏.?天天爱跑步?是一个养成类游戏,需要玩家每天按时上线,完成打卡任 ...

  5. 「NOIP2016」天天爱跑步 题解

    (声明:图片来源于网络) 「NOIP2016」天天爱跑步 题解 题目TP门 题目 题目描述 小c同学认为跑步非常有趣,于是决定制作一款叫做<天天爱跑步>的游戏.<天天爱跑步>是 ...

  6. [NOIp2016]天天爱跑步 线段树合并

    [NOIp2016]天天爱跑步 LG传送门 作为一道被毒瘤出题人们玩坏了的NOIp经典题,我们先不看毒瘤的"动态爱跑步"和"天天爱仙人掌",回归一下本来的味道. ...

  7. Noip 2016 天天爱跑步 题解

    [NOIP2016]天天爱跑步 时间限制:2 s   内存限制:512 MB [题目描述] 小C同学认为跑步非常有趣,于是决定制作一款叫做<天天爱跑步>的游戏.<天天爱跑步>是 ...

  8. 【LG1600】[NOIP2016]天天爱跑步

    [LG1600][NOIP2016]天天爱跑步 题面 洛谷 题解 考虑一条路径\(S\rightarrow T\)是如何给一个观测点\(x\)造成贡献的, 一种是从\(x\)的子树内出来,另外一种是从 ...

  9. [luogu1600 noip2016] 天天爱跑步 (树上差分)

    题目描述 小c同学认为跑步非常有趣,于是决定制作一款叫做<天天爱跑步>的游戏.<天天爱跑步>是一个养成类游戏,需要玩家每天按时上线,完成打卡任务. 这个游戏的地图可以看作一一棵 ...

随机推荐

  1. 基于OpenSSL的RSA加密应用(非算法)

    基于OpenSSL的RSA加密应用(非算法) iOS开发中的小伙伴应该是经常用der和p12进行加密解密,而且在通常加密不止一种加密算法,还可以加点儿盐吧~本文章主要阐述的是在iOS中基于openSL ...

  2. Maven学习(七)-----Maven添加远程仓库

    Maven添加远程仓库 默认情况下,Maven从Maven中央仓库下载所有依赖关系.但是,有些库丢失在中央存储库,只有在Java.net或JBoss的储存库远程仓库中能找到. 1. Java.net资 ...

  3. pytest使用笔记(一)

    使用环境及预置条件:pycharm+win10+python3.6+pytest 1,创建示范的测试功能脚本,另存为test_sample.py,代码如下: # test_sample.py def ...

  4. 【Jmeter测试】如何使用BeanShell断言判断请求返回的Json相应结果

      脚本结构​上图中,queryMaterialApiDTOListByPkIds是返回Json格式响应结果的请求,然后添加BeanShell断言详细判断Json结果中的值是否正确. Json格式的相 ...

  5. Lua学习笔记(8): 元表

    元表 Lua中提供了元表(Metatable),其实这个元表就比较像面向对象中的类了,可以通过给某些特殊的标识符赋值达到重载的效果,这些特殊的标识符有: 名称 功能 __index 元表的索引方法 _ ...

  6. dubbo SpringContainer

    dubbo SpringContainer Spring启动类容器 SPI service provider interfaces 服务提供借口 Singleton 单例 ThreadSafe 线程安 ...

  7. EXE模块说明

    EXE模块是fastCMS系统内非常优秀的一个功能模块,它将一些操作打包成可执行单元.它具有以下优势: 1)功能明确.便于维护. 2)发起端可获取EXE模块的执行结果. 3)对于不需要执行结果的请求, ...

  8. Nginx特性验证-反向代理/负载均衡/页面缓存/URL重定向

    原文发表于cu:2016-08-25 参考文档: Nginx 反向代理.负载均衡.页面缓存.URL重写等:http://freeloda.blog.51cto.com/2033581/1288553 ...

  9. 【Python入门学习】列表生成和函数生成器的方式实现杨辉三角

    列表生成: L = [i for i in range(10)] 列表生成器: g = (i for i in range(10)) 函数生成器使用的关键字yield实现 例如fib生成器 def f ...

  10. drupal CVE-2018-7600 复现

    1.系统环境 Drupal 8.5 linux 主机 ruby 代码 2.原理说明 影响版本 Drupal 6.x,7.x,8.x 参考:CVE-2018-7600漏洞分析 3.利用 在Python2 ...