题目描述
小c同学认为跑步非常有趣,于是决定制作一款叫做《天天爱跑步》的游戏。«天天爱跑步»是一个养成类游戏,需要玩家每天按时上线,完成打卡任务。
这个游戏的地图可以看作一一棵包含 n个结点和 n−1条边的树, 每条边连接两个结点,且任意两个结点存在一条路径互相可达。树上结点编号为从1到n的连续正整数。
现在有m个玩家,第i个玩家的起点为 Si,终点为 Ti 。每天打卡任务开始时,所有玩家在第0秒同时从自己的起点出发, 以每秒跑一条边的速度, 不间断地沿着最短路径向着自己的终点跑去, 跑到终点后该玩家就算完成了打卡任务。 (由于地图是一棵树, 所以每个人的路径是唯一的)
小C想知道游戏的活跃度, 所以在每个结点上都放置了一个观察员。 在结点j的观察员会选择在第Wj秒观察玩家, 一个玩家能被这个观察员观察到当且仅当该玩家在第Wj秒也理到达了结点 j 。 小C想知道每个观察员会观察到多少人?
注意: 我们认为一个玩家到达自己的终点后该玩家就会结束游戏, 他不能等待一 段时间后再被观察员观察到。 即对于把结点j作为终点的玩家: 若他在第Wj秒重到达终点,则在结点j的观察员不能观察到该玩家;若他正好在第Wj秒到达终点,则在结点j的观察员可以观察到这个玩家。
输入输出格式
输入格式：
第一行有两个整数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的观察员可以观察到多少人。
输入输出样例
6 3 2 3 1 2 1 4 4 5 4 6 0 2 5 1 2 3 1 5 1 3 2 6
2 0 0 1 1 1
5 3 1 2 2 3 2 4 1 5 0 1 0 3 0 3 1 1 4 5 5
1 2 1 0 1
说明
【样例1说明】
对于1号点，Wi=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
会因为栈溢出而崩溃； 如果使用了上述命令后运行该程序，该程序则不会崩溃。
特别地， 当你打开多个终端时， 它们并不会共享该命令， 你需要分别对它们
运行该命令。
请注意， 调用栈占用的空间会计入总空间占用中， 和程序其他部分占用的内
存共同受到内存限制。
题解
25分算法
S为根节点部分分
T为根节点
退化为链部分分
满分算法
#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
",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("
");
}
int main(){
init();
focus();
tarjan_lca();
dfs(rt,0);
print();
return 0;
}