poj2482 Stars in Your Window

此题可用线段树或静态二叉树来做。

考虑用线段树：

很容易想到先限定矩形横轴范围再考虑在此纵轴上矩形内物品总价值的最大值。

那么枚举矩形横轴的复杂度是O（n）的，考虑如何快速获取纵轴上的最大值。

我们不可能再次枚举纵轴，依次统计，这样做事多余的。

考虑窗口在纵轴上的滑动，每上升到一个新的高度，在加入新元素的同时只需将最底层的那些值弹出队列即可。

这样我们需要考虑队列上元素和的最大值。

我们从反面考虑每个元素对特定队列（矩形纵轴位置）的贡献。

枚举窗口的上面一条边，那么元素对窗口贡献正值当且仅当H(element） < H(window_top) - b。

否则对窗口贡献0。

注意到变化是连续的，考虑统计所有高度不超过枚举高度的物品总价值减去那些高度低于窗口下端的物品总价值。

这样我们可以对每个点辅助构造一个对应的虚拟点，位置恰在该点上方b处，权值为是原点的相反数。

于是队列和的最大值变成统计前缀最大值。

y轴上离散化用线段是维护即可，x轴控制进出队。

 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 using namespace std;
 const int maxn = 1e5 + ;
 typedef __int64 LL;
 struct Seg{
     LL l, r;
     LL sum, maxl;
 }seg[maxn << ];
 LL n, a, b;
 LL k;
 LL base, len;
 struct Point{
     LL x, y, z;
     Point(LL x = , LL y = , LL z = ) : x(x), y(y), z(z) {}
 }t[maxn << ];

 bool cmp1(Point a, Point b){
     return a.y < b.y;
 }

 bool cmp2(Point a, Point b){
     return a.x < b.x;
 }

 void build(LL u, LL l, LL r){
     seg[u].l = l, seg[u].r = r;
     seg[u].maxl = seg[u].sum = ;
     if(r - l < ) return;
     LL mid = (l + r) >> ;
     build(u << , l, mid);
     build(u <<  | , mid, r);
 }

 void push_up(LL u){
     seg[u].sum = seg[u << ].sum + seg[u <<  | ].sum;
     seg[u].maxl = max(seg[u << ].maxl, seg[u << ].sum + seg[u <<  | ].maxl);
 }

 void add(LL u, LL l, LL r, LL L, LL R, LL from, LL d){
     if(l == L && r == R){
         seg[u].maxl += d * t[from].z;
         seg[u].sum += d * t[from].z;
         return;
     }
     LL mid = (l + r) >> ;
     if(R <= mid) add(u << , l, mid, L, R, from, d);
     else if(L >= mid) add(u <<  | , mid, r, L, R, from, d);
     push_up(u);
 }

 int main(){
     //freopen("in.txt", "r", stdin);
     while(~scanf("%I64d%I64d%I64d", &n, &a, &b)){
         for(LL i = , x, y, z; i <= n; i++){
             scanf("%I64d%I64d%I64d", &x, &y, &z);
             t[i] = Point(x, y, z);
             t[i + n] = Point(x, y + b, -z);
         }
         len = n << ;
         sort(t + , t + len + , cmp1);
         base = t[].y;
         t[].y = ;
         for(LL i = ; i <= len; i++){
             if(t[i].y == base) t[i].y = t[i - ].y;
             else{
                 base = t[i].y;
                 t[i].y = t[i - ].y + ;
             }
         }
         LL high = t[len].y;
         sort(t + , t + len + , cmp2);
         base = ;
         while(base <= len && t[base].x - t[].x < a) ++base;
         build(, , high + );
         for(LL i = ; i < base; i++) add(, , high + , t[i].y, t[i].y + , i, );
         LL ans = seg[].maxl;
         LL pre = ;
         for(LL i = base; i < len + ; i++){
             LL tp = pre;
             while(tp < len +  && t[i].x - t[tp].x >= a) ++tp;
             for(LL j = pre; j < tp; j++) add(, , high + , t[j].y, t[j].y + , j, -);
             LL tem = i;
             while(i < len && t[i + ].x == t[i].x) ++i;
             for(LL j = tem; j <= i; j++) add(, , high + , t[j].y, t[j].y + , j, );
             ans = max(ans, seg[].maxl);
             pre = tp;
         }
         printf("%I64d\n", ans);
     }
     return ;
 }