[NOIp2016] 天天爱跑步

显然，一个人的跑步路线可以看成是一段上行到lca，一段下行。

首先考虑上行，一个点$x$可以观察到$(s,t)$的条件是：
$dep[s]-dep[x]=w_x$
移项：
$dep[x]=w_x+dep[x]$
相当于树上差分之后维护子树里有起点的$dep[x]$

考虑下行，一个点$x$可以观察到$(s,t)$的条件是：
$dis(s,t)-(dep[t]-dep[x])=w_x$
移项：
$dis(s,t)-dep[t]=w_x-dep[x]$
相当于树上差分后维护子树里有终点的$dis(s,t)-dep[t]$

那么怎么统计答案呢？

一种方法是无脑的码一个线段树合并，并没有增加太多的代码量
另一种方法运用到差分的思想，递归子树之后计算的答案减去递归子树之前的答案，其实就是子树里的贡献了。
复杂度 $O(n\log n)$

注意一个细节，我们不能把贡献都在lca处清掉，要不然在lca可能会被重复算。

#include<iostream>
#include<cstring>
#include<cassert>
#include<cmath>
#include<map>
#include<set>
#include<queue>
#include<stack>
#include<cstdio>
#include<vector>
#include<time.h>
#include<algorithm>
#include<climits>
#include<list>

using namespace std;

# define Rep(i,a,b) for(register int i=a;i<=b;i++)
# define _Rep(i,a,b) for(register int i=a;i>=b;i--)
# define RepG(i,u) for(int i=head[u];~i;i=e[i].next)

typedef long long ll;

const int N=3e5+5;

template<typename T> void read(T &x){
   x=0;int f=1;
   char c=getchar();
   for(;!isdigit(c);c=getchar())if(c=='-')f=-1;
   for(;isdigit(c);c=getchar())x=(x<<1)+(x<<3)+c-'0';
    x*=f;
}

int n,m;
int head[N],cnt;
int f[N][20],dep[N];
int a[N];
int out[N];
list<int> S1[N],S2[N],S3[N],S4[N];
int buc[N<<1],ket[N<<1];

struct Edge{
	int to,next;
}e[N<<1];

void add(int x,int y){
	e[++cnt]=(Edge){y,head[x]},head[x]=cnt;
}

int lca(int x,int y){
	if(dep[x]<dep[y])swap(x,y);
	_Rep(i,19,0)if(dep[f[x][i]]>=dep[y])x=f[x][i];
	if(x==y)return x;
	_Rep(i,19,0)if(f[x][i]!=f[y][i])x=f[x][i],y=f[y][i];
	return f[x][0];
}

void dfs1(int u,int fa){
	dep[u]=dep[fa]+1;
	f[u][0]=fa;
	Rep(i,1,19)f[u][i]=f[f[u][i-1]][i-1];
	RepG(i,u){
		int v=e[i].to;
		if(v==fa)continue;
		dfs1(v,u);
	}
}

void dfs2(int u,int fa){
	out[u]-=(a[u]+dep[u]+n>2*n)?0:buc[a[u]+dep[u]+n];
	out[u]-=ket[a[u]-dep[u]+n];
	for(list<int>::iterator it=S1[u].begin();it!=S1[u].end();it++)buc[*it]++;
	for(list<int>::iterator it=S2[u].begin();it!=S2[u].end();it++)ket[*it]++;
	RepG(i,u){
		int v=e[i].to;
		if(v==fa)continue;
		dfs2(v,u);
	}
	out[u]+=(a[u]+dep[u]+n>2*n)?0:buc[a[u]+dep[u]+n];
	out[u]+=ket[a[u]-dep[u]+n];
	for(list<int>::iterator it=S3[u].begin();it!=S3[u].end();it++)buc[*it]--;
	for(list<int>::iterator it=S4[u].begin();it!=S4[u].end();it++)ket[*it]--;
}

int main()
{
	memset(head,-1,sizeof(head));
	read(n),read(m);
	Rep(i,1,n-1){
		int x,y;
		read(x),read(y);
		add(x,y),add(y,x);
	}
	dfs1(1,0);
	Rep(i,1,n)read(a[i]);
	Rep(i,1,m){
		int x,y;
		read(x),read(y);
		int LCA=lca(x,y);
		int dis=dep[x]+dep[y]-2*dep[LCA];
		S1[x].push_back(dep[x]+n);
		S3[LCA].push_back(dep[x]+n);
		if(y==LCA)continue;
		int jy=y;
		_Rep(i,19,0)if(dep[f[jy][i]]>dep[LCA])jy=f[jy][i];
		S2[y].push_back(dis-dep[y]+n);
		S4[jy].push_back(dis-dep[y]+n);
	}
	dfs2(1,0);
	Rep(i,1,n)printf("%d ",out[i]);
	puts("");
	return 0;
}