bzoj3011 可并堆

我们可以遍历得出每个节点到根节点的距离h,然后用可并堆进行维护。树形dp

我用的是pairing heap

 #include<cstdio>
 #include<algorithm>
 #include<queue>
 using namespace std ; 

 struct node {
     long long value ;
     node * brother ;
     node * child ;
     node ( const long long value ) : value ( value ) ,
     brother (  ) , child (  ) {} ;
 } ;

 node * merge ( node * a , node * b ) {
     if ( a ==  ) return b ;
     if ( b ==  ) return a ;
     if ( a -> value < b -> value ) swap ( a , b ) ;
     b -> brother = a -> child ;
     a -> child = b ;
     a -> brother =  ;
     return a ;
 }

 node * pop ( node * a ) {
     node * o = a -> child ;
     delete a ;
     if ( o ==  ) return  ;
     static queue < node * > q ;
     while ( ! q . empty () ) q . pop () ;
     while ( o ) {
         q . push ( o ) ;
         o = o -> brother ;
     }
     while ( q . size () > 1u ) {
         node * a = q . front () ;
         q . pop () ;
         node * b = q . front () ;
         q . pop () ;
         q . push ( merge ( a , b ) ) ;
     }
     return q . front () ;
 }

 const int MAXN =  +  ;
 int pa [ MAXN ] ;
 long long l [ MAXN ] ;
 long long h [ MAXN ] ;
 int size [ MAXN ] ;
 int N ;
 long long L ;
 node * heap [ MAXN ] ;

 int main () {
     scanf ( "%d%lld" , & N , & L ) ;
     for ( int i =  ; i <= N ; ++ i )
         scanf ( "%d%lld" , & pa [ i ] , & l [ i ] ) ;
     for ( int i =  ; i <= N ; ++ i ) h [ i ] = l [ i ] + h [ pa [ i ] ] ;
     for ( int i =  ; i <= N ; ++ i ) {
         heap [ i ] = new node ( h [ i ] ) ;
         size [ i ] =  ;
     }
     for ( int i = N ; i >=  ; -- i ) {
         while ( heap [ i ] -> value - h [ i ] > L ) {
             heap [ i ] = pop ( heap [ i ] ) ;
             size [ i ] -- ;
         }
         heap [ pa [ i ] ] = merge ( heap [ pa [ i ] ] , heap [ i ] ) ;
         size [ pa [ i ] ] += size [ i ] ;
     }
     while ( heap [  ] -> value - h [  ] > L ) {
         heap [  ] = pop ( heap [  ] ) ;
         size [  ] -- ;
     }
     for ( int i =  ; i <= N ; ++ i )
         printf ( "%d\n" , size [ i ] ) ;
     return  ;
 }