洛谷P3066 [USACO12DEC] 逃跑的Barn [左偏树]

　　题目传送门

逃跑的Barn

题目描述

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.

 

---

　　分析：

　　一句话：左偏树。

　　做多了这类题目的话，这题也就不难想。从根节点向下$DFS$，然后递归回溯，到达某个结点时就把它和它的子树构成的左偏树合并，这里左偏树维护的权值是该点到根节点的距离，判断的时候用类似于前缀和的思想就行了。

　　Code：

 

//It is made by HolseLee on 28th Aug 2018
//Luogu.org P3066
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<iostream>
#include<iomanip>
#include<algorithm>
using namespace std;

typedef long long ll;
const int N=2e5+7;
int n,ans[N],nxt[N],head[N],to[N],cnte,rt[N];
ll m,v[N];
struct Leftist{
    int ch[N][2],dis[N],siz[N];
    ll val[N];

    int merge(int x,int y)
    {
        if( !x || !y )return x+y;
        if( val[x]<val[y] || (val[x]==val[y] && x<y) )
        swap(x,y);
        int &ul=ch[x][0], &ur=ch[x][1];
        ur=merge(ur,y);
        if( dis[ur]>dis[ul] ) swap(ur,ul);
        dis[x]=dis[ur]+1;
        siz[x]=siz[ur]+siz[ul]+1;
        return x;
    }

    inline int delet(int x)
    {
        return merge(ch[x][0],ch[x][1]);
    }
}T;

template<typename re>
inline void read(re &x)
{
    x=0; char ch=getchar(); bool flag=false;
    while( ch<'0'||ch>'9' ) {
        if( ch=='-' )flag=true;
        ch=getchar();
    }
    while( ch>='0'&&ch<='9' ) {
        x=(x<<1)+(x<<3)+(ch^48);
        ch=getchar();
    }
    x=flag?-x:x;
}

void dfs(int u,ll now)
{
    rt[u]=u;
    T.val[u]=now, T.siz[u]=1, T.dis[u]=0;
    T.ch[u][0]=T.ch[u][1]=0;
    for(int i=head[u]; i; i=nxt[i]) {
        dfs(to[i],now+v[i]);
        rt[u]=T.merge(rt[u],rt[to[i]]);
    }
    while( rt[u] && (T.val[rt[u]]-now)>m ) rt[u]=T.delet(rt[u]);
    ans[u]=T.siz[rt[u]];
}

int main()
{
    read(n); read(m);
    int x; ll y;
    for(int i=2; i<=n; ++i) {
        read(x); read(y);
        to[++cnte]=i;v[cnte]=y;
        nxt[cnte]=head[x];head[x]=cnte;
    }
    dfs(1,0);
    for(int i=1;i<=n;++i)printf("%d\n",ans[i]);
    return 0;
}

 

转载于:https://www.cnblogs.com/cytus/p/9547476.html