poj 2482 Stars in Your Window(线段树+扫描线)

http://poj.org/problem?id=2482

题意：给出n个星星的坐标的亮度，一个矩形的宽和长，分别是w和h。问这个矩形能够框住的星星的最大亮度是多少。

看的解题报告，愧疚中。。。直接说思路吧。

解题：

将每个星星分成两个星星(x,y,val)和(x+w,y,-val)。当不断加入星星的时候相当于一个矩形框从左向右移动，当遇到第一个星星总亮度加上val,说明框住了该星星，当遇到第二个星星再加上-val，相当于没有框住星星。

先对y轴坐标离散化，对每个星星按x坐标从小到大排序，然后从左向右扫描每个线段[y,y+h]，在线段树中相应区间加上val。用线段树求出此刻的最大值，插入完所有星星后，最大值就求出来了。

今天又拿出来这道题，重新思考了一下，每个星星被圈住的范围是(x,y)~(x+w,y+h)。其实就把每个星星变为一个矩形，求所有矩形重叠的最大亮度。可以按照求面积并的方法思考，因为把星星拆成两个点(x,y,val)和（x+w,y,-val），即把这两个点所在的竖边分别看做上边和下边，上边就加val,下边就减val，对于每一条竖边用扫描线[y,y+h]去扫描，更新[y,y+h]的val，每更新一次，求出当前状态下所框住星星的亮度，最后比较得到最大的。

#include <stdio.h>
#include <string.h>
#include <algorithm>
#define lint __int64

using namespace std;

const int maxn = 1000000;
lint y[maxn];
struct item
{
	lint x,y,val;
}point[maxn];

struct line
{
	lint l,r,add,sum;
}tree[maxn];

int cmp(const struct item & a, const struct item & b)
{
	//优先按x排序，若x相等，按val从小到大排序
	if(a.x == b.x)
		return a.val < b.val;
	return a.x < b.x;
}

void build(lint v,lint l, lint r)
{
	tree[v].l = l;
	tree[v].r = r;
	tree[v].add = tree[v].sum = 0;
	if(l == r)
		return;
	lint mid = (l+r)>>1;
	build(v*2,l,mid);
	build(v*2+1,mid+1,r);
}

int binsearch(lint low, lint high,lint key)
{
	while(low <= high)
	{
		int mid = (low+high)>>1;
		if(y[mid] == key)
			return mid;
		if(y[mid] < key)
			low = mid+1;
		else high = mid-1;
	}
	return 0;
}

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

	if(tree[v].add)
	{
		tree[v*2].add += tree[v].add;
		tree[v*2].sum += tree[v].add;
		tree[v*2+1].add += tree[v].add;
		tree[v*2+1].sum += tree[v].add;
		tree[v].add = 0;
	}
	lint mid = (tree[v].l + tree[v].r)>>1;
	if(r <= mid)
		update(l,r,val,v*2);
	else if(l > mid)
		update(l,r,val,v*2+1);
	else
	{
		update(l,mid,val,v*2);
		update(mid+1,r,val,v*2+1);
	}
	tree[v].sum = max(tree[v*2].sum,tree[v*2+1].sum);
}

int main()
{
	lint n,w,h,i,ans,cnt;
	while(~scanf("%I64d %I64d %I64d",&n,&w,&h))
	{
		for(i = 1; i <= n; i++)
		{
			scanf("%I64d %I64d %I64d",&point[i].x,&point[i].y,&point[i].val);
			//分成两个星星。
			y[i] = point[i].y;
			y[n+i] = point[i].y+h;
			point[i+n].x = point[i].x+w;
			point[i+n].y = point[i].y;
			point[i+n].val = -point[i].val;
		}

		sort(y+1,y+1+n*2);
		sort(point+1,point+1+n*2,cmp);
		//对y离散化
		cnt = 1;
		for(i = 2; i <= n*2; i++)
		{
			if(y[i] != y[i-1])
				y[++cnt] = y[i];
		}
		build(1,1,cnt);

		ans = 0;
		for(i = 1; i <= n*2; i++)
		{
			lint l = binsearch(1,cnt,point[i].y);
			lint r = binsearch(1,cnt,point[i].y+h)-1;//对每个星星，求出其纵坐标对应离散后的编号
			if(l > r)
				swap(l,r);
			update(l,r,point[i].val,1);//更新[l,r]区间val值
			ans = max(ans,tree[1].sum);
		}
		printf("%I64d\n",ans);
	}
	return 0;
}