线段树区间合并

线段树区间合并主要解决一段连续区间修改，查询问题。

线段树是树形结构，为解决相邻区间更新，修改问题，我们必须在原本须要维护的区间内，连续段最大值的基础上加上，从左，右两边起，最大的连续区间长度。

例题：

酒店：
此题开始时，所有的房间都是空房间，有两个操作：

1、查询长度为x的连续房间，并将房间全部填满，输出左端点值。

2、表示退房，将x,到x+y-1的房间退房。

我们来看线段树，我们知道线段树要将区间分成好多块，之后对每一块进行处理。对于两块深度相同的区间，如果只是单纯的维护一个区间最大值，很明显。对于两个区间共同的祖宗区间，你无法判断，祖宗区间的最大值，是它左儿子的最大值还是右儿子的最大值，还是这个最大的连续区间在两个区间之间。因此引入两个新的值，这个区间从最左段起最大的连续区间，还有从这个区间最右端起最大的连续区间，这样我们就可以判断祖宗节点最大的连续区间到底是多大。

向上更新：

对于我们维护的三个值，左最大跟右最大的更新几乎是一样的：

（图比较丑，emm，手残多见谅。）

我们看到祖宗节点的左最大为1，就是左儿子的左最大，右最大为4，我们单看右儿子最大只为3，但是左儿子还有一个点与它们相邻，因此当右儿子右最大等于它所包含的区间长度时，那么我们就可以将左儿子右最大也更新到祖宗节点中，具体见代码。

向下更新，对于lazy节点我们只需要让他记录是开房，还是退房，记录完毕向下更新，就将区间全部清空，或者全部住房即可。

对于查询，我们可以看到，需要查找长度为x的区间，输出的是最左端的房间，也就是说有多个空房时，我们只要输出最左端的那一个，那么我们的查找只要从最左端找起，如果有就输出没有就继续查找中间，最后查找最右端。，找到最左端值后，我们再根据区间长度调用更新函数，区间更新即可。

代码：

#include 
#include 
#include 
#define ll long long
const int M=1e5+1000;
using namespace std;
//对于入住情况，先查询满足情况的左端点。然后根据左端点，求出更新区间，对整个区间进行更新
struct node
{
    ll sum;
    ll lmax;//从最左边有多少个空房间
    ll rmax;//从最右边有多少个空房间
    int lazy;//延迟更新，如果入住为1，退房为2
}tr[M*4];
void build(int i,int l,int r)
{
    tr[i].sum=tr[i].lmax=tr[i].rmax=r-l+1;
    tr[i].lazy=0;
    if(l==r)
    {
        return;
    }
    int mid=(l+r)/2;
    build(i*2,l,mid);
    build(i*2+1,mid+1,r);
}
void pushup(int i,int l,int r)
{
    int mid=(r+l)/2;
    if(tr[i*2].sum==(mid-l+1))
    {
        tr[i].lmax=tr[i*2].sum+tr[i*2+1].lmax;
    }
    else
    tr[i].lmax=tr[i*2].lmax;
    if(tr[i*2+1].sum==(r-mid))
    {
        tr[i].rmax=tr[i*2+1].sum+tr[i*2].rmax;
    }
    else
    tr[i].rmax=tr[i*2+1].rmax;
    tr[i].sum=max(tr[i*2].rmax+tr[i*2+1].lmax,max(tr[i*2].sum,tr[i*2+1].sum));
}
void pushdown(int i,int l,int r)
{
    int mid=(r+l)/2;
    if(tr[i].lazy==1)
    {
        tr[i*2].sum=tr[i*2+1].sum=tr[i*2].lmax=tr[i*2+1].lmax=tr[i*2+1].rmax=tr[i*2].rmax=0;
        tr[i*2].lazy=tr[i*2+1].lazy=1;
    }
    if(tr[i].lazy==2)
    {
        tr[i*2].sum=tr[i*2].lmax=tr[i*2].rmax=mid-l+1;
        tr[i*2+1].sum=tr[i*2+1].lmax=tr[i*2+1].rmax=r-mid;
        tr[i*2].lazy=tr[i*2+1].lazy=2;
    }
    tr[i].lazy=0;
}
ll query(int i,int l,int r,int x)
{
    if(tr[i].lazy!=0)
    pushdown(i,l,r);
    if(l==r)return l;
    int mid=(r+l)/2;
    if(tr[i*2].sum>=x) return query(i*2,l,mid,x);
    if(tr[i*2].rmax+tr[i*2+1].lmax>=x) return mid-tr[i*2].rmax+1;
    else return query(i*2+1,mid+1,r,x);
}
void update(int i,int l,int r,int x,int y,int t)
{
    if(tr[i].lazy!=0)
    pushdown(i,l,r);
    if(x<=l&&y>=r)
    {
       if(t==1)
    {
        tr[i].sum=tr[i].lmax=tr[i].rmax=0;
    }
    else
    {
        tr[i].sum=tr[i].lmax=tr[i].rmax=r-l+1;
    }
    tr[i].lazy=t;
    return;
    }
    int mid=(l+r)/2;
    if(x<=mid) update(i*2,l,mid,x,y,t);
    if(y>mid) update(i*2+1,mid+1,r,x,y,t);
    pushup(i,l,r);
}
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    build(1,1,n);
    for(int i=1;i<=m;i++)
    {
        int o,x,y;
        scanf("%d",&o);
        if(o==1)
        {
            scanf("%d",&x);
            if(tr[1].sum>=x)
            {
                ll l=query(1,1,n,x);
                printf("%lld\n",l);
                update(1,1,n,l,x+l-1,o);
            }
            else{
            printf("0\n");}
        }
        else{
            scanf("%d%d",&x,&y);
            update(1,1,n,x,x+y-1,o);
        }

    }
    return 0;
}

