poj2482

（题外话：这题这是ACMer的福利啊……）
我非常不擅长做矩形类的数据结构
一般来说，二维的问题我们要转化为一维来考虑
感觉一般的手法是对一维排序，并且线性扫描这一维，然后用各种数据结构维护另一维上的最优值
这道题我们首先对x排序，然后扫描x坐标
这时候我们要维护2条扫描线，一左一右（应该就是two pointer）
扫描线之间的长度就是要求小于等于窗口宽度
随着右扫描线的移动，我们把这条扫描线上的点加到某个数据结构中
随着左扫描线的移动，我们把这条扫描线的点删除
显然每个点添加一次且删除一次，要做O(n)次操作
下面我们要做的就是在给定的横坐标区域内，找出星星亮度和最大的窗口
显然这里横坐标区域中的每一个点我们都可以当作压缩在一条线上考虑
考虑求数列区间长度小于等于h的和的最大值，我们对于每一个位置x上的元素a[x]
在x+h的位置上加上-a[x],然后我们可以用线段树维护区间最大和
这个区间最大和长度一定是小于等于h的（想想为什么）
这里的线段树是单点修改，直接查询（难得不用lazy tag，但是要用lmax，rmax）
所以操作的复杂度为O(logn),查询O(1),总的复杂度为O(nlogn)
注意y的坐标很大，要离散化

 var tree,lmax,rmax,maxx,c,rank:array[..] of longint;
     a:array[..] of int64;
     x,y,s:array[..] of longint;
     w,h,n,m,t,p,l,i,ans:longint;

 function max(a,b:longint):longint;
   begin
     if a>b then exit(a) else exit(b);
   end;

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

 procedure sorty(l,r: longint);
   var i,j: longint;
       x,y:int64;
   begin
     i:=l;
     j:=r;
     x:=a[(l+r) shr ];
     repeat
       while a[i]<x do inc(i);
       while x<a[j] do dec(j);
       if not(i>j) then
       begin
         y:=a[i];
         a[i]:=a[j];
         a[j]:=y;

         swap(c[i],c[j]);
         inc(i);
         j:=j-;
       end;
     until i>j;
     if l<j then sorty(l,j);
     if i<r then sorty(i,r);
   end;

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

 procedure work(i,l,r,x,z:longint);
   var m:longint;
   begin
     if l=r then
     begin
       inc(tree[i],z);
       lmax[i]:=tree[i];
       rmax[i]:=tree[i];
       maxx[i]:=tree[i];
     end
     else begin
       m:=(l+r) shr ;
       if x<=m then work(i*,l,m,x,z)
       else work(i*+,m+,r,x,z);
       inc(tree[i],z);
       lmax[i]:=max(lmax[i*],tree[i*]+lmax[i*+]);   //不多说
       rmax[i]:=max(rmax[i*+],tree[i*+]+rmax[i*]);
       maxx[i]:=max(lmax[i*+]+rmax[i*],max(maxx[i*],maxx[i*+]));
     end;
   end;

 begin
   while not eof do
   begin
     readln(n,w,h);
     for i:= to n do
       readln(x[i],y[i],s[i]);
     sortx(,n);
 //先对x排序，后面离散化y坐标对应就轻松一点
     for i:= to n do
     begin
       a[i]:=y[i];
       a[i+n]:=int64(y[i])+int64(h);//当然y+h这个位置也要离散化
       c[i]:=i;
       c[i+n]:=i+n;
     end;
     t:=n*;
     sorty(,t);
     p:=;
     rank[c[]]:=;
     for i:= to t do
     begin
       if (a[i]<>a[i-]) then inc(p);
       rank[c[i]]:=p;
     end;
     m:=p;
     fillchar(tree,sizeof(tree),);
     fillchar(lmax,sizeof(lmax),);
     fillchar(rmax,sizeof(rmax),);
     fillchar(maxx,sizeof(maxx),);
     l:=;
     ans:=;
     for i:= to n do
     begin
       while (l<i) and (int64(x[l])+int64(w)<=x[i])  do
       begin
         work(,,m,rank[l],-s[l]);   //删除左扫描线左边的点
         work(,,m,rank[l+n],s[l]);
         inc(l);
       end;
       work(,,m,rank[i+n],-s[i]);   //右加入扫描线上的点
       work(,,m,rank[i],s[i]);
       ans:=max(ans,maxx[]);
     end;
     writeln(ans);
   end;
 end.