HDU 2871 Memory Control

裸线段树区间合并，一开始没注意题目细节结果搞麻烦了……

给你四种操作，每种操作按它的要求输出结果。

1.  Reset Reset all memory units free. 

Reset 释放所有的内存

2.  New x Allocate a memory block consisted of x continuous free memory units with the least start number

New x   申请一个包含x个连续内存单元的内存块，起始地址编号最小

3.  Free x Release the memory block which includes unit x

Free x  释放包含地址x的内存块

（这个地方有个注意点可以从样例中得到，就是说如果我先申请了内存块1-2，后申请了内存块3-4，虽然1-4此时都被申请了，但1-4并不属于一个连续的内存块，因为它不是被一次申请的。如果查询4所在的内存块的起始地址，应当输出3，而不是1 ）

4.  Get x Return the start number of the xth memory block(Note that we count the memory blocks allocated from left to right)

Get x 返回第x个内存块的起始地址（假定我们将内存块从左到右编号）

因为把题意的细节理解的有问题，所以一开始我的线段树不只是记录了连续的空余区间长度，还把连续被申请的区间长度也记录了，事实证明这是完全没必要。然后就去掉了。

还有一个地方是用一个vector来记录一下已经申请的内存块，因为要用二分查找，所以在向vector中插入元素时应注意维护一下它的有序性。

 

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

using namespace std;

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

const int MAXN = 50002;

struct node
{
    int st, ed;
    node(){}
    node( int _st, int _ed ) : st( _st ), ed( _ed ) { }
};

vector<node> blocks;

int N, Q;
int len[ MAXN << 2 ];    //空闲区最长连续长度

int Llen[ MAXN << 2 ];   //左端空闲区长度
int Rlen[ MAXN << 2 ];   //右端空闲区长度

int flag[ MAXN << 2 ];   //0 释放  -1  无标记   1 占用

bool lbd[ MAXN << 2 ];   //左端点是否空闲
bool rbd[ MAXN << 2 ];   //右端点是否空闲

void chuli( int op, int rt, int l, int r )
{
    if ( op == 0 )
        Llen[rt] = Rlen[rt] = len[rt] = r - l + 1;
    else
        Llen[rt] = Rlen[rt] = len[rt] = 0;

    lbd[rt] = rbd[rt] = op ^ 1;
    return;
}

void PushDown( int rt, int l, int r, int m )
{
    if ( flag[rt] != -1 )
    {
        flag[lc] = flag[rc] = flag[rt];
        chuli( flag[lc], lc, l, m );
        chuli( flag[rc], rc, m + 1, r );
        flag[rt] = -1;
    }
    return;
}

void PushUp( int rt, int l, int r, int m )
{
    lbd[rt] = lbd[lc];
    rbd[rt] = rbd[rc];

    Llen[rt] = Llen[lc];
    Rlen[rt] = Rlen[rc];

    if ( Llen[lc] == m - l + 1 ) Llen[rt] += Llen[rc];
    if ( Rlen[rc] == r - m )     Rlen[rt] += Rlen[lc];

    len[rt] = max( len[lc], len[rc] );
    if ( lbd[rc] && rbd[lc] ) len[rt] = max( len[rt], Llen[rc] + Rlen[lc] );

    return;
}

void build( int l, int r, int rt )
{
    flag[rt] = -1;
    if ( l == r )
    {
        len[rt] = Llen[rt] = Rlen[rt] = 1;
        lbd[rt] = rbd[rt] = true;
        return;
    }

    int m = ( l + r ) >> 1;
    build( lson );
    build( rson );
    PushUp( rt, l, r, m );

    return;
}

void Update( int L, int R, int op, int l, int r, int rt )
{
    int m = ( l + r ) >> 1;
    if ( L <= l && r <= R )
    {
        flag[rt] = op;
        chuli( op, rt, l, r );
        return;
    }
    PushDown( rt, l, r, m );

    if ( L <= m ) Update( L, R, op, lson );
    if ( R > m )  Update( L, R, op, rson );

    PushUp( rt, l, r, m );

    return;
}

int Query( int a, int op, int l, int r, int rt )  //op代表查询空闲区间还是占用区间
{
    int m = ( l + r ) >> 1;

    if ( l == r )
    {
        if ( len[rt] == a ) return l;
        else return 0;
    }

    PushDown( rt, l, r, m );

    if ( len[lc] >= a ) return Query( a, op, lson );
    else if ( Rlen[lc] + Llen[rc] >= a ) return m - Rlen[lc] + 1;
    else if ( len[rc] >= a ) return Query( a, op, rson );
    else return 0;
}

int BiSearch( int tar )
{
    int low = 0, high = blocks.size() - 1, mid;
    while ( low <= high )
    {
        mid = ( low + high ) >> 1;
        if ( blocks[mid].st <= tar ) low = mid + 1;
        else high = mid - 1;
    }
    return low;
}

int main()
{
    while ( ~scanf( "%d%d", &N, &Q ) )
    {
        build( 1, N, 1 );
        blocks.clear();
        while ( Q-- )
        {
            char oper[10];
            int a, idx;
            scanf( "%s", oper );
            if ( oper[0] == 'R' )
            {
                Update( 1, N, 0, 1, N, 1 );
                blocks.clear();
                puts("Reset Now");
            }
            else
            {
                scanf( "%d", &a );
                switch( oper[0] )
                {
                    case 'N':
                    if ( len[1] < a ) puts("Reject New");
                    else
                    {
                        int st = Query( a, 0, 1, N, 1 );
                        printf( "New at %d\n", st );
                        idx = BiSearch( st );
                        blocks.insert( blocks.begin() + idx, node( st, st + a - 1 ) );
                        Update( st, st + a - 1, 1, 1, N, 1 );
                    }
                    break;

                    case 'F':
                    idx = BiSearch(a) - 1;
                    if ( idx == -1 || a > blocks[idx].ed ) puts("Reject Free");
                    else
                    {
                        printf( "Free from %d to %d\n", blocks[idx].st, blocks[idx].ed );
                        Update( blocks[idx].st, blocks[idx].ed, 0, 1, N, 1 );
                        blocks.erase( blocks.begin() + idx, blocks.begin() + idx + 1 );
                    }
                    break;

                    case 'G':
                    --a;
                    if ( a >= (int)blocks.size() ) puts("Reject Get");
                    else printf( "Get at %d\n", blocks[a].st );
                    break;
                }
            }
        }
        puts("");
    }
    return 0;
}