HDU 4031 Attack （线段树）

成功袭击次数=所有袭击次数-成功防守次数

需要一个辅助pre来记录上一次袭击成功什么时候，对于每个查询，从上一次袭击成功开始，每隔t更新一次。

感觉这样做最坏时间复杂度是O(n^2)，这里 说是O(q)*O(q/t)log(n)，应该是超时边缘。

能AC或许因为数据不强。

PS.初始化的时候直接memset会超时，每次根据N的大小build线段树，memset也根据N的大小来就能AC。

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

#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 = ;

struct node
{
    int l, r;
};

node D[MAXN];
int sum[ MAXN <<  ];
int flag[ MAXN <<  ];
int pre[ MAXN ];
int defen[MAXN];
int N, Q, t;

void PushDown( int rt, int m )
{
    if ( flag[rt] )
    {
        flag[lc] += flag[rt];
        flag[rc] += flag[rt];
        sum[lc] += flag[rt]*(m-(m>>));
        sum[rc] += flag[rt]*(m>>);
        flag[rt] = ;
    }
    return;
}

void update( int L, int R, int l, int r, int rt )
{
    if ( L <= l && r <= R )
    {
        sum[rt] += ;
        flag[rt] += ;
        return;
    }
    PushDown(rt, r - l + );
    int m = ( l + r ) >> ;
    if ( L <= m ) update( L, R, lson );
    if ( R > m )  update( L, R, rson );
    return;
}

int query( int L, int l, int r, int rt )
{
    if ( L == l && r == L ) return sum[rt];
    PushDown(rt, r - l + );
    int m = ( l + r ) >> ;
    if ( L <= m ) return query( L, lson );
    else return query( L, rson );
}

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

int main()
{
    int T, cas = ;
    scanf( "%d", &T );
    char str[];
    while( T-- )
    {
        scanf( "%d%d%d", &N, &Q, &t );
        build( , N,  );
        memset( defen, , sizeof(int)*(N+) );
        memset( pre, , sizeof(int)*(N+) );
        memset( D, , sizeof(D[])*(N+) );

        int cnt = ;
        printf( "Case %d:\n", ++cas );
        for ( int i = ; i < Q; ++i )
        {
            scanf( "%s", str );
            if ( str[] == 'A' )
            {
                scanf("%d%d", &D[cnt].l, &D[cnt].r );
                update( D[cnt].l, D[cnt].r, , N,  );
                ++cnt;
            }
            else
            {
                int a;
                scanf( "%d", &a );
                for ( int i = pre[a]; i <= cnt; )
                {
                    if ( a >= D[i].l && a <= D[i].r )
                    {
                        pre[a] = i + t;
                        ++defen[a];
                        i += t;
                    }
                    else ++i;
                }
                //printf("qry=%d def=%d\n", query(a, 1, N, 1 ), defen[a] );
                printf( "%d\n", query(a, , N,  ) - defen[a] );
            }
            //printf("***qry=%d def=%d\n", query(5, 1, N, 1 ), defen[5] );
        }
    }
    return ;
}