[POJ 2482]Stars in Your Window 扫描线

题目链接：http://poj.org/problem?id=2482

题目大意：平面上有n个星星，每个星星有一个权值，给你一个w×h的框，问你框能框到的星星的最大权值和是多少。

这道题目做了我很久很久，据说是经典题中的经典，题面还是一个非常美的故事。。

然后就能够顺便总结出几个模型，在这里稍加记录一下。

【模型一】求任意区间的最大子段和（SPOJ 1043）

题目链接：http://www.spoj.com/problems/GSS1/

这道题目有点卡时间，题目大意是给你n个数，问你下标在[l,r]的最大子段和是多少。

思路是用线段树维护一个左起最大子段和，右起最大子段和，整个区间的最大子段和，整个区间的和，其中：

当前节点表示区间的左起最大子段和 = max( 左儿子的左起最大子段和,左儿子的区间和+右儿子的左起最大子段和 )

当前节点表示区间的右起最大子段和 = max( 右儿子的右起最大子段和,右儿子的区间和+左儿子的右起最大子段和 )

当前节点的最大子段和 = max( 左儿子的最大子段和,右儿子的最大子段和,左儿子的右起最大子段和+右儿子的左起最大子段和 )

查询十分复杂，另外此题十分卡时间，需要这样写线段树才能过：

#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;

const int INF = 999999999;
const int MAX_N = 50000+100;
int N,M,a[MAX_N];
int mid[MAX_N<<2],sum[MAX_N<<2],lmax[MAX_N<<2],rmax[MAX_N<<2],maxn[MAX_N<<2];

void build(int idx,int l,int r){
//sum[idx] = lmax[idx] = rmax[idx] = maxn[idx] = -INF;
mid[idx] = l+r>>1;
if( l==r ){
sum[idx] = lmax[idx] = rmax[idx] = maxn[idx] = a[l];
return;
}
build(idx<<1,l,mid[idx]);
build(idx<<1|1,mid[idx]+1,r);
sum[idx] = sum[idx<<1]+sum[idx<<1|1];
lmax[idx] = max( lmax[idx<<1],sum[idx<<1]+lmax[idx<<1|1] );
rmax[idx] = max( rmax[idx<<1|1],sum[idx<<1|1]+rmax[idx<<1] );
maxn[idx] = max(rmax[idx<<1]+lmax[idx<<1|1],max(maxn[idx<<1],maxn[idx<<1|1]));
}

//以L开头的最大区间和
int lquery(int L,int R,int idx,int l,int r){
//printf("[lquery]:L=%d,R=%d,idx=%d,l=%d,r=%d\n",L,R,idx,l,r);
if( L==l&&R==r ) return lmax[idx];
if( R<=mid[idx] ) return lquery(L,R,idx<<1,l,mid[idx]);
else if( L>mid[idx] ) return lquery(L,R,idx<<1|1,mid[idx]+1,r);
else return max(lquery(L,mid[idx],idx<<1,l,mid[idx]),sum[idx<<1]+lquery(mid[idx]+1,R,idx<<1|1,mid[idx]+1,r));
}

//以R结尾的最大区间和
int rquery(int L,int R,int idx,int l,int r){
//printf("[rquery]:L=%d,R=%d,idx=%d,l=%d,r=%d\n",L,R,idx,l,r);
if( L==l&&R==r ) return rmax[idx];
if( R<=mid[idx] ) return rquery(L,R,idx<<1,l,mid[idx]);
else if( L>mid[idx] ) return rquery(L,R,idx<<1|1,mid[idx]+1,r);
else return max(rquery(mid[idx]+1,R,idx<<1|1,mid[idx]+1,r),sum[idx<<1|1]+rquery(L,mid[idx],idx<<1,l,mid[idx]));
}

int query(int L,int R,int idx,int l,int r){
if( L==l&&R==r ) return maxn[idx];
if( R<=mid[idx] ) return query(L,R,idx<<1,l,mid[idx]);
else if( L>mid[idx] ) return query(L,R,idx<<1|1,mid[idx]+1,r);
else
return max(max(query(L,mid[idx],idx<<1,l,mid[idx]),query(mid[idx]+1,R,idx<<1|1,mid[idx]+1,r)),rquery(L,mid[idx],idx<<1,l,mid[idx])+lquery(mid[idx]+1,R,idx<<1|1,mid[idx]+1,r));
}

