Estrelas em seu Windows POJ2482 (linha segmento de digitalização matriz, o intervalo máximo, a atualização intervalo)

-Tronco que:
Há muitas estrelas (vistos como plano retangular sistema de coordenadas) em um céu, as coordenadas conhecidas e luminância de cada estrela (são inteiros) procurando uma largura w, a altura h do retângulo (w, h é um inteiro ) a soma do brilho das estrelas pode ser circulado é o maior número (estrelas no limite rectangular não é).
entrada

Há vários casos de teste da entrada. A primeira linha de cada caso contém 3 inteiros: n, W, H, indicando o número de estrelas, o comprimento horizontal e a altura vertical da janela do rectângulo em forma. Então n linhas seguir, com 3 inteiros cada: X, Y, c, dizendo a localização (x, y) e o brilho de cada estrela. Não há duas estrelas estão no mesmo ponto.

Há pelo menos 1 e no máximo 10000 estrelas no céu. 1 <= W, H <= 1000000, 0 <= x, y <2 ^ 31.
Resultado

Para cada teste, a saída do brilho máximo em uma única linha.
Entrada de amostra

3 5 4
1 2 3
2 3 2
6 3 1
3 5 4
1 2 3
2 3 2
5 3 1
Exemplo de saída

. 5
. 6
Solução:
Porque um rectângulo de tamanho fixo, o rectângulo pode ser um vértice da sua posição unicamente determinada pela sua arbitrária. Podemos considerar o canto direito superior do retângulo em que vértice posição, a soma do brilho máximo das estrelas circulou.

Para uma estrela (x, y, C), em que x, y as coordenadas, c representa a luminância, "rectângulo pode ser circundado que estrela no canto superior direito do intervalo do vértice" como mostrado na FIG. Esta gama é também um rectângulo, o vértice inferior esquerdo (x, y), o vértice superior direito (x + w, y + H). Para que não restem dúvidas, na discussão a seguir, temos de substituir esta faixa com a palavra "região".

Em questão, existem diversas áreas no plano **, cada região possuindo um valor de peso, encontrar a área em que o peso e coordenadas sobreposição máxima. ** em que cada região é gerado por uma estrela, a estrela igual ao valor do peso de luminância, o canto superior direito dos problemas retângulo originais nesta área, que pode ser rodeado algumas estrelas.

Após conversão problema, usamos o algoritmo de exploração de linha, tomada em torno do limite de cada região, armazenado em dois de quatro tuplo (x, y, y + h -1, c) , e (x + w, y, y + h -1, -c). Estes quatro tupla (um primeiro valor de dimensão) escolhidas abscissa.

Sobre os mesmos valores das ordenadas tempo para estabelecer uma linha de árvore, os intervalos máximos de manutenção, inicialmente todos os zeros. Podemos pensar em uma árvore de segmentos de "y" do intervalo elemento representativo [y, y + 1], e o intervalo de [y, y + h-1] pode ser expressa como o segmento da árvore y, y + 1, y + 2, ..., y + h-1 estes valores. Assim, a árvore de segmentos de manutenção é a sequência de uma pluralidade de valores numéricos.

digitalizar individualmente cada um dos quatro-tuplo (X, Y1, Y2, c), a modificação árvore de segmentos da linha de corte de execução (bandeira atraso disponível implementado), o [y1, y2] Cada valor C são adicionados, em seguida, o nó de raiz com o valor dat a resposta pode ser atualizado.

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int u=20010;
struct rec{unsigned int x,l,r; int c;}a[u];
struct{int p,l,r,dat,add;}t[u*4];
unsigned int b[u],c[u],x,y,w,h;
int n,m,p,i,ans,z;

bool cmp(rec a,rec b)
{
	return a.x<b.x||a.x==b.x&&a.c<b.c;
}

void build(int p,int l,int r)
{
	t[p].l=l,t[p].r=r,t[p].dat=t[p].add=0;
	if(l==r) return;
	int mid=(l+r)>>1;
	build(p*2,l,mid);
	build(p*2+1,mid+1,r);
}

void spread(int p)
{
	if(t[p].add)
	{
		t[p*2].dat+=t[p].add,t[p*2].add+=t[p].add;
		t[p*2+1].dat+=t[p].add,t[p*2+1].add+=t[p].add;
		t[p].add=0;
	}
}

void change(int p,int l,int r,int c)
{
	if(l<=t[p].l&&r>=t[p].r)
	{
		t[p].dat+=c,t[p].add+=c;
		return;
	}
	spread(p);
	int mid=(t[p].l+t[p].r)>>1;
	if(l<=mid) change(p*2,l,r,c);
	if(r>mid) change(p*2+1,l,r,c);
	t[p].dat=max(t[p*2].dat,t[p*2+1].dat);
}

int main()
{
	while(cin>>n>>w>>h)
	{
		for(m=p=0,i=1;i<=n;i++)
		{
			scanf("%u%u%d",&x,&y,&z);
			a[i].l=a[n+i].l=y,a[i].r=a[n+i].r=y+h-1;
			a[i].x=x,a[n+i].x=x+w,a[i].c=z,a[n+i].c=-z;
			b[++m]=y,b[++m]=y+h-1;
		}
		sort(b+1,b+m+1);
		for(i=1;i<=m;i++)
			if(i==1||b[i]!=b[i-1]) c[++p]=b[i];
		for(n*=2,i=1;i<=n;i++)
		{
			a[i].l=lower_bound(c+1,c+p+1,a[i].l)-c;
			a[i].r=lower_bound(c+1,c+p+1,a[i].r)-c;
		}
		sort(a+1,a+n+1,cmp);
		build(1,1,p);
		for(ans=0,i=1;i<=n;i++)
		{
			change(1,a[i].l,a[i].r,a[i].c);
			ans=max(ans,t[1].dat);
		}
		cout<<ans<<endl;
	}
	return 0;
}