[USACO12DEC] 逃跑的BarnRunning Away From…(主席树)

[USACO12DEC]逃跑的BarnRunning Away From…

题目描述

It's milking time at Farmer John's farm, but the cows have all run away! Farmer John needs to round them all up, and needs your help in the search.

FJ's farm is a series of N (1 <= N <= 200,000) pastures numbered 1...N connected by N - 1 bidirectional paths. The barn is located at pasture 1, and it is possible to reach any pasture from the barn.

FJ's cows were in their pastures this morning, but who knows where they ran to by now. FJ does know that the cows only run away from the barn, and they are too lazy to run a distance of more than L. For every pasture, FJ wants to know how many different pastures cows starting in that pasture could have ended up in.

Note: 64-bit integers (int64 in Pascal, long long in C/C++ and long in Java) are needed to store the distance values.

给出以1号点为根的一棵有根树，问每个点的子树中与它距离小于等于l的点有多少个。

输入输出格式

输入格式：

• Line 1: 2 integers, N and L (1 <= N <= 200,000, 1 <= L <= 10^18)

• Lines 2..N: The ith line contains two integers p_i and l_i. p_i (1 <= p_i < i) is the first pasture on the shortest path between pasture i and the barn, and l_i (1 <= l_i <= 10^12) is the length of that path.

输出格式：

• Lines 1..N: One number per line, the number on line i is the number pastures that can be reached from pasture i by taking roads that lead strictly farther away from the barn (pasture 1) whose total length does not exceed L.

输入输出样例

输入样例#1：

4 5

1 4

2 3

1 5

输出样例#1：

3

2

1

1

说明

Cows from pasture 1 can hide at pastures 1, 2, and 4.

Cows from pasture 2 can hide at pastures 2 and 3.

Pasture 3 and 4 are as far from the barn as possible, and the cows can hide there.

Solution

这道题做法也是千千万万...倍增+差分/左偏树/主席树/...

蒟蒻我写的主席树

左偏树只写过一道题,所以对这道题思路不是很熟,稍微讲一下倍增+差分的思路吧,我们要找到一个点的子树中距离小于等于L的节点的个数,最朴素的做法就是暴力查找,找到一个打标记,但是这样的优化空间很大,寻找我们可以用倍增优化,标记可以差分,时间复杂度\(O(nlogn)\)

---

下面是主席树的思路,我们要寻找一个节点\(u\)子树中距离小于等于L的节点\(v\)的个数,即需要满足这样的条件:\(dis[v]-dis[u]<=L\to dis[u]>=dis[v]+L\)

问题就转化成了求子树内小于一个值的个数,主席树啊

对权值建树....

注意:dis[v]+L不一定在原序列中出现过,所以我们用upper_bound,找的时候就变成严格<才统计答案,最后为了一定能找到,我们在序列的末尾加一个inf

Code

#include<bits/stdc++.h>
#define mid ((l+r)>>1)
#define in(i) (i=read())
#define lol long long
using namespace std;

const lol N=2e5+10,inf=2e15;

lol read()
{
    lol ans=0,f=1; char i=getchar();
    while(i<'0' || i>'9') {if(i=='-') f=-1; i=getchar();}
    while(i>='0' && i<='9') ans=(ans<<1)+(ans<<3)+i-'0',i=getchar();
    return ans*f;
}

lol n,m,cur,tot,dfscnt,L;
lol head[N],nex[N<<1],to[N<<1],w[N<<1];
lol a[N],b[N],inc[N],ouc[N],rt[N];

struct Chair_Tree {
    lol l,r,v;
}t[N<<5];

void add(lol a,lol b,lol c) {
    to[++cur]=b,nex[cur]=head[a],w[cur]=c,head[a]=cur;
    to[++cur]=a,nex[cur]=head[b],w[cur]=c,head[b]=cur;
} 

void insert(lol &u,lol l,lol r,lol pre,lol p) {
    t[u=++tot]=t[pre], t[u].v++;
    if(l==r) return;
    if(p<=mid) insert(t[u].l,l,mid,t[pre].l,p);
    else insert(t[u].r,mid+1,r,t[pre].r,p);
}

lol query(lol u,lol v,lol l,lol r,lol k) {
    if(r<k) return t[v].v-t[u].v;
    if(l>=k) return 0;
    if(k<=mid) return query(t[u].l,t[v].l,l,mid,k);
    else return query(t[u].r,t[v].r,mid+1,r,k)+t[t[v].l].v-t[t[u].l].v;
}

void init(lol u,lol fa,lol now) {
    inc[u]=++dfscnt, a[++m]=b[m]=now;
    for (lol i=head[u];i;i=nex[i]) {
        if(to[i]==fa) continue;
        init(to[i],u,now+w[i]);
    }ouc[u]=dfscnt;
}

int main()
{
    in(n), in(L);
    for (lol i=2,f,c;i<=n;i++)
        in(f), in(c), add(i,f,c);
    init(1,0,0);
    sort(b+1,b+1+m); m=unique(b+1,b+1+m)-b-1;
    for (lol i=1;i<=n;i++) {
        lol p=lower_bound(b+1,b+1+m,a[i])-b;
        insert(rt[i],1,m,rt[i-1],p);
    }
    b[m+1]=inf;
    for (lol i=1,ans;i<=n;i++) {
        lol k=upper_bound(b+1,b+2+m,a[inc[i]]+L)-b;
        ans=query(rt[inc[i]-1],rt[ouc[i]],1,m,k);
        printf("%lld\n",ans);
    }
}