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[N];

struct item
{
	lint x, y, v;
} point[N];

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

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;
}