POJ2482 Stars in Your Window(线段树)

题意：在一个平面内有N个星星，每个星星都在一个亮度值，用一个W*H的矩形去围这些星星，（边上的不算）求能得到的最大亮度值。

思路：我们很容易想到，可以动态的维护出每个宽度为W 的区间内，找出满足的星星，然后在高度为H的范围内求和。

但是这样明显时间复杂度太高，维护宽度为W的区间只需要o(n),在高度为H的范围内求和时间复杂度为o(n*H),总的就是o(n^2*H).

显然“维护宽度为W的区间”已经不能再优化了，就只有对后面的“高度为H的范围内求和”进行优化。

如果，对于每一个在范围点(x,y)亮度为c，我们再在(x,y+H)建一个亮度为-c的点，再将这些亮点质按照它们的纵坐标的大小进行排序，那么我们将只需要这个序列的最大前缀和即可。但是这么写还是会Time Limit Exceeded。此时就需要用到线段树了，来动态维护整个区间的最大前缀和。当添加(或者删除)一个点的时候，只会影响y和y+H这两个点本身即以后的前缀和的值。

由于y的范围较大，需要进行离散化。

#include<iostream>
#include<algorithm>
#include<string.h>
#include<stdio.h>
#include<math.h>
#include<queue>
using namespace std;

#define nn 10100
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
#define maxx 1e9
#define ll long long

ll pos[nn<<1];
struct point
{
    ll x,y;
    ll v;
}p[nn];
struct node
{
    ll mx,v;
}t[nn<<3];
int num,n;
ll w,h;

bool cmp(point a,point b)
{
    return a.x<b.x;
}

int binary(ll a)//二分
{
    int top=num-1;
    int low=0;
    while(low<=top)
    {
        int mid=(low+top)>>1;
        if(pos[mid]==a) return mid;
        else if(pos[mid]>a) top=mid-1;
        else low=mid+1;
    }
    return -1;
}

void pushdown(int rt)
{
    if(t[rt].v!=0)
    {
        t[rt<<1].v+=t[rt].v;
        t[rt<<1|1].v+=t[rt].v;
        t[rt<<1|1].mx+=t[rt].v;
        t[rt<<1].mx+=t[rt].v;
        t[rt].v=0;
    }
}

void updata(int l,int r,int rt,int L,int R,int v)//更新
{
    if(L<=l && r<=R)
    {
        t[rt].v+=v;
        t[rt].mx+=v;
        return;
    }
    pushdown(rt);
    int mid=(l+r)>>1;
    if(L<=mid) updata(lson,L,R,v);
    if(R>mid) updata(rson,L,R,v);
    t[rt].mx=max(t[rt<<1].mx,t[rt<<1|1].mx);
}

void insert(point a)//加点
{
    int y1=binary(a.y);
    int y2=binary(a.y+h);
    updata(0,num-1,1,y1,num-1,a.v);
    updata(0,num-1,1,y2,num-1,-a.v);
}

void del(point a)//删点
{
    ll y1=binary(a.y);
    ll y2=binary(a.y+h);
    updata(0,num-1,1,y1,num-1,-a.v);
    updata(0,num-1,1,y2,num-1,a.v);
}

ll query()
{
    return t[1].mx;
}

void build(int l,int r,int rt)//建树
{
    t[rt].mx=0;t[rt].v=0;
    if(l==r) return ;
    int mid=(l+r)>>1;
    build(lson);
    build(rson);
}

int main()
{
    while(~scanf("%lld%lld%lld",&n,&w,&h))
    {
        int m=0;
        for(int i=0;i<n;i++)
        {
            scanf("%lld%lld%lld",&p[i].x,&p[i].y,&p[i].v);
            pos[m++]=p[i].y;
            pos[m++]=p[i].y+h;
        }
        sort(p,p+n,cmp);//排序
        sort(pos,pos+m);//排序
        num=1;
        for(int i=1;i<m;i++)//去重
            if(pos[i]!=pos[i-1])
                pos[num++]=pos[i];

        int l=0,r=0;
        build(0,num-1,1);
        for(r=0;r<n;r++)
        {
            if(p[r].x<p[0].x+w)
                insert(p[r]);
            else break;
        }

        ll ans=query();
        for(;l<n;)
        {
            ll k=p[l].x;
            for(;l<n;l++)
            {
                if(p[l].x==k)
                    del(p[l]);
                else break;
            }

            for(;r<n;r++)
            {
                if(p[r].x<w+p[l].x)
                    insert(p[r]);
                else break;
            }

            ans=max(ans,query());
        }
        printf("%lld\n",ans);
    }
    return 0;
}