bzoj3110

网上几乎清一色树套树，但是我就写个整体二分吧（其实是我不会树套树……）
这题还是和原来步骤一样，二分-判定-划分，当二分答案为m的时候
询问：大于等于m的个数大于等于k那就可能追求更大，划到右边；
不满足意味着答案要更小，那些大于等于m的修改操作对询问影响不变，k减去他们贡献的个数，划到左边
修改：显然大于等于m的划到右边，小于m划到左边
两个部分内都是操作都是按时间线的顺序的
注意这里的修改是——区间修改，区间查询……不好要上线段树？
突然想起来树状数组也是可以解决区间求改区间查询的
首先我们知道，区间修改时要维护一个差分数组d[i]，代表[i..n]都加上d[i]
区间修改就是对d[l]+,d[r+1]-,然后每个位置的修改总和就等于d[]的前缀和 这就是单点查询
区间查询怎么办？我们还是想方设法变成前缀和，我们知道[l,r]=sum(r)-sum(l-1)
而sum[x]这个前缀和又怎么求呢？我们知道sum[x]=sumpre[x]（初始和）+sumdelta[x]（增量和）
重点是增量和，结合刚才的区间修改d[]，我们发现，sumdelta[x]=∑d[i]*(x-i+1)=(x+1)*∑d[i]-∑d[i]*i
然后显然我们维护两个树状数组d[i]和d[i]*i即可
这题就解决了,没有tle，zjoi良心了一把……

UPD：这题啊现在在bzoj上非常坑，因为加强了数据……

转c++练模板的时候发现的，为什么不弄个hack……害得我以为c++有什么特殊之处呢……

坑点是50000*50000爆了树状数组统计时的int，换成unsigned int就好……

上面那个pascal程序我也顺便改了%%%（pascal范围检测比c++严格……）

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<stdlib.h>

using namespace std;
struct node{int op,l,r,k,p;} a[50010],b[50010];
int q[50010],g[50010][2],c[50010],d[50010],ans[50010];
bool can[50010],v[50010];
int n,m,t,tot,p;