int main(){
while(scanf("%d",&N)!=EOF){
for(int i=1;i<=N;i++){
scanf("%d",&a[i]);
}
build(1,1,N);
scanf("%d",&M);
int l,r;
while( M-- ){
scanf("%d%d",&l,&r);
int ans = query(l,r,1,1,N);
printf("%d\n",ans);
}
}
return 0;
}

【模型二】求长度为w的最大子段和

意思是给你n个数，问你区间长度在w的最大子段和是多少？

这题就可以转化成为：对于下标为i的数（起始点为1），我们在线段的i的位置加上a[i]，然后再线段为i+w的位置加上-a[i]，然后求最大前缀和。

【模型三】求长度最长为w的最大子段和



意思是给你n个数，问你区间长度最长为w的最大子段和是多少？

这题目与上题不同的是，限制了区间长度最长为w，也就是说区间长度可以在w以内，那么我们只需要把上一个模型中，扫描到i点的时候，在i-w以左的所有点都置为0。然后求出每次动态修改得到的前缀和的最大值。

然后回到这一题上面来：本题要求的值可以转化为给定横坐标区间长度为w，在这个长度区间内去扫描纵坐标上的点，映射到纵坐标后求长度为h的最大子段和。因此代码就是下面这样了（这题数据范围貌似有点问题？）：

#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
typedef long long LL;

const int MAX_N = 101000;
int n,w,h;
LL maxn[MAX_N<<2],lmax[MAX_N<<2],rmax[MAX_N<<2],sum[MAX_N<<2];

struct STAR{
LL x,y,l;
bool operator<(const STAR& A) const {
return x<A.x;
}
};

STAR inp[MAX_N];
LL b[MAX_N<<1];

void push_up(int idx){
sum[idx] = sum[idx<<1]+sum[idx<<1|1];
lmax[idx] = max(lmax[idx<<1],sum[idx<<1]+lmax[idx<<1|1]);
rmax[idx] = max(rmax[idx<<1|1],sum[idx<<1|1]+rmax[idx<<1]);
maxn[idx] = max(max(maxn[idx<<1],maxn[idx<<1|1]),rmax[idx<<1]+lmax[idx<<1|1]);
}

void update(int pos,int x,int idx,int l,int r){
if( l==r ){
sum[idx] += x;
lmax[idx] = rmax[idx] = maxn[idx] = sum[idx];
return;
}
int m = l+r>>1;
if( pos<= m ) update(pos,x,idx<<1,l,m);
else update(pos,x,idx<<1|1,m+1,r);
push_up(idx);
}

int main() {
while(scanf("%d%d%d",&n,&w,&h)!=EOF){
memset(maxn,0,sizeof(maxn));
memset(lmax,0,sizeof(lmax));
memset(rmax,0,sizeof(rmax));
memset(sum,0,sizeof(sum));
int ptrb = 0;
for(int i=0;i<n;i++){
scanf("%I64d%I64d%I64d",&inp[i].x,&inp[i].y,&inp[i].l);
b[ptrb++] = inp[i].y;
b[ptrb++] = inp[i].y+h;
}
sort(inp,inp+n); sort(b,b+ptrb);
int ub = unique(b,b+ptrb) - b;
int s = 0;
LL ans = 0;
for(int i=0;i<n;i++){
//printf("%d has been excuted!\n",i);
while( s<i&&inp[s].x+w<=inp[i].x ){
int L = lower_bound(b,b+ub,inp[s].y) - b;
int R = lower_bound(b,b+ub,inp[s].y+h) - b;
update(L,-inp[s].l,1,0,ub-1);
update(R,inp[s].l,1,0,ub-1);
s++;
}
int L = lower_bound(b,b+ub,inp[i].y) - b;
int R = lower_bound(b,b+ub,inp[i].y+h) - b;
update(R,-inp[i].l,1,0,ub-1);
update(L,inp[i].l,1,0,ub-1);
ans = max(ans,lmax[1]);
}
printf("%I64d\n",ans);
}
return 0;
}