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真的有毒 
}