bzoj3064 CPU监控

今天终于写了一道正常的题

思路是这样的:

1.普通线段树add,set不变，并改为下放标记版本

2.past_addv 记录一个区间内可能的addv值的最大值

3.past_setv 记录一个区间被set的最大值

4.maxv与past_maxv为值

代码风格导致比较长

#include<cstdio>
#include<climits>
#include<cctype>
#include<algorithm>

using std :: max ;

const int MAXN = 1024 * 128 + 20 ;
const int NONE = INT_MIN ;
int N ;

void max_equal ( int & a , const int b ) {
    if ( b > a ) a = b ;
}

int get_int () {
    int v ;
    scanf ( "%d" , & v ) ;
    return v ;
}

int addv [ MAXN * 2 ] ;
int setv [ MAXN * 2 ] ;
int maxv [ MAXN * 2 ] ;

int past_addv [ MAXN * 2 ] ;
int past_setv [ MAXN * 2 ] ;
int past_maxv [ MAXN * 2 ] ; 

void M_add ( const int o , const int v ) {
    if ( setv [ o ] != NONE ) {
        setv [ o ] += v ; max_equal ( past_setv [ o ] , setv [ o ] ) ;
    } else {
        addv [ o ] += v ; max_equal ( past_addv [ o ] , addv [ o ] ) ;
    }
}

void M_set ( const int o , const int v ) {
    setv [ o ] = v ; max_equal ( past_setv [ o ] , setv [ o ] ) ;
}

void P_add ( const int o , const int v ) {
    if ( setv [ o ] != NONE ) {
        max_equal ( past_setv [ o ] , setv [ o ] + v ) ;
    } else {
        max_equal ( past_addv [ o ] , addv [ o ] + v ) ;
    }
}

void P_set ( const int o , const int v ) {
    max_equal ( past_setv [ o ] , v ) ;
}

void push_down ( const int o ) {
    const int o1 = o << 1 ;
    const int o2 = o << 1 | 1 ; 
    if ( past_addv [ o ] ) {
        P_add ( o1 , past_addv [ o ] ) ;
        P_add ( o2 , past_addv [ o ] ) ;
        past_addv [ o ] = 0 ;
    }
    if ( addv [ o ] ) {
        M_add ( o1 , addv [ o ] ) ;
        M_add ( o2 , addv [ o ] ) ;
        addv [ o ] = 0 ;
    }
    if ( past_setv [ o ] != NONE ) {
        P_set ( o1 , past_setv [ o ] ) ;
        P_set ( o2 , past_setv [ o ] ) ;
        past_setv [ o ] = NONE ;
    }
    if ( setv [ o ] != NONE ) {
        M_set ( o1 , setv [ o ] ) ;
        M_set ( o2 , setv [ o ] ) ;
        setv [ o ] = NONE ;
    }
}

void maintain ( const int o , const int L , const int R ) {
    const int o1 = o << 1 ;
    const int o2 = o << 1 | 1 ;
    if ( R - L == 1 ) {
        maxv [ o ] = setv [ o ] ;
        max_equal ( past_maxv [ o ] , past_setv [ o ] ) ; 
    } else {
        maxv [ o ] = 
            ( setv [ o ] == NONE ) ? max ( maxv [ o1 ] , maxv [ o2 ] ) + addv [ o ] : setv [ o ] ;
        max_equal ( past_maxv [ o ] , past_setv [ o ] ) ;
        max_equal ( past_maxv [ o ] , max ( maxv [ o1 ] , maxv [ o2 ] ) + past_addv [ o ] ) ;
        max_equal ( past_maxv [ o ] , max ( past_maxv [ o1 ] , past_maxv [ o2 ] ) ) ;
    }
}

static struct {
    void W ( const int o , const int L , const int R ) {
        setv [ o ] = past_setv [ o ] = maxv [ o ] = past_maxv [ o ] = NONE ;
        addv [ o ] = past_addv [ o ] = 0 ;
        if ( R - L == 1 ) {
            M_set ( o , get_int () ) ;
        } else {
            const int M = ( L + R ) >> 1 ;
            W ( o << 1 , L , M ) ;
            W ( o << 1 | 1 , M , R ) ;
        }
        maintain ( o , L , R ) ;
    }
    void operator ( ) ( ) {
        scanf ( "%d" , & N ) ;
        W ( 1 , 1 , N + 1 ) ;
    }
} Build ;


