[USACO 12DEC]Running Away From the Barn

Description

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的点有多少个。

Input

• 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.

Output

• 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.

Sample Input

4 5
1 4
2 3
1 5

Sample Output

3
2
1
1

Hint

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$求出根节点到各个节点的距离，再按逆$Dfs$时间戳顺序进行操作（为了使得处理的当前节点的所有子节点均被处理过，至于为何不正向，就不解释了）

建大根堆，每次做完合并操作后，将不可行的边从堆中弹出（即堆顶所表示的点到当前点的距离$>L$（同时以操作顺序为前提的条件下必有“相距距离=两点到根节点的距离差”））

另一个需要解决的问题就是如何求解，我们可以按逆$Dfs$序模拟一个回溯过程：将所以$pop$掉的值和其子节点的值累加，再相减即可。

 #include<cmath>
 #include<queue>
 #include<stack>
 #include<ctime>
 #include<cstdio>
 #include<string>
 #include<cstdlib>
 #include<iostream>
 #include<algorithm>
  using namespace std;
 const long long N=;
 struct tt
 {
     long long cost,next,to;
 }edge[*N+];//保存边的信息
 long long path[N+],top;
 struct node
 {
     long long key,dist;
     node *l,*r;
     long long ldist() {return l ? l->dist:-;}
     long long rdist() {return r ? r->dist:-;}
 }T[N+],*root[N+];//T[i]表示节点i的相关信息;root[i]表示序号为i的节点所在堆的根的地址
 long long n,l,a,b;
 long long remain[N+],tail,Rank[N+];//remain[]表示逆Dfs顺序,tail表示remain[]的大小;Rank[]表示Bfs序
 long long popnum[N+],cnt[N+];//popnum[i]保存在i节点时,弹出元素的数量 cnt[i]表示以i为根，其子树节点数量(不含根节点)
 void Add(long long x,long long y,long long cost);
 void Dfs(long long x);
 node* Merge(node* a,node* b);
 int main()
 {
     scanf("%lld%lld",&n,&l);
     for (long long i=;i<=n;i++)
     {
         scanf("%lld%lld",&a,&b);
         Add(a,i,b);
         Add(i,a,b);

 }//连双向边,正向用于Dfs用,逆向用于求解用

     Rank[]=;
     Dfs();
     for (long long i=;i<=tail;i++)
     {
         for (long long j=path[remain[i]];j;j=edge[j].next)
         {
             if (Rank[remain[i]]==Rank[edge[j].to]+)//找到前驱节点
             {
                 root[edge[j].to]=Merge(root[remain[i]],root[edge[j].to]);//将当前节点构成的堆并入前驱节点
                 while(root[edge[j].to]->key-T[edge[j].to].key>l)//弹出
                 {
                     popnum[edge[j].to]++;
                     root[edge[j].to]=Merge(root[edge[j].to]->l,root[edge[j].to]->r);
                 }
             }
         }
     }
     for (long long i=;i<=tail;i++) //对最终答案数据的处理
     {
         for (long long j=path[remain[i]];j;j=edge[j].next)
         {
             if (Rank[remain[i]]==Rank[edge[j].to]+)
             {
                 cnt[edge[j].to]+=cnt[remain[i]]+;
                 popnum[edge[j].to]+=popnum[remain[i]];
             }
         }
     }
     for (long long i=;i<=n;i++) printf("%lld\n",cnt[i]+-popnum[i]);
     return ;
 }
 void Add(long long x,long long y,long long cost)
 {
     edge[++top].to=y;
     edge[top].cost=cost;
     edge[top].next=path[x];
     path[x]=top;
 }
 void Dfs(long long x)
 {
     root[x]=x+T;
     for (long long i=path[x];i;i=edge[i].next) if (!Rank[edge[i].to])
     {
         Rank[edge[i].to]=Rank[x]+;
         T[edge[i].to].key=T[x].key+edge[i].cost;//key保存的是根节点到该点的距离
         Dfs(edge[i].to);
     }
     remain[++tail]=x;
 }
 node* Merge(node* a,node* b)
 {
     if (!a||!b) return a ? a:b;
     if (a->key<b->key) swap(a,b);
     a->r=Merge(a->r,b);
     if (a->ldist()<a->rdist()) swap(a->l,a->r);
     a->dist=a->rdist()+;
     return a;
 }