bzoj1036 树的统计Count

第一次写链剖，于是挑了个简单的裸题写。

以下几点要注意:

1.链剖中的height是从根到该店经过的轻边个数

2.分清num与sum。。。。。

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

const int MAXN =  *  +  ;
const int MAX_SIZE =  *  +  ;
int N , Q ; 

int max_equal ( int & a , const int b ) { if ( a < b ) a = b ; return a ; }

namespace Seg {

int maxv [ MAX_SIZE *  ] ;
int sumv [ MAX_SIZE *  ] ;
int value [ MAXN ] ;
int l , r , v ; 

void maintain ( const int o ) {
    const register int o1 = o <<  , o2 = o <<  |  ;
    maxv [ o ] = max ( maxv [ o1 ] , maxv [ o2 ] ) ;
    sumv [ o ] = sumv [ o1 ] + sumv [ o2 ] ;
}

void __build ( const int o , const int L , const int R ) {
    if ( R - L ==  ) maxv [ o ] = sumv [ o ] = value [ L ] ;
    else {
        const int M = ( L + R ) /  ;
        __build ( o <<  , L , M ) ;
        __build ( o <<  |  , M , R ) ;
        maintain ( o ) ;
    }
}
void build () {
    __build (  ,  , N ) ;
}

void _modify ( const int o , const int L , const int R ) {
    if ( R - L ==  ) maxv [ o ] = sumv [ o ] = v ;
    else {
        const int M = ( L + R ) /  ;
        if ( l < M ) _modify ( o <<  , L , M ) ;
        else _modify ( o <<  |  , M , R ) ;
        maintain ( o ) ;
    }
}
void modify ( const int p , const int V ) {
    l = p ; v = V ; _modify (  ,  , N ) ;
}

void _Qmax ( const int o , const int L , const int R ) {
    if ( l <= L && R <= r ) max_equal ( v , maxv [ o ] ) ;
    else {
        const int M = ( L + R ) /  ;
        if ( l < M ) _Qmax ( o <<  , L , M ) ;
        if ( M < r ) _Qmax ( o <<  |  , M , R ) ;
    }
}
int Qmax ( int L , int R ) {
    if ( L > R ) swap ( L , R ) ;
    l = L ; r = R +  ; v = - (  <<  ) /* -INF */ ;
    _Qmax (  ,  , N ) ;
    return v ;
}

void _Qsum ( const int o , const int L , const int R ) {
    if ( l <= L && R <= r ) v += sumv [ o ] ;
    else {
        const int M = ( L + R ) /  ;
        if ( l < M ) _Qsum ( o <<  , L , M ) ;
        if ( M < r ) _Qsum ( o <<  |  , M , R ) ;
    }
}
int Qsum ( int L , int R ) {
    if ( L > R ) swap ( L , R ) ;
    l = L ; r = R +  ; v =  ;
    _Qsum (  ,  , N ) ;
    return v ;
}

}

struct edge {
    int p ;
    edge * nxt ;
} ;
edge * V [ MAXN ] ;
int value [ MAXN ] ;
edge E [ MAXN *  ] ; 

void ___add_edge ( const int a , const int b ) {
    static edge * t = E ;
    t -> p = b ; t -> nxt = V [ a ] ; V [ a ] = t ++ ;
}
void add_edge ( const int a , const int b ) {
    ___add_edge ( a , b ) ;
    ___add_edge ( b , a ) ;
}

namespace Link_cut {

    int top [ MAXN ] ;
    int num [ MAXN ] ;
    int size [ MAXN ] ;
    int height [ MAXN ] ;
    int father [ MAXN ] ;

    namespace GET_SIZE {
        int dfs ( const int o ) {
            size [ o ] =  ;
            for ( edge * i = V [ o ] ; i !=  ; i = i -> nxt )
            if ( i -> p != father [ o ] ) {
                father [ i -> p ] = o ;
                size [ o ] += dfs ( i -> p ) ;
            }
            return size [ o ] ;
        }
    }
    void Get_size () { father [  ] =  ; GET_SIZE :: dfs (  ) ; }  

    namespace LINK_CUT {
        void dfs ( const int o , const int t , const int h ) {
            if ( o <  ) return ;
            else {
                static int dfs_clock =  ;
                top [ o ] = t ;
                num [ o ] = dfs_clock ++ ;
                height [ o ] = h ;
                int max_size_value = - , max_size_node = - ;
                for ( edge * i = V [ o ] ; i !=  ; i = i -> nxt )
                if ( i -> p != father [ o ] && max_size_value < size [ i -> p ] ) {
                    max_size_value = size [ i -> p ] ;
                    max_size_node = i -> p ;
                }
                dfs ( max_size_node , t , h ) ;
                for ( edge * i = V [ o ] ; i !=  ; i = i -> nxt )
                if ( i -> p != father [ o ] && i -> p != max_size_node ) dfs ( i -> p , i -> p , h +  ) ;
            }
        }
    }

    void cut_link ( ) {
        LINK_CUT :: dfs (  ,  ,  ) ;
        for ( int i =  ; i < N ; ++ i ) Seg :: value [ num [ i ] ] = :: value [ i ] ;
        Seg :: build () ;
    }

    void modify ( const int p , const int v ) {
        Seg :: modify ( num [ p ] , v ) ;
    }

    int Qsum ( int a , int b ) {
        int v =  ;
        while ( top [ a ] != top [ b ] ) {
            if ( height [ a ] < height [ b ] ) swap ( a , b ) ;
            v += Seg :: Qsum ( num [ a ] , num [ top [ a ] ] ) ;
            a = father [ top [ a ] ] ;
        }
        v += Seg :: Qsum ( num [ a ] , num [ b ] ) ;
        return v ;
    }

    int Qmax ( int a , int b ) {
        int v = -(  <<  ) ;
        while ( top [ a ] != top [ b ] ) {
            if ( height [ a ] < height [ b ] ) swap ( a , b ) ;
            max_equal ( v , Seg :: Qmax ( num [ a ] , num [ top [ a ] ] ) ) ;
            a = father [ top [ a ] ] ;
        }
        max_equal ( v , Seg :: Qmax ( num [ a ] , num [ b ] ) ) ;
        return v ;
    }

}

char c [  ] ;
int main () {
    scanf ( "%d" , & N ) ;
    for ( int i =  ; i < N ; ++ i ) {
        int a , b ;
        scanf ( "%d%d" , & a , & b ) ;
        add_edge ( a -  , b -  ) ;
    }
    for ( int i =  ; i < N ; ++ i ) scanf ( "%d" , & value [ i ] ) ;
    Link_cut :: Get_size () ;
    Link_cut :: cut_link () ;

    scanf ( "%d" , & Q ) ;
    for ( int i =  ; i < Q ; ++ i ) {
        int a , b ;
        scanf ( "%s%d%d" , c , & a , & b ) ;
        switch ( c [  ] ) {
            case 'H' :
                Link_cut :: modify ( a -  , b ) ;
                break ;
            case 'M' :
                printf ( "%d\n" , Link_cut :: Qmax ( a -  , b -  ) ) ;
                break ;
            case 'S' :
                printf ( "%d\n" , Link_cut :: Qsum ( a -  , b -  ) ) ;
                break ;
        }
    }

    return  ;
}

本博客禁止转载，转载请先联系作者，谢谢。

原地址：http://www.cnblogs.com/Christopher-Cao/p/5186126.html

如发现与文章与地址不同，请通过博客联系作者