Memory Control（酒店加强版）

这个题除了酒店的操作之外，需要释放x位置所在的区间，得到从左数第x个区间开始的位置。

这题需要用一个vector来维护，我们储存的空间，这样方便查找第x个位置所在的空间，跟从左数第x个区间开始位置。因为我们输出从左数第x个空间开始的位置，因此我们的vector要有序，有序插入，怎么才能缩短时间复杂度？二分！下面看代码。

#include 
#include 
#include 
#include 
#define ll long long
const int M=1e5+1000;
using namespace std;
//对于入住情况，先查询满足情况的左端点。然后根据左端点，求出更新区间，对整个区间进行更新
struct node
{
    ll sum;
    ll lmax;//从最左边有多少个空房间
    ll rmax;//从最右边有多少个空房间
    int lazy;//延迟更新，如果入住为1，退房为2
}tr[M*4];
void build(int i,int l,int r)
{
    tr[i].sum=tr[i].lmax=tr[i].rmax=r-l+1;
    tr[i].lazy=0;
    if(l==r)
    {
        return;
    }
    int mid=(l+r)/2;
    build(i*2,l,mid);
    build(i*2+1,mid+1,r);
}
void pushup(int i,int l,int r)
{
    int mid=(r+l)/2;
    if(tr[i*2].sum==(mid-l+1))
    {
        tr[i].lmax=tr[i*2].sum+tr[i*2+1].lmax;
    }
    else
    tr[i].lmax=tr[i*2].lmax;
    if(tr[i*2+1].sum==(r-mid))
    {
        tr[i].rmax=tr[i*2+1].sum+tr[i*2].rmax;
    }
    else
    tr[i].rmax=tr[i*2+1].rmax;
    tr[i].sum=max(tr[i*2].rmax+tr[i*2+1].lmax,max(tr[i*2].sum,tr[i*2+1].sum));
}
void pushdown(int i,int l,int r)
{
    int mid=(r+l)/2;
    if(tr[i].lazy==1)
    {
        tr[i*2].sum=tr[i*2+1].sum=tr[i*2].lmax=tr[i*2+1].lmax=tr[i*2+1].rmax=tr[i*2].rmax=0;
        tr[i*2].lazy=tr[i*2+1].lazy=1;
    }
    if(tr[i].lazy==2)
    {
        tr[i*2].sum=tr[i*2].lmax=tr[i*2].rmax=mid-l+1;
        tr[i*2+1].sum=tr[i*2+1].lmax=tr[i*2+1].rmax=r-mid;
        tr[i*2].lazy=tr[i*2+1].lazy=2;
    }
    tr[i].lazy=0;
}
ll query(int i,int l,int r,int x)
{

    if(l==r)return l;
    int mid=(r+l)/2;
    if(tr[i].lazy!=0)
    pushdown(i,l,r);
    if(tr[i*2].sum>=x) return query(i*2,l,mid,x);
    else if(tr[i*2].rmax+tr[i*2+1].lmax>=x) return mid-tr[i*2].rmax+1;
    else return query(i*2+1,mid+1,r,x);
}
void update(int i,int l,int r,int x,int y,int t)
{

    if(x<=l&&y>=r)
    {
       if(t==1)
    {
        tr[i].sum=tr[i].lmax=tr[i].rmax=0;
    }
    else
    {
        tr[i].sum=tr[i].lmax=tr[i].rmax=r-l+1;
    }
    tr[i].lazy=t;
    return;
    }
    if(tr[i].lazy!=0)
    pushdown(i,l,r);
    int mid=(l+r)/2;
    if(x<=mid) update(i*2,l,mid,x,y,t);
    if(y>mid) update(i*2+1,mid+1,r,x,y,t);
    pushup(i,l,r);
}
typedef pairpil;
vectorlist;
int find(int k)
{
    int l,r,mid,ans;
    ans=-1;
    l=0,r=list.size()-1;
    while(l<=r)
    {
         mid=(r+l)/2;
         if(list[mid].first>k)
         {
             r=mid-1;
         }
         else
         {
             ans=mid;
               l=mid+1;
         }

    }
    return ans;
}
int main()
{
    int n,m;
    while(scanf("%d%d",&n,&m)==2)
    {
         build(1,1,n);
    list.clear();
    for(int i=1;i<=m;i++)
    {
        int x;
        char o[10];
        scanf("%s",o);
        if(o[0]=='N')
        {
            scanf("%d",&x);
            if(tr[1].sum>=x)
            {
                int l=query(1,1,n,x);
                printf("New at %d\n", l);
                pil u=make_pair(l,l+x-1);
                list.insert(list.begin()+find(l)+1,u);
                update(1,1,n,l,x+l-1,1);
            }
            else{
            printf("Reject New\n");}
        }
        else if(o[0]=='R')
        {
            update(1,1,n,1,n,2);
             list.clear();
            printf("Reset Now\n");
        }
        else if(o[0]=='F'){
            scanf("%d",&x);
            int k=find(x);
            if(k!=-1&&x<=list[k].second)
            {
                update(1,1,n,list[k].first,list[k].second,2);
                printf("Free from %d to %d\n", list[k].first, list[k].second);
                list.erase(list.begin()+k);
            }
            else
                printf("Reject Free\n");
        }
        else
        {
            scanf("%d",&x);
            if(x<=list.size())
            {
                printf("Get at %d\n", list[x-1].first);
            }
                else
                    printf("Reject Get\n");
            }
    }
    printf("\n");
    }

    return 0;
}

 HDU 1540 Tunnel Warfare

