（线段树,二分）hdoj 2871-Memory Control

Memory units are numbered from 1 up to N. 
A sequence of memory units is called a memory block. 
The memory control system we consider now has four kinds of operations: 
1.  Reset Reset all memory units free. 
2.  New x Allocate a memory block consisted of x continuous free memory units with the least start number 
3.  Free x Release the memory block which includes unit x 
4.  Get x Return the start number of the xth memory block(Note that we count the memory blocks allocated from left to right) 
Where 1<=x<=N.You are request to find out the output for M operations. 

InputInput contains multiple cases. 
Each test case starts with two integer N,M(1<=N,M<=50000) ,indicating that there are N units of memory and M operations. 
Follow by M lines,each line contains one operation as describe above. 
OutputFor each “Reset” operation, output “Reset Now”. 
For each “New” operation, if it’s possible to allocate a memory block, 
output “New at A”,where Ais the least start number,otherwise output “Reject New”. 
For each “Free” operation, if it’s possible to find a memory block occupy unit x,
output “Free from A to B”,where A and B refer to the start and end number of the memory block,otherwise output “Reject Free”. 
For each “Get” operation, if it’s possible to find the xth memory blocks, 
output “Get at A”,where A is its start number,otherwise output “Reject Get”. 
Output one blank line after each test case. 
Sample Input

6 10
New 2
New 5
New 2
New 2
Free 3
Get 1
Get 2
Get 3
Free 3
Reset

Sample Output

New at 1
Reject New
New at 3
New at 5 
Free from 3 to 4
Get at 1
Get at 5
Reject Get
Reject Free
Reset Now

区间维护依旧与Hotel题目类似。变得更加复杂的是对Free get操作时区间的维护。采用引入vector记录区间的办法，为了提高效率，每次查询、插入都需要采用二分法（利用了vector插入时是在
给定地址前插入数据的特性）这种二分法的使用值得复习反思。

#include <iostream>
//#include<bits/stdc++.h>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <math.h>
using namespace std;
int N,M;
const int MAX=5e4+5;
struct node
{
    int left,right,mid;
    int al,ar;
    int status;
    int len()
    {
        return ar-al+1;
    }
    void actl()
    {
        left=right=mid=(status?0:len());
    }
}st[10*MAX];
struct seg//记录区间
{
    int left,right;
};
vector <seg> ve;//储存区间信息
seg oh;//临时储存
void init(int l,int r,int k)
{
    st[k].al=l;
    st[k].ar=r;
    st[k].status=0;
    st[k].actl();
    if(l==r)
        return;
    init(l,(l+r)/2,2*k);
    init((l+r)/2+1,r,2*k+1);
}
void pushdown(int k)
{
    if(st[k].status!=-1)
    {
        st[2*k].status=st[2*k+1].status=st[k].status;
        st[k].status=-1;
        st[2*k].actl();
        st[2*k+1].actl();
    }
}
int query(int len,int k)
{
    if(len==1&&st[k].al==st[k].ar)
        return st[k].al;
    if(st[k].mid<len)
        return -1;
    pushdown(k);
    if(st[2*k].mid>=len)
        return query(len,2*k);
    else if(st[2*k].right+st[2*k+1].left>=len)
        return st[2*k].ar-st[2*k].right+1;
    else if(st[2*k+1].mid>=len)
        return query(len,2*k+1);
    return -1;
}
void update(int ul,int ur,int l,int r,int k,int val)
{
    if(l==ul&&r==ur)
    {
        st[k].status=val;
        st[k].actl();
        return;
    }
    if(l==r)
        return;
    pushdown(k);
    int mid=(l+r)/2;
    if(ur<=mid)
        update(ul,ur,l,mid,2*k,val);
    else if(ul>mid)
        update(ul,ur,mid+1,r,2*k+1,val);
    else
    {
        update(ul,mid,l,mid,2*k,val);
        update(mid+1,ur,mid+1,r,2*k+1,val);
    }
    st[k].mid=max(st[2*k].mid,st[2*k+1].mid);
    st[k].left=st[2*k].left;
    st[k].right=st[2*k+1].right;
    st[k].mid=max(st[2*k].right+st[2*k+1].left,st[k].mid);
    if(st[2*k].left==st[2*k].len())
        st[k].left+=st[2*k+1].left;
    if(st[2*k+1].right==st[2*k+1].len())
        st[k].right+=st[2*k].right;
    return;
}
char command[10];
int tem,an;
int lo;//添加的位置
int binarysearch(int k)
{
    int l,r,mid;
    l=0;r=ve.size()-1;
    while(l<=r)
    {
        mid=(l+r)/2;
        if(ve[mid].left<=k)
            l=mid+1;
        else if(ve[mid].left>k)
            r=mid-1;
    }
    return l;
}
int main()
{
    while(~scanf("%d %d",&N,&M))
    {
        ve.clear();
        init(1,N,1);
        while(M--)
        {
            scanf("%s",command);
            if(command[0]=='R')
            {
                ve.clear();
                st[1].status=0;
                st[1].actl();
                pushdown(1);
                printf("Reset Now
");
            }
            else if(command[0]=='N')
            {
                scanf("%d",&tem);
                an=query(tem,1);
                if(an==-1)
                    printf("Reject New
");
                else
                {
                    oh.left=an;oh.right=an+tem-1;
                    lo=binarysearch(an);
                    ve.insert(ve.begin()+lo,oh);

                    update(an,an+tem-1,1,N,1,1);
                    printf("New at %d
",an);
                }
            }
            else if(command[0]=='F')
            {
                scanf("%d",&tem);
                lo=binarysearch(tem)-1;
                if(lo<=-1||ve[lo].right<tem)
                    printf("Reject Free
");
                else
                {
                    update(ve[lo].left,ve[lo].right,1,N,1,0);
                    printf("Free from %d to %d
",ve[lo].left,ve[lo].right);
                    ve.erase(ve.begin()+lo,ve.begin()+lo+1);//删除掉ve中的这个seg区间
                }
            }
            else if(command[0]=='G')
            {
                scanf("%d",&tem);
                if(tem>ve.size())
                    printf("Reject Get
");
                else
                {
                    printf("Get at %d
",ve[tem-1].left);
                }
            }
        }
        printf("
");//题意要求两组数据之间换行
    }
}