int read()
{
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
void work(int x,int w,int f)
{
     for (int i=x; i<=n; i+=i&-i)
     {
         if (!v[i]) {v[i]=1; q[++tot]=i;}
         g[i][f]+=w;
     }
}

int ask(int x,int f)
{
     int s=0;
     for (int i=x;i; i-=i&-i) s+=g[i][f];
     return s;
}

unsigned int sum(int x) //注意啊注意啊……
{
    return (x+1)*ask(x,0)-ask(x,1);
}

void cdq(int l,int r,int f,int t)
{
     if (l>r||f>t) return;
     int m=(l+r)>>1,h; tot=h=0;
     for (int i=f; i<=t; i++)
       if (a[i].op==1&&a[i].k>=d[m])
       {
          work(a[i].l,1,0);
          work(a[i].r+1,-1,0);
          work(a[i].l,a[i].l,1);
          work(a[i].r+1,-a[i].r-1,1);
          can[i]=1; ++h;
       }
       else if (a[i].op==2)
       {
          unsigned int s=sum(a[i].r)-sum(a[i].l-1);  
          if (s>=a[i].k)
          {
             ans[a[i].p]=m;
             can[i]=1; ++h;
          }
          else a[i].k-=s;
       }
     
     for (int i=1; i<=tot; i++)
     {
         int x=q[i]; v[x]=0;
         g[x][0]=g[x][1]=0;
     }
     int f1=f,f2=t-h+1;
     for (int i=f; i<=t; i++)
       if (can[i]) 
       {
          b[f2++]=a[i];
          can[i]=0;
       }
       else b[f1++]=a[i];
     for (int i=f; i<=t; i++)
       a[i]=b[i];  
     cdq(l,m-1,f,f1-1);
     cdq(m+1,r,f1,t);
}  
     
int main()
{
    n=read(); m=read();
    for (int i=1;i<=m; i++)
    {
        a[i].op=read(); a[i].l=read(); a[i].r=read(); a[i].k=read();
        a[i].p=i;
        if (a[i].op==1) c[++t]=a[i].k;
    }
    sort(c+1,c+t+1);
    p=1; d[1]=c[1];
    for (int i=2;i<=t; i++)
      if (c[i]!=c[i-1]) d[++p]=c[i];
        
    cdq(1,p,1,m);  
    for (int i=1;i<=m;i++)
      if (ans[i]) printf("%d\n",d[ans[i]]);
    return 0;
}  

type node=record
       l,r,k,op,p:longint;
     end;

var a,b:array[0..50010] of node;
    q,ans,c,g,d:array[0..50010] of longint;
    v1,v2:array[0..50010] of boolean;
    i,t,n,m,tot,p:longint;

procedure swap(var a,b:longint);
  var c:longint;
  begin
    c:=a;
    a:=b;
    b:=c;
  end;

procedure sort(l,r:longint);
  var i,j,x:longint;
  begin
    i:=l;
    j:=r;
    x:=c[(l+r) shr 1];
    repeat
      while c[i]<x do inc(i);
      while x<c[j] do dec(j);
      if not(i>j) then
      begin
        swap(c[i],c[j]);
        inc(i);
        dec(j);
      end;
    until i>j;
    if l<j then sort(l,j);
    if i<r then sort(i,r);
  end;

function lowbit(x:longint):longint;
  begin
    exit(x and (-x));
  end;

procedure addc(x,w:longint);
  begin
    while x<=n do
    begin
      if not v2[x] then
      begin
        v2[x]:=true;
        inc(tot);
        q[tot]:=x;
      end;
      inc(c[x],w);
      x:=x+lowbit(x);
    end;
  end;

procedure addg(x,w:longint);
  begin
    while x<=n do
    begin
      inc(g[x],w);
      x:=x+lowbit(x);
    end;
  end;

function askc(x:longint):longint;
  begin
    askc:=0;
    while x>0 do
    begin
      askc:=askc+c[x];
      x:=x-lowbit(x);
    end;
  end;

function askg(x:longint):longint;
  begin
    askg:=0;
    while x>0 do
    begin
      askg:=askg+g[x];
      x:=x-lowbit(x);
    end;
  end;

function sum(x:longint):longword;
  begin
    exit(longword(askg(x))*longword(x+1)-askc(x)); //pascal范围检测严格……
  end;

procedure cdq(l,r,f,t:longint);
  var m,h,l1,l2:longint;
      s:longword;
  begin
    if (f>t) or (l>r) then exit;
    m:=(l+r) shr 1;
    h:=0; tot:=0;
    for i:=f to t do
      if (a[i].op=1) and (a[i].k>=d[m]) then
      begin
        addg(a[i].l,1);
        addg(a[i].r+1,-1);
        addc(a[i].l,a[i].l);
        addc(a[i].r+1,-a[i].r-1);
        v1[i]:=true; inc(h);
      end
      else if (a[i].op=2) then
      begin
        s:=sum(a[i].r)-sum(a[i].l-1);
        if s>=a[i].k then
        begin
          ans[a[i].p]:=m;
          v1[i]:=true;  inc(h);
        end
        else a[i].k:=a[i].k-s;
      end;

    for i:=1 to tot do
    begin
      c[q[i]]:=0;
      g[q[i]]:=0;
      v2[q[i]]:=false;
    end;
    l1:=f; l2:=t-h+1;
    for i:=f to t do
      if v1[i] then
      begin
        b[l2]:=a[i];
        inc(l2);
        v1[i]:=false;
      end
      else begin
        b[l1]:=a[i];
        inc(l1);
      end;

    for i:=f to t do
      a[i]:=b[i];

    cdq(l,m-1,f,l1-1);
    cdq(m+1,r,l1,t);
  end;

begin
  readln(n,m);
  for i:=1 to m do
  begin
    readln(a[i].op,a[i].l,a[i].r,a[i].k);
    a[i].p:=i;
    if a[i].op=1 then
    begin
      inc(t);
      c[t]:=a[i].k;
    end;
  end;
  sort(1,t);
  p:=1;
  d[1]:=c[1];
  for i:=2 to t do
    if c[i]<>c[i-1] then
    begin
      inc(p);
      d[p]:=c[i];
    end;

  fillchar(c,sizeof(c),0);
  cdq(1,p,1,m);
  for i:=1 to m do
    if ans[i]<>0 then writeln(d[ans[i]]);
end.