这个题查询跟上面的题有一定的相似，查询x所在区间最左端值，此题可用线段树解决，判断x在哪个区间中：

#include 
#include 
#include 
#include 
#include 
using namespace std;

const int M= 50000+10;
struct
{
    int len;
    int lmax,rmax,maxn;

}tr[M*4];
int r[M],cnt;
void pushup(int i)
{
    if(tr[i*2].lmax==tr[i*2].len)
    {
        tr[i].lmax=tr[i*2].maxn+tr[i*2+1].lmax;
    }
    else
    tr[i].lmax=tr[i*2].lmax;
    if(tr[i*2+1].rmax==tr[i*2+1].len)
    {
        tr[i].rmax=tr[i*2+1].maxn+tr[i*2].rmax;
    }
    else
    tr[i].rmax=tr[i*2+1].rmax;
    tr[i].maxn=max(max(tr[i*2].maxn,tr[i*2+1].maxn),tr[i*2].rmax+tr[i*2+1].lmax);
}
void build(int i,int l,int r)
{
    tr[i].len=r-l+1;
    tr[i].lmax=tr[i].rmax=tr[i].maxn=r-l+1;
    if(l==r)
    return;
    int mid=(r+l)/2;
    build(i*2,l,mid);
    build(i*2+1,mid+1,r);
}
void update(int i,int l,int r,int x,int o)
{
    if(l==r)
    {
        if(o==1)
        {
            tr[i].lmax=tr[i].rmax=tr[i].maxn=1;
        }
        else
          tr[i].lmax=tr[i].rmax=tr[i].maxn=0;
        return;
    }
    int mid=(r+l)/2;
    if(x<=mid)update(i*2,l,mid,x,o);
    else update(i*2+1,mid+1,r,x,o);
    pushup(i);
}
int query(int i,int l,int r,int x)
{
    //printf("%d%d\n",l,r);
    if(r==l||tr[i].maxn==0||tr[i].maxn==tr[i].len)
    {
        return tr[i].maxn;
    }

    int mid=(r+l)/2;
    if(x<=mid)
    {
        if(x>=mid-tr[i*2].rmax+1)
            return query(i*2,l,mid,x)+query(i*2+1,mid+1,r,mid+1);
        else
        {
            return query(i*2,l,mid,x);
        }
    }
    else
    {
        if(x<=mid+tr[i*2+1].lmax)
        {
           // printf("%d  %d\n",tr[i*2].lmax,l);
              return query(i*2,l,mid,mid)+query(i*2+1,mid+1,r,x);
        }

        else
        {
            return query(i*2+1,mid+1,r,x);
        }
    }
}
int main()
{
    int n,m;
    char o;
    while(~scanf("%d%d",&n,&m))
    {
        build(1,1,n);
        cnt=1;
        int x=0;
        for(int i=0;i0)
                {
                     cnt--;
                x=r[cnt];
                update(1,1,n,x,1);
                }

            }
            else
            {

                    scanf("%d",&x);
                printf("%d\n",query(1,1,n,x));

            }

        }
    }
    return 0;
}