POJ 2482 Stars in Your Window 线段树+扫描线

妈个鸡，要不是队友提醒，我能把题面上的那封情书读完，读了一半多了都

然后题意就是，在一个平面直角坐标系上，有一些点，每个点有一个权值，用一个矩形框去框住他们，问怎么才能使框住的所有点的权值和最大，边界上的点不算。

边界上的点 不算，我之前只做到过一次边界上的点算的啊，怎么办，把长和宽都各自-1就好啦。处理之后，设长为w，宽为h。

大概就是，把一个点沿一个方向，假如说是x轴，沿x轴向正方向延长w个长度，然后这是一条入边，在y+h+1上，建一条相应的出边，就是权值取个负数，就相当于把这条边又给删去啦。

然后将所有的边按y排序，根据y从小到大，加入边，就是更新(x,x+w)这个区间。想想，这样的话，某一点 x0就可以有x0为右边界的矩形的框住的权值和，然后y又是从下往上扫的，而且还有出边，所以(x0,y0)表示以这个点为右上角的矩形框住的权值和。

比如我们更新到了y=yi，在把所有y=yi的边都更新之后，线段树存的是x，对应的最大值。所以线段树的根的最大值，就代表在y=yi下(xi,yi)为右上角的矩形框住最大权值和。

然后y从0扫到最大值，就可以得到最大权值和啦。

代码：

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <algorithm>
using namespace std;
#define maxn 10002
#define uint unsigned int
uint x_data[maxn * 2], y_data[maxn * 2];
struct Node
{
	unsigned int x, y;
	int val;
	void made(unsigned int a, unsigned int b,int c)
	{
		x = a, y = b, val = c;
	}
}node[maxn];
struct edge_mode
{
	int y, l, r, val;
	void edge_make(int y, int l, int r, int val)
	{
		this->y = y;
		this->l = l;
		this->r = r;
		this->val = val;
	}
}edge[20005];
struct segment
{
	int add, max;
}segtree[160005];
bool cmp(edge_mode a, edge_mode b)
{
	if (a.y < b.y) return true;
	else return false;
}
void init(int id, int l, int r)
{
	segtree[id].add = segtree[id].max = 0;
	if (l == r) return;
	init(id << 1, l, (l + r) >> 1);
	init(id << 1 | 1, ((l + r) >> 1) + 1, r);
}
void update(int id, int l, int r, int nl, int nr, int val)
{
	if (r<nl || l>nr) return;
	if (l >= nl&&r <= nr)
	{
		segtree[id].add += val;
		segtree[id].max += val;
		return;
	}
	update(id << 1, l, (l + r) >> 1, nl, nr, val);
	update(id << 1 | 1, ((l + r) >> 1) + 1, r, nl, nr, val);
	segtree[id].max = max(segtree[id << 1].max, segtree[id << 1 | 1].max) + segtree[id].add;
}
int main()
{
	//freopen("input.txt", "r", stdin);
	int n, w, h;
	while ((scanf("%d%d%d", &n, &w, &h)) == 3)
	{
		--w, --h;
		init(1, 0, 20000);
		//unsigned int x, y;
		for (int i = 0; i < n; ++i)
		{
			scanf("%u%u%d", &node[i].x, &node[i].y, &node[i].val);
			x_data[2 * i] = node[i].x, x_data[2 * i + 1] = node[i].x + w;
			y_data[2 * i] = node[i].y, y_data[2 * i + 1] = node[i].y + h + 1;
		}
		sort(x_data, x_data + 2 * n);
		sort(y_data, y_data + 2 * n);
		uint x_d = unique(x_data, x_data + 2 * n) - x_data, y_d = unique(y_data, y_data + 2 * n) - y_data;
		for (int i = 0; i < n; ++i)
		{
			int x1 = lower_bound(x_data, x_data + x_d, node[i].x) - x_data;
			int y1 = lower_bound(y_data, y_data + y_d, node[i].y) - y_data;
			int x2 = lower_bound(x_data, x_data + x_d, node[i].x + w) - x_data;
			int y2 = lower_bound(y_data, y_data + y_d, node[i].y + h + 1) - y_data;
			edge[2 * i].edge_make(y1, x1, x2, node[i].val);
			edge[2 * i + 1].edge_make(y2, x1, x2, -1 * node[i].val);
			//printf("%d %d %d %d %d\n", x1, y1, x2, y2, node[i].val);
		}
		sort(edge, edge + 2 * n, cmp);
		int ans = 0;
		for (int i = 0, t = 0; i <= 20000; i++)
		{
			while (edge[t].y == i&&t < 2 * n)
			{
				update(1, 0, 20000, edge[t].l, edge[t].r, edge[t].val);
				t++;
			}
			//if (i <= 5)
				//printf("%d\n", segtree[1].max);
			ans = max(ans, segtree[1].max);
		}
		printf("%d\n", ans);
	}
	//while (1);
	return 0;
}