hdu 3577（线段树区间更新）
题意：输入一个t，表示有t组测试数据；
接下来一行，输入两个数，k，m，其中k表示这个辆车最多可以坐这么多人,m表示有m次询问能否上车；
每一次询问，输入两个数a,b，表示该乘客能否在a站台上车，b站台下车，乘车区间为（a,b--），先后次序；
即我每次询问，你就判断在a站台处将会有多少人还在车上，小于k则表示能够上车，更新数据，反之不能上车；
解题思路：这道题很明显就是线段树的区间更新，即判断线段的重叠次数。
按照刘汝佳书上写的代码WA了，不知道为什么。。。
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int maxn = 1e6+5;
int add[maxn<<2],Max[maxn<<2],l,r,_max;
int ans[maxn];
void maintain(int o,int L,int R)
{
int lc = o*2,rc = o*2+1;
Max[o] = 0;
if(R > L){
Max[o] = max(Max[lc],Max[rc]);
}
Max[o] += add[o];
}
void update(int o,int L,int R,int v)
{
int lc = o*2, rc = o*2+1;
if(l <= L && R <= r){
add[o] += v;
}
else{
int M = (L + R) >> 1;
if(M >= l) update(lc,L,M,v);
if(r > M) update(rc,M+1,R,v);
}
maintain(o,L,R);
}
void query(int o,int L,int R,int addv)
{
int lc = o*2, rc = o*2+1;
if(l <= L && R <= r){
_max = max(_max,Max[o] + addv);
}
else{
int M = (L + R) >> 1;
if(l <= M) query(lc,L,M,addv+add[lc]);
if(r > M) query(rc,M+1,R,addv+add[rc]);
}
}
int main()
{
int t,cas = 1,len;
scanf("%d",&t);
while(t--){
memset(add,0,sizeof(add));
memset(Max,0,sizeof(Max));
len = 0;
int k,q;
scanf("%d%d",&k,&q);
for(int i = 1; i <= q; i++){
scanf("%d%d",&l,&r);
r--;
_max = 0;
query(1,1,1000000,0);
if(_max < k){
update(1,1,1000000,1);
ans[len++] = i;
}
}
printf("Case %d:\n",cas++);
for(int i = 0; i < len; i++)
printf("%d ",ans[i]);
printf("\n\n");
}
return 0;
}
看了别人的代码，采用了一种lazy思想，也就是用一层更新一层，如果我在某一层能够找到符合要求的区间，那么就不更新它的子节点了，等到我需要它的子节点时，再把子节点更新了。。。总之是这样的一种思想，结合代码多思考下。。。
#include<iostream>
#include<string>
#include<algorithm>
#include<cstdio>
#include<cstring>
using namespace std;
const int N=1000005;
int ans[N];
struct node
{
int l,r,v,lazy;
}node[N<<2]; // 线段树的空间大概是数组空间的4倍；
void build(int l,int r,int numb) // 线段树的建立；
{
node[numb].l=l;
node[numb].r=r;
node[numb].v=0;
node[numb].lazy=0; // 用了lazy思想，提高了效率；
if(l==r) return;
int mid=(l+r)>>1;
build(l,mid,numb<<1);
build(mid+1,r,numb<<1|1);
}
void PushUp(int numb) // 往上往父节点方向更新数据；但是这里不是左右儿子的和，而是最大值，因为是站台人数；
{
node[numb].v=max(node[numb<<1].v,node[numb<<1|1].v);
}
void PushDown(int numb) // 向下往左右儿子方向更新数据；
{
node[numb<<1].lazy+=node[numb].lazy;
node[numb<<1|1].lazy+=node[numb].lazy;
node[numb<<1].v+=node[numb].lazy;
node[numb<<1|1].v+=node[numb].lazy;
node[numb].lazy=0; // 更新完了要清零；
}
void Insert(int l,int r,int numb) // 插入更新数据；
{
if(node[numb].l>=l&&node[numb].r<=r) // 如果区间完全重合，则不需要再往下更新了，先保存起来，可以节约很多的时间（lazy思想）
{
node[numb].v+=1;
node[numb].lazy+=1;
return;
}
if(node[numb].lazy) PushDown(numb); // 因为没有找到完全重合的区间，所以要先更新下一层区间；
int mid=(node[numb].r+node[numb].l)>>1;
if(l>mid) Insert(l,r,numb<<1|1);
else if(r<=mid) Insert(l,r,numb<<1);
else{
Insert(l,mid,numb<<1);
Insert(mid+1,r,numb<<1|1);
}
PushUp(numb); // 最后还得往上返回，更新父节点区间；
}
int query(int l,int r,int numb) // 查询区间l到r；
{
if(node[numb].l>=l&&node[numb].r<=r){
return node[numb].v;
}
if(node[numb].lazy) PushDown(numb); // 道理同48行；
int mid=(node[numb].r+node[numb].l)>>1;
if(l>mid) return query(l,r,numb<<1|1);
else if(r<=mid) return query(l,r,numb<<1);
else{
return max(query(l,mid,numb<<1),query(mid+1,r,numb<<1|1)); // 道理同28行；
}
}
int main()
{
int t,Case=1,len=0,k,m,a,b;
scanf("%d",&t);
while(t--){
len=0;
memset(ans,0,sizeof(ans));
scanf("%d%d",&k,&m);
build(1,1000000,1);
for(int i=0;i<m;i++){
scanf("%d%d",&a,&b);
b--; // 这里有一个问题，就是乘客从a上车，b下车，所以乘客在车上的区间为（a,b--）;
if(query(a,b,1)<k){ // 表示可以上车；
ans[len++]=i+1;
Insert(a,b,1);
}
}
printf("Case %d:\n",Case++);
for(int i=0; i<len; i++)
printf("%d ",ans[i]);
printf("\n\n");
}
return 0;
}