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 =  *  +  ;
 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 *  ] ;
 int setv [ MAXN *  ] ;
 int maxv [ MAXN *  ] ;

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

 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 <<  ;
     const int o2 = o <<  |  ;
     if ( past_addv [ o ] ) {
         P_add ( o1 , past_addv [ o ] ) ;
         P_add ( o2 , past_addv [ o ] ) ;
         past_addv [ o ] =  ;
     }
     if ( addv [ o ] ) {
         M_add ( o1 , addv [ o ] ) ;
         M_add ( o2 , addv [ o ] ) ;
         addv [ o ] =  ;
     }
     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 <<  ;
     const int o2 = o <<  |  ;
     if ( R - L ==  ) {
         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 ] =  ;
         if ( R - L ==  ) {
             M_set ( o , get_int () ) ;
         } else {
             const int M = ( L + R ) >>  ;
             W ( o <<  , L , M ) ;
             W ( o <<  |  , M , R ) ;
         }
         maintain ( o , L , R ) ;
     }
     void operator ( ) ( ) {
         scanf ( "%d" , & N ) ;
         W (  ,  , N +  ) ;
     }
 } 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 ) >>  ;
             push_down ( o ) ;
             if ( l < M ) W ( o <<  , L , M ) ; else maintain ( o <<  , L , M ) ;
             if ( M < r ) W ( o <<  |  , M , R ) ; else maintain ( o <<  |  , M , R ) ;
         }
         maintain ( o , L , R ) ;
     }
     void operator () ( const int L , const int R , const int V ) {
         l = L ; r = R +  ; v = V ;
         W (  ,  , N +  ) ;
     }
 } 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 ) >>  ;
             push_down ( o ) ;
             if ( l < M ) W ( o <<  , L , M ) ; else maintain ( o <<  , L , M ) ;
             if ( M < r ) W ( o <<  |  , M , R ) ; else maintain ( o <<  |  , M , R ) ;
         }
         maintain ( o , L , R ) ;
     }
     void operator () ( const int L , const int R , const int V ) {
         l = L ; r = R +  ; v = V ;
         W (  ,  , N +  ) ;
     }
 } 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 ) >>  ;
             push_down ( o ) ;
             maintain ( o <<  , L , M ) ;
             maintain ( o <<  |  , M  , R ) ;
             if ( l < M ) W ( o <<  , L , M ) ;
             if ( M < r ) W ( o <<  |  , M , R ) ;
         }
     }
     int operator () ( const int L , const int R ) {
         l = L ;  r = R +  ; ans = NONE ;
         W (  ,  , N +  ) ;
         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 ) >>  ;
             push_down ( o ) ;
             maintain ( o <<  , L , M ) ;
             maintain ( o <<  |  , M  , R ) ;
             if ( l < M ) W ( o <<  , L , M ) ;
             if ( M < r ) W ( o <<  |  , M , R ) ;
         }
     }
     int operator () ( const int L , const int R ) {
         l = L ;  r = R +  ; ans = NONE ;
         W (  ,  , N +  ) ;
         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\n" , Qmax ( X , Y ) ) ;
                 break ;
             case 'A' :
                 scanf ( "%d%d" , & X , & Y ) ;
                 printf ( "%d\n" , 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  ;
 }