[bzoj4719][树链剖分][Noip2016]天天爱跑步

4719: [Noip2016]天天爱跑步

Time Limit: 40 Sec Memory Limit: 512 MB
Submit: 1022 Solved: 342
[Submit][Status][Discuss]
Description

小c同学认为跑步非常有趣,于是决定制作一款叫做《天天爱跑步》的游戏。?天天爱跑步?是一个养成类游戏,需要
玩家每天按时上线,完成打卡任务。这个游戏的地图可以看作一一棵包含 N个结点和N-1 条边的树, 每条边连接两
个结点,且任意两个结点存在一条路径互相可达。树上结点编号为从1到N的连续正整数。现在有个玩家,第个玩家的
起点为Si ,终点为Ti 。每天打卡任务开始时,所有玩家在第0秒同时从自己的起点出发, 以每秒跑一条边的速度,
不间断地沿着最短路径向着自己的终点跑去, 跑到终点后该玩家就算完成了打卡任务。 (由于地图是一棵树, 所以
每个人的路径是唯一的)小C想知道游戏的活跃度, 所以在每个结点上都放置了一个观察员。 在结点的观察员会选
择在第Wj秒观察玩家, 一个玩家能被这个观察员观察到当且仅当该玩家在第Wj秒也理到达了结点J 。 小C想知道
每个观察员会观察到多少人?注意: 我们认为一个玩家到达自己的终点后该玩家就会结束游戏, 他不能等待一 段时
间后再被观察员观察到。 即对于把结点J作为终点的玩家: 若他在第Wj秒重到达终点,则在结点J的观察员不能观察
到该玩家;若他正好在第Wj秒到达终点,则在结点的观察员可以观察到这个玩家。
Input

第一行有两个整数N和M 。其中N代表树的结点数量, 同时也是观察员的数量, M代表玩家的数量。
接下来n-1 行每行两个整数U和V ,表示结点U 到结点V 有一条边。
接下来一行N 个整数,其中第个整数为Wj , 表示结点出现观察员的时间。
接下来 M行,每行两个整数Si和Ti,表示一个玩家的起点和终点。
对于所有的数据,保证 。
1<=Si,Ti<=N,0<=Wj<=N
Output

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

Sample Input

6 3

2 3

1 2

1 4

4 5

4 6

0 2 5 1 2 3

1 5

1 3

2 6
Sample Output

2 0 0 1 1 1
HINT

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

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

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

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

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

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

Source

sol:
树剖是用来求lca的，顺便找到了个新板子
这题发现对观察者有贡献的点是有特点的，然后我们查询能够提供贡献的点中在子树里的有多少个即可。实现使用差分加上权值线段树。

#include<cstdio>
#include<algorithm>
#include<string>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<iostream>
using namespace std;
int n,m;
inline int read()
{
    char c;
    int res,flag=0;
    while((c=getchar())>'9'||c<'0') if(c=='-')flag=1;
    res=c-'0';
    while((c=getchar())>='0'&&c<='9') res=(res<<3)+(res<<1)+c-'0';
    return flag?-res:res;
}
const int N=310000;
const int M=9000000;
int fa[N],size[N],deep[N],bl[N],sz,id[N],ans[N];
int dfs[N],watch[N],son[N];
int fir[N],nex[N*2],go[N*2];
int root[N*3],lc[M],rc[M],sum[M],tot,cnt;
struct node
{
    int s,t,lca;
}a[N];
void add(int u,int v)
{
    nex[++cnt]=fir[u];fir[u]=cnt;go[cnt]=v;
    nex[++cnt]=fir[v];fir[v]=cnt;go[cnt]=u;
}
void dfs1(int u)
{
    int v;
    size[u]=1;
    for(int e=fir[u];e,v=go[e];e=nex[e])
    if(v!=fa[u])
    {
        deep[v]=deep[u]+1;
        fa[v]=u;
        dfs1(v);
        size[u]+=size[v];
        if(size[v]>size[son[u]]) son[u]=v;
    }
}
void dfs2(int u,int top)
{
    int v;
    id[u]=++sz;
    dfs[u]=sz;
    bl[u]=top;
    if(son[u]) dfs2(son[u],top);
    else return;
    for(int e=fir[u];e,v=go[e];e=nex[e])
    if(v!=fa[u]&&v!=son[u]) dfs2(v,v);
}
int Lca(int u,int v)
{
    while(bl[u]!=bl[v])
    {
        if(deep[bl[u]]<deep[bl[v]]) swap(u,v);
        u=fa[bl[u]];
    }
    return deep[u]<deep[v]?u:v;
}
void change(int &now,int l,int r,int pos,int w)
{
    if(!pos) return;
    if(!now) now=++tot;
    sum[now]+=w;
    if(l==r) return;
    int mid=l+r>>1;
    if(pos<=mid) change(lc[now],l,mid,pos,w);
    else change(rc[now],mid+1,r,pos,w);
}
int query(int now,int l,int r,int L,int R)
{
    if(!now) return 0;
    if(l==L&&r==R) return sum[now];
    int mid=l+r>>1;
    if(R<=mid) return query(lc[now],l,mid,L,R);
    else if(L>mid) return query(rc[now],mid+1,r,L,R);
    else return query(lc[now],l,mid,L,mid)+query(rc[now],mid+1,r,mid+1,R);
}
int main()
{
//  freopen("4719.in","r",stdin);
//  freopen(".out","w",stdout);
    n=read();
    m=read();
    int x,y;
    for(int i=1;i<n;i++)
    {
        x=read();
        y=read();
        add(x,y);
    }
    for(int i=1;i<=n;i++) watch[i]=read();
    for(int i=1;i<=m;i++)
    {
        a[i].s=read();
        a[i].t=read();
    }
    dfs1(1);
    dfs2(1,0);
    for(int i=1;i<=m;i++)
        a[i].lca=Lca(a[i].s,a[i].t);
    int now;
    for(int i=1;i<=m;i++)
    {
        now=deep[a[i].s];
        change(root[now],1,n,id[a[i].s],1);
        change(root[now],1,n,id[fa[a[i].lca]],-1);
    }
    for(int i=1;i<=n;i++)
        ans[i]=query(root[deep[i]+watch[i]],1,n,dfs[i],dfs[i]+size[i]-1);
    tot=0;//记得清零数组 
    memset(lc,0,sizeof(lc));
    memset(rc,0,sizeof(rc));
    memset(sum,0,sizeof(sum));
    memset(root,0,sizeof(root));
    for(int i=1;i<=m;i++) 
    {
        now=deep[a[i].s]-deep[a[i].lca]*2+n*2;
        change(root[now],1,n,id[a[i].t],1);
        change(root[now],1,n,id[a[i].lca],-1);//链的时候别算重了 
    }
    for(int i=1;i<=n;i++)
        ans[i]+=query(root[watch[i]-deep[i]+n*2],1,n,dfs[i],dfs[i]+size[i]-1);
    for(int i=1;i<n;i++)
        printf("%d ",ans[i]);
    printf("%d",ans[n]);//bzoj的PE真的有毒 
}