HDU 3954 Level up （线段树特殊懒惰标记）

http://blog.csdn.net/acm_cxlove/article/details/7548087

感觉最巧的是定义了min_dis……将区间内有无英雄升级分开处理

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>

#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1
#define lc rt << 1
#define rc rt << 1 | 1

using namespace std;

const int MAXN = ;
const int INF =  << ;

struct node
{
    int exp, level;
    int min_dis;
    int flag;
};

int N, K, Q;
node Tr[ MAXN <<  ];
int sum[];

void build( int l, int r, int rt )
{
    Tr[rt].exp = Tr[rt].flag = ;
    Tr[rt].level = ;
    Tr[rt].min_dis = sum[];
    if ( l == r ) return ;
    int m = ( l + r ) >> ;
    build( lson );
    build( rson );
    return;
}

void PushDown( int rt )
{
    if ( Tr[rt].flag )
    {
        Tr[lc].exp += Tr[rt].flag * Tr[lc].level;
        Tr[lc].min_dis -= Tr[rt].flag;
        Tr[lc].flag += Tr[rt].flag;

        Tr[rc].exp += Tr[rt].flag * Tr[rc].level;
        Tr[rc].min_dis -= Tr[rt].flag;
        Tr[rc].flag += Tr[rt].flag;

        Tr[rt].flag = ;
    }
    return;
}

void PushUp( int rt )
{
    Tr[rt].level = max( Tr[lc].level, Tr[rc].level );
    Tr[rt].exp = max( Tr[lc].exp, Tr[rc].exp );
    Tr[rt].min_dis = min( Tr[lc].min_dis, Tr[rc].min_dis );
    return;
}

void Update( int L, int R, int v, int l, int r, int rt )
{
    if ( l == r )
    {
        Tr[rt].exp += Tr[rt].level * v;
        while ( Tr[rt].exp >= sum[ Tr[rt].level ] )
            ++Tr[rt].level;
        Tr[rt].min_dis = ( sum[ Tr[rt].level ] - Tr[rt].exp ) / Tr[rt].level;
        if( ( sum[ Tr[rt].level ] - Tr[rt].exp ) % Tr[rt].level ) ++Tr[rt].min_dis;
        return;
    }
    int m = ( l + r ) >> ;

    if ( L == l && r == R )
    {
        if ( v >= Tr[rt].min_dis )
        {
            PushDown(rt);
            if ( R <= m ) Update( L, R, v, lson );
            else if ( L > m ) Update( L, R, v, rson );
            else
            {
                Update( L, m, v, lson );
                Update( m + , R, v, rson );
            }
            PushUp(rt);
        }
        else
        {
            Tr[rt].exp += Tr[rt].level * v;
            Tr[rt].min_dis -= v;
            Tr[rt].flag += v;
        }
        return;
    }

    PushDown(rt);

    if ( R <= m ) Update( L, R, v, lson );
    else if ( L > m ) Update( L, R, v, rson );
    else
    {
        Update( L, m, v, lson );
        Update( m + , R, v, rson );
    }

    PushUp(rt);

    return;
}

int Query( int L, int R, int l, int r, int rt )
{
    if ( L <= l && r <= R ) return Tr[rt].exp;
    PushDown(rt);
    int m = ( l + r ) >> ;
    int res = ;
    if ( L <= m ) res = max( res, Query( L, R, lson ) );
    if ( R > m )  res = max( res, Query( L, R, rson ) );
    //PushUp(rt);
    return res;
}

int main()
{
    int T;
    int cas = ;
    scanf( "%d", &T );
    while ( T-- )
    {
        scanf( "%d%d%d", &N, &K, &Q );
        for ( int i = ; i < K; ++i )
            scanf( "%d", &sum[i] );
        sum[K] = INF;

        build( , N,  );
        printf( "Case %d:\n", ++cas );
        while ( Q-- )
        {
            char op[];
            int a, b, c;
            scanf( "%s", op );
            if ( op[] == 'W' )
            {
                scanf( "%d%d%d", &a, &b, &c );
                Update( a, b, c, , N,  );
            }
            else
            {
                scanf( "%d%d", &a, &b );
                printf("%d\n", Query( a, b, , N,  ) );
            }
        }
        puts("");
    }
    return ;
}