题目描述

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

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

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

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

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

输入输出格式

输入格式：

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

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

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

接下来 mm行,每行两个整数S_iSi,和T_iTi,表示一个玩家的起点和终点。

对于所有的数据,保证1\leq
S_i,T_i\leq n, 0\leq W_j\leq n1≤Si,Ti≤n,0≤Wj≤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：

输出样例#2：

1 2 1 0 1

说明

【样例1说明】

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

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

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

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

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

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

【子任务】

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

NOIP2016天天爱跑步题解报告【lca+树上统计(桶)】

【提示】

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

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

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

栈溢出崩溃。

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

令 ulimit -s 1048576

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

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

NOIP2016天天爱跑步题解报告【lca+树上统计(桶)】

将上述源代码编译为可执行文件 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+树上统计(桶)】

题目描述

输入输出格式

输入输出样例

说明

题解

25分算法

S为根节点部分分

T为根节点

退化为链部分分

满分算法

NOIP2016天天爱跑步题解报告【lca+树上统计(桶)】