POJ 2482 Stars in Your Window 线段树

题意：每一颗星星有一定的亮度值，现在坐标系中有许多星星，每个星星的坐标及亮度值已经给定，求一个矩形能够框住的最大值。Lazy 标记。

题解：对每一颗星星，画出以它为左下角的矩形，这个矩形就是它的影响范围。为了方便处理，我们将每一颗星分作两颗，

frist_star ( x, y, val ),  second_star ( x + w, y, -val )，这样当我们不断插入星星的时候，其实就相当于有一个矩形框在从左往右移动，因为碰到 first_star 则总亮度加上 val 说明框住了星星，碰到 second_star 则再加上 -val， 那么 val + (-val ) = 0， 相当于没有框住星星。 那么，我们每插入一颗星就得到一个 x 轴范围固定，但是 y 轴范围不定的矩形（也就是两条扫描线，因为矩形上下两边不定）。如此便只需要维护 y
坐标这一个变量了，让 [ y, y + h ] 这一区间加上val， 用线段树求得此时刻的最大值。当所有星星都插入完成，得到的最大值也就是我们要求的值了。

           另外有一点需要注意，不能加上矩形边上的点。（我想原意应该是星星本身要加，以星星为左下角的矩形的其他边上的星星则不加）。因此对节点排序时便要注意了，当 x 相同的时候切记 val 小的要放在前面！否则求的的最大值就有可能包含边上点的。

#include <iostream>
using namespace std;

#define lint __int64
#define N 1000000
lint y
;

struct item
{
lint x, y, v;
} point
;

struct line
{
lint l, r, sum, add;
} node
;

int ycmp ( const void* a, const void* b )
{
return *(lint*)a - *(lint*)b;
}

int pcmp ( const void *a, const void *b )
{
item *ta = (item*)a;
item *tb = (item*)b;
if ( ta->x == tb->x )
return ta->v - tb->v; /* 注意 val 为负则放在前面， 否则会加上边界的点 */
return ta->x - tb->x;
}

lint max ( lint a, lint b )
{
return a > b ? a : b;
}

void build_tree ( lint left, lint right, lint u )
{
node[u].l = left;
node[u].r = right;
node[u].sum = node[u].add = 0;
if ( left == right ) return;
lint mid = ( left + right ) / 2;
build_tree ( left, mid, u * 2 );
build_tree ( mid + 1, right, u * 2 + 1 );
}

int bfind ( lint l, lint r, lint key )
{
while ( l <= r )
{
int mid = ( l + r ) / 2;
if ( y[mid] == key )
return mid;
if ( key < y[mid] )
r = mid - 1;
else if ( key > y[mid] )
l = mid + 1;
}
return 0;
}

void update ( lint l, lint r, lint val, lint u )
{
if ( l <= node[u].l && node[u].r <= r )
{
node[u].add += val;
node[u].sum += val;
return;
}

if ( node[u].add != 0 )
{
node[u*2].add += node[u].add;
node[u*2].sum += node[u].add;
node[u*2+1].add += node[u].add;
node[u*2+1].sum += node[u].add;
node[u].add = 0;
}

lint mid = ( node[u].l + node[u].r ) / 2;
if ( r <= mid )
update ( l, r, val, u * 2 );
else if ( l > mid )
update ( l, r, val, u * 2 + 1 );
else
{
update ( l, mid, val, u * 2 );
update ( mid + 1, r, val, u * 2 + 1 );
}
node[u].sum = max ( node[u*2].sum, node[u*2+1].sum );
}

int main()
{
lint n, w, h, i, cnt, ans;
//freopen("a.txt","r",stdin);
while ( scanf("%I64d%I64d%I64d",&n,&w,&h ) != EOF )
{
for ( i = 1; i <= n; ++i )
{
scanf("%I64d%I64d%I64d",&point[i].x, &point[i].y, &point[i].v );
y[i] = point[i].y;
y[n+i] = point[i].y + h;
point[n+i].x = point[i].x + w;
point[n+i].y = point[i].y;
point[n+i].v = -point[i].v;
}

qsort ( y+1, 2*n, sizeof(y[1]), ycmp );
qsort ( point+1, 2*n, sizeof(point[1]), pcmp);

for ( i = cnt = 1; i <= 2 * n; ++i )
{
if ( y[cnt] != y[i] )
y[++cnt] = y[i];
}

build_tree ( 1, cnt, 1 );

ans = 0;
for ( i = 1; i <= 2 * n; ++i )
{
lint left = bfind ( 1, cnt, point[i].y );
lint right = bfind ( 1, cnt, point[i].y + h ) - 1;
if ( left > right ) swap(left,right);
update ( left, right, point[i].v, 1 );
ans = max ( ans, node[1].sum );
}
printf ( "%I64d\n", ans );
}
return 0;
}