hdu4614 线段树+二分 插花

　Alice is so popular that she can receive many flowers everyday. She has N vases numbered from 0 to N-1. When she receive some flowers, she will try to put them in the vases, one flower in one vase. She randomly choose the vase A and try to put a flower in the vase. If the there is no flower in the vase, she will put a flower in it, otherwise she skip this vase. And then she will try put in the vase A+1, A+2, ..., N-1, until there is no flower left or she has tried the vase N-1. The left flowers will be discarded. Of course, sometimes she will clean the vases. Because there are too many vases, she randomly choose to clean the vases numbered from A to B(A <= B). The flowers in the cleaned vases will be discarded.

Input　　The first line contains an integer T, indicating the number of test cases. 
　　For each test case, the first line contains two integers N(1 < N < 50001) and M(1 < M < 50001). N is the number of vases, and M is the operations of Alice. Each of the next M lines contains three integers. The first integer of one line is K(1 or 2). If K is 1, then two integers A and F follow. It means Alice receive F flowers and try to put a flower in the vase A first. If K is 2, then two integers A and B follow. It means the owner would like to clean the vases numbered from A to B(A <= B).Output　　For each operation of which K is 1, output the position of the vase in which Alice put the first flower and last one, separated by a blank. If she can not put any one, then output 'Can not put any one.'. For each operation of which K is 2, output the number of discarded flowers. 
　　 Output one blank line after each test case.Sample Input

2
10 5
1 3 5
2 4 5
1 1 8
2 3 6
1 8 8
10 6
1 2 5
2 3 4
1 0 8
2 2 5
1 4 4
1 2 3

Sample Output

[pre]3 7
2
1 9
4
Can not put any one.

2 6
2
0 9
4
4 5
2 3

现在要你插花，有n个花瓶，m次操作，初始花瓶中无花，操作有两种方式

操作1：1 a b，从编号为a的花瓶开始插花，共插b朵花，花只能插到无花的花瓶中，如果最后插不完b朵花，剩下的花舍弃掉 
操作2：1 a b，把从编号a到编号b的所有花瓶里的花全部清理掉

对于操作1，需要输出开始插花的瓶子编号，和最后插花的瓶子编号 
对于操作2，需要输出在a~b中总共清理了多少个花瓶中的花

题解：线段树+二分，分析一下这道题，如果是情理，那是十分容易的，只需要lazy，tag就可以了，但是如何去找区间第一个可以插的位置呢，

　　　线段树可以记录该位置里的有多少个空位置，那么我们可以二分，来查找判断是多了，还是少了，这样就可以了，时间复杂度就控制了

　　　下来，然后整个区间填满，什么区间？就是第一支花和最后一枝花那个区间，hh。

 #include<iostream>
 #include<stdio.h>
 #include<map>
 #include<algorithm>
 #include<math.h>
 #include<queue>
 #include<stack>
 #include<string>
 #include<cstring>
 using namespace std;
 struct node
 {
     int l,r;
     int tag;//如果为-1则为初始状态，如果为0意思将子区间内的花清空，为1为插满花
     int v;//记录区间内插了多少花
 }t[*];
 int n;
 void Build(int l,int r,int k)
 {
     t[k].l=l;
     t[k].r=r;
     t[k].v=;
     t[k].tag=-;
     if(l==r)
         return;
     int mid=(l+r)/;
     Build(l,mid,k*);
     Build(mid+,r,k*+);
 }
 void pushdown(int k)//向下传递状态
 {
     t[k*].tag=t[k*+].tag=t[k].tag;
     t[k*].v=t[k].tag*(t[k*].r-t[k*].l+);
     t[k*+].v=t[k].tag*(t[k*+].r-t[k*+].l+);
     t[k].tag=-;
 }
 void update(int l,int r,int v,int k)
 {
     if(t[k].l==l&&t[k].r==r)
     {
         t[k].tag=v;
         t[k].v=v*(r-l+);//插满或者清空
         return;
     }
     if(t[k].tag!=-)//要传递状态
         pushdown(k);
     int mid=(t[k].l+t[k].r)/;
     if(r<=mid)
         update(l,r,v,k*);
     else if(l>mid)
         update(l,r,v,k*+);
     else
     {
         update(l,mid,v,k*);
         update(mid+,r,v,k*+);
     }
     t[k].v=t[k*].v+t[k*+].v;//向上传递区间信息
 }
 int query(int l,int r,int k)//查询区间内插花的数目
 {
     if(t[k].l==l&&t[k].r==r)
     {
         return t[k].v;
     }
     if(t[k].tag!=-)//同样lazy tag
         pushdown(k);
     int mid=(t[k].l+t[k].r)/;
     if(r<=mid)
         return query(l,r,k*);
     else if(l>mid)
         return query(l,r,k*+);
     else
     {
         return query(l,mid,k*)+query(mid+,r,k*+);
     }
     t[k].v=t[k*].v+t[k*+].v;
 }
 int dive(int s,int num)//二分查找，第一个为开始的位置，第二个参数为要插多少个
 {
     int temp=query(s,n,);
     if(temp==n-s+)//如果一个都不能插
         return -;
     if(n-s+-temp<num)//如果空位小于要插的数目，改下要插的数目
         num=n-s+-temp;
     int l=s;
     int r=n;
     int mid,d;
     int f=-;
     while(r>=l)//二分
     {
         mid=(l+r)/;
         d=mid-s+-query(s,mid,);//d为从s到mid的空位数目
         if(d>num)
         {
             r=mid-;
         }
         else if(d<num)
             l=mid+;
         else//如果空位的数目正好要一个个减
         {
             f=mid;//为了保存第一个能够满足该数目空位的位置
             r=mid-;
         }
     }
     return f;
 }
 int main()
 {
     int i,j,test,x,y,d,m;
     scanf("%d",&test);
     while(test--)
     {
         scanf("%d%d",&n,&m);
         n--;
         Build(,n,);
         for(i=;i<m;i++)
         {
             scanf("%d%d%d",&d,&x,&y);
             if(d==)
             {
                 int temp=dive(x,);//查找插的第一个位置
                 if(temp==-)
                 {
                     printf("Can not put any one.\n");
                 }
                 else
                 {
                     int en=dive(x,y);//查找插的第二个位置
                     printf("%d %d\n",temp,en);
                     update(temp,en,,);//更新插满区间
                 }
             }
             else
             {
                 printf("%d\n",query(x,y,));
                 update(x,y,,);//清空区间
             }
         }
         printf("\n");
     }
     return ;
 }