线段树区间合并主要解决一段连续区间修改，查询问题。
线段树是树形结构，为解决相邻区间更新，修改问题，我们必须在原本须要维护的区间内，连续段最大值的基础上加上，从左，右两边起，最大的连续区间长度。
例题：
酒店：
此题开始时，所有的房间都是空房间，有两个操作：
1、查询长度为x的连续房间，并将房间全部填满，输出左端点值。
2、表示退房，将x,到x+y-1的房间退房。
我们来看线段树，我们知道线段树要将区间分成好多块，之后对每一块进行处理。对于两块深度相同的区间，如果只是单纯的维护一个区间最大值，很明显。对于两个区间共同的祖宗区间，你无法判断，祖宗区间的最大值，是它左儿子的最大值还是右儿子的最大值，还是这个最大的连续区间在两个区间之间。因此引入两个新的值，这个区间从最左段起最大的连续区间，还有从这个区间最右端起最大的连续区间，这样我们就可以判断祖宗节点最大的连续区间到底是多大。
向上更新：
对于我们维护的三个值，左最大跟右最大的更新几乎是一样的：
（图比较丑，emm，手残多见谅。）
我们看到祖宗节点的左最大为1，就是左儿子的左最大，右最大为4，我们单看右儿子最大只为3，但是左儿子还有一个点与它们相邻，因此当右儿子右最大等于它所包含的区间长度时，那么我们就可以将左儿子右最大也更新到祖宗节点中，具体见代码。
向下更新，对于lazy节点我们只需要让他记录是开房，还是退房，记录完毕向下更新，就将区间全部清空，或者全部住房即可。
对于查询，我们可以看到，需要查找长度为x的区间，输出的是最左端的房间，也就是说有多个空房时，我们只要输出最左端的那一个，那么我们的查找只要从最左端找起，如果有就输出没有就继续查找中间，最后查找最右端。，找到最左端值后，我们再根据区间长度调用更新函数，区间更新即可。
代码：
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#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 <iostream>
#include <stdio.h>
#include <vector>
#include <stdlib.h>
#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 pair<int,int>pil;
vector<pil>list;
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;
}这个题查询跟上面的题有一定的相似，查询x所在区间最左端值，此题可用线段树解决，判断x在哪个区间中：
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <math.h>
#include <stdlib.h>
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;i<m;i++)
{
scanf(" %c",&o);
if(o=='D')
{
scanf("%d",&x);
r[cnt]=x;
cnt++;
update(1,1,n,x,0);
}
else if(o=='R')
{
if(x>0)
{
cnt--;
x=r[cnt];
update(1,1,n,x,1);
}
}
else
{
scanf("%d",&x);
printf("%d\n",query(1,1,n,x));
}
}
}
return 0;
}