static struct {
    int l , r , v ;
    void W ( const int o , const int L , const int R ) {
        if ( l <= L && R <= r ) {
            M_set ( o , v ) ;
        } else {
            const int M = ( L + R ) >> 1 ;
            push_down ( o ) ;
            if ( l < M ) W ( o << 1 , L , M ) ; else maintain ( o << 1 , L , M ) ;
            if ( M < r ) W ( o << 1 | 1 , M , R ) ; else maintain ( o << 1 | 1 , M , R ) ;
        }
        maintain ( o , L , R ) ;
    }
    void operator () ( const int L , const int R , const int V ) {
        l = L ; r = R + 1 ; v = V ;
        W ( 1 , 1 , N + 1 ) ;
    }
} Set ;

static struct {
    int l , r , v ;
    void W ( const int o , const int L , const int R ) {
        if ( l <= L && R <= r ) {
            M_add ( o , v ) ;
        } else {
            const int M = ( L + R ) >> 1 ;
            push_down ( o ) ;
            if ( l < M ) W ( o << 1 , L , M ) ; else maintain ( o << 1 , L , M ) ;
            if ( M < r ) W ( o << 1 | 1 , M , R ) ; else maintain ( o << 1 | 1 , M , R ) ;
        }
        maintain ( o , L , R ) ;
    }
    void operator () ( const int L , const int R , const int V ) {
        l = L ; r = R + 1 ; v = V ;
        W ( 1 , 1 , N + 1 ) ;
    }
} Add ;

static struct {
    int l , r , ans ;
    void W ( const int o , const int L , const int R ) {
        if ( l <= L && R <= r ) {
            max_equal ( ans , maxv [ o ] ) ;
        } else {
            const int M = ( L + R ) >> 1 ;
            push_down ( o ) ; 
            maintain ( o << 1 , L , M ) ;
            maintain ( o << 1 | 1 , M  , R ) ;
            if ( l < M ) W ( o << 1 , L , M ) ;
            if ( M < r ) W ( o << 1 | 1 , M , R ) ;
        }
    }
    int operator () ( const int L , const int R ) {
        l = L ;  r = R + 1 ; ans = NONE ;
        W ( 1 , 1 , N + 1 ) ;
        return ans ;
    }
} Qmax ;

static struct {
    int l , r , ans ;
    void W ( const int o , const int L , const int R ) {
        if ( l <= L && R <= r ) {
            max_equal ( ans , past_maxv [ o ] ) ;
        } else {
            const int M = ( L + R ) >> 1 ;
            push_down ( o ) ; 
            maintain ( o << 1 , L , M ) ;
            maintain ( o << 1 | 1 , M  , R ) ;
            if ( l < M ) W ( o << 1 , L , M ) ;
            if ( M < r ) W ( o << 1 | 1 , M , R ) ;
        }
    }
    int operator () ( const int L , const int R ) {
        l = L ;  r = R + 1 ; ans = NONE ;
        W ( 1 , 1 , N + 1 ) ;
        return ans ;
    }
} Q_past_max ;

int T , E , opt , X , Y , Z ;
int main () {
    Build ( ) ;
    scanf ( "%d" , & E ) ;
    while ( E -- ) {
        while ( isspace ( opt = getchar () ) ) ;
        switch ( opt ) {
            case 'Q' :
                scanf ( "%d%d" , & X , & Y ) ;
                printf ( "%d
" , Qmax ( X , Y ) ) ;
                break ;
            case 'A' :
                scanf ( "%d%d" , & X , & Y ) ;
                printf ( "%d
" , Q_past_max ( X , Y ) ) ;
                break ;
            case 'P' :
                scanf ( "%d%d%d" , & X , & Y , & Z ) ;
                Add ( X , Y , Z ) ;
                break ;
            case 'C' :
                scanf ( "%d%d%d" , & X , & Y , & Z ) ;
                Set ( X , Y , Z ) ;
                break ;
        }
    }
    return 0 ;
}