　　　　[NOIP2016]天天爱跑步

　　　　　　　　　　时间限制：2 s 内存限制：512 MB

【题目描述】

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

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

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

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

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

【输入格式】

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

接下来n-1行每行两个整数u和v，表示结点u到结点v有一条边。

接下来一行n个整数，其中第j个整数为Wj，表示结点j出现观察员的时间。

接下来m行,每行两个整数Si和Ti，表示一个玩家的起点和终点。

对于所有的数据，保证1≤Si,Ti≤n，0≤ Wj ≤n。

【输出格式】

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

【样例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号点，W1=0，故只有起点为1号点的玩家才会被观察到，所以玩家1和玩家2被观察到，共2人被观察到。

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

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

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

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

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

　　好尴尬的一道题，过了编译器直接上交，75分，一看，倍增爬LCA时将深度与下标进行的比较，还75分……改完后AC，有点不大满意。

　　对于暴力80分我就不说了，直接说正解。

　　我们把一个人的路程分为两部分：起点到LCA，LCA到终点。

　　那么，在第一部分中观察员看到玩家的前提是w[x]=deep[st]-deep[x]。

　　在第二部分看到玩家的前提是w[x]=l-(deep[to]-deep[x])，其中l为起点到终点的长度。

　　把两个式子化为和x有关，就是w[x]+deep[x]=deep[st],w[x]-deep[x]=l-deep[to]。

　　我们只要把两个式子做成桶，然后对于每个点在遍历到时先记录一下对应桶内的初始值，因为此时桶里的值对他是不可能有贡献的，真正有贡献的是遍历完他的子树后与之前的值的差值。遍历完他的子树后我们先把把这个点作为起点的玩家信息塞进一个桶里，再把以这个点作为终点的玩家信息塞到另一个桶里，然后再统计答案。注意，如果一个点是一条路径上的LCA，那么，他如果会被观察到答案会被记录两次，所以我们要提前减去这个值。在这之后，我们再将以这个点作为LCA的所有路径在桶里清除掉就好了。

#include <iostream>

#include <cstdlib>

#include <cstdio>

#include <cstring>

#include <queue>

#include <algorithm>

#include <cmath>

#include <map>

#define N 300000

using namespace std;

int n,m,w[N],a[N],zz,s[N],t[N],js[N],l[N];

struct ro

{

	int to,next;

}road[N*2],road1[N],road2[N];

void build(int x,int y)

{

	zz++;

	road[zz].to=y;

	road[zz].next=a[x];

	a[x]=zz;

}

int zz2,b[N],zz3,c[N];

void build3(int x,int y)

{

	zz3++;

	road2[zz3].to=y;

	road2[zz3].next=c[x];

	c[x]=zz3;

}

void build2(int x,int y)

{

	zz2++;

	road1[zz2].to=y;

	road1[zz2].next=b[x];

	b[x]=zz2;

}

int fa[N][20],deep[N],ans[N];

void dfs1(int x)

{

	for(int i=a[x];i>0;i=road[i].next)

	{

		int y=road[i].to;

		if(y==fa[x][0])continue;

		deep[y]=deep[x]+1;

		fa[y][0]=x;

		dfs1(y);

	}

}

int get_lca(int x,int y)

{

	if(x==y)return x;

	if(deep[x]>deep[y])swap(x,y);

	for(int i=19;i>=0;i--)

	{

		if(deep[x]<=deep[fa[y][i]])y=fa[y][i];

	}

	if(x==y)return x;

	for(int i=19;i>=0;i--)

	{

		if(fa[x][i]!=fa[y][i])x=fa[x][i],y=fa[y][i];

	}

	return fa[x][0];

}

int T1[N*2],T2[N*2];

void dfs2(int x)

{

	int t1=T1[w[x]+deep[x]],t2=T2[w[x]-deep[x]+N];

	for(int i=a[x];i>0;i=road[i].next)

	{

		int y=road[i].to;

		if(y==fa[x][0])continue;

		dfs2(y);

	}

	T1[deep[x]]+=js[x];

	for(int i=c[x];i>0;i=road2[i].next)

	{

		int y=road2[i].to;

		T2[l[y]-deep[t[y]]+N]++;

	}

	ans[x]+=T1[w[x]+deep[x]]-t1+T2[w[x]-deep[x]+N]-t2;

	for(int i=b[x];i>0;i=road1[i].next)

	{

		int y=road1[i].to;

		T1[deep[s[y]]]--;

		T2[l[y]-deep[t[y]]+N]--;

	}

}

int main()

{

    scanf("%d%d",&n,&m);

    for(int i=1;i<n;i++)

    {

    	int x,y;

    	scanf("%d%d",&x,&y);

    	build(x,y),build(y,x);

	}

	for(int i=1;i<=n;i++)

	{

		scanf("%d",&w[i]);

	}

	for(int i=1;i<=m;i++)

	{

		scanf("%d%d",&s[i],&t[i]);

	}

	deep[1]=1;

	dfs1(1);

	for(int i=1;i<=19;i++)

	{

		for(int j=1;j<=n;j++)

		{

			fa[j][i]=fa[fa[j][i-1]][i-1];

		}

	}

	for(int i=1;i<=m;i++)

	{

		int lca=get_lca(s[i],t[i]);

		js[s[i]]++;

		l[i]=deep[s[i]]+deep[t[i]]-2*deep[lca];

		if(w[lca]==deep[s[i]]-deep[lca])ans[lca]--;

		build2(lca,i);

		build3(t[i],i);

	}

	dfs2(1);

	for(int i=1;i<=n;i++)

	{

		printf("%d ",ans[i]);

	}

	return 0;

}

　　当前NOIP2016 估计分数：

　　　T1 100+75+88=263

　　　T2 100+?+100=200

　　总共463分，还没算大坑“蚯蚓”……