2014 UESTC Training for Data Structures D

看出司马懿在等蜀军粮草不济，孔明于是下令分兵屯田以备久战。

司马懿日日只是闭营不出。孔明每日思虑对策至天明，却也无可奈何。

漫天星辰中有一类星叫做将星，它们随着将魂的燃烧会越发明亮。

今夜五丈原的星空格外璀璨。

司马懿一声轻叹。五丈原的星，要落了。

Input

第一行输入三个整数，n,W,H，分别表示有n颗星，矩形宽W，高H,。

接下来n行，每行三个整数，xi,yi,wi。表示第i颗星星的在天空的位置是(xi,yi)，亮度是wi。

1≤n≤100000,1≤W,H≤1000000,0≤x,y≤100000000,1≤wi≤100

Output

仅一行，该行只包含一个整数，表示平移矩形后，矩形内星星的亮度之和最大能是多少。

Sample input and output

Sample Input	Sample Output
3 5 4 1 2 3 2 3 2 6 3 1	5

题意是找一个矩形可以框住总亮度最大的星星群。

首先需要离散化，因为题目中y的取值太大而又要以y轴建线段树，做法是先排序，按顺序标序号，相同的Y要标相同的序号。然后对每个点操作      如果其y值加H比下几个点大那就记录一下一共有几个点（包括这个点）xin.len；

然后再生成n个虚点，他们的坐标是（x-W,y）。

扫描线从左往右扫描，遇到虚点就在y轴的线段树加入区间（当前节点i到i+xin.len-1）,遇到实点就删除区间，（如果x相同优先操作实点）。每次区间操作完都更新一下答案max。

#include <iostream>
#include<cstring>
#include<algorithm>
#include<stdio.h>
using namespace std;

struct node{
    int left;
    int right;
    int data;
    int lazy;
}shu[200005];
int n,W,H;
struct mmmm{
    int x;
    int y;
    int w;
    bool real;
    int len;
}xin[200005];
bool cmpy(const mmmm &j,const mmmm &k)
{
    if (j.y!=k.y) return (j.y<k.y);
    else return (j.x<k.x);
}
bool cmpx(const mmmm &j,const mmmm &k)
{
    if (j.x!=k.x) return (j.x<k.x);
    else return (j.real>k.real);
}
void jian(int j,int g,int h)
{
    shu[j].left=g;shu[j].right=h;
    if (g==h) return;
    jian(j*2,g,(g+h)/2);
    jian(j*2+1,(g+h)/2+1,h);
}
void push_down(int l)
{
    if (shu[l].lazy!=0){
        shu[l*2].lazy+=shu[l].lazy;
        shu[l*2+1].lazy+=shu[l].lazy;
        shu[l*2].data+=shu[l].lazy;
        shu[l*2+1].data+=shu[l].lazy;
        shu[l].lazy=0;
    }
    return;
}
void inside(int g,int h,int l,int light)
{
    bool b=false;
        if (shu[l].left==shu[l].right) {shu[l].data+=light;return ;}
        if (shu[l].left==g && shu[l].right==h) {shu[l].lazy+=light;shu[l].data+=light;return ;}
        push_down(l);
        if (g>(shu[l].left+shu[l].right)/2) {inside(g,h,l*2+1,light);b=true;}
        if (h<=(shu[l].left+shu[l].right)/2) {inside(g,h,l*2,light);b=true;}
        if (!b) {
            inside(g,(shu[l].left+shu[l].right)/2,l*2,light);
            inside((shu[l].left+shu[l].right)/2+1,h,l*2+1,light);
        }
        shu[l].data=max(shu[l*2].data,shu[l*2+1].data);
}

int main()
{
    memset(shu,0,sizeof(shu));
    memset(xin,0,sizeof(xin));
    cin>>n>>W>>H;
    int g,h,j,l;
    for (j=0;j<n;j++) scanf("%d%d%d",&xin[j].x,&xin[j].y,&xin[j].w);
    sort(xin,xin+n,cmpy);
    h=1;g=0;
    while (g<n){
        while (g<n && xin[g].y==xin[g+1].y) {
            xin[g].len=h;
            g++;
        }
        xin[g].len=h;
        h++;g++;
    }
    g=0;
    for (j=0;j<n;j++){
        while (g<n && xin[j].y+H>xin[g].y) g++;
        g--;
        xin[j].y=xin[j].len;
        xin[j].len=xin[g].len-xin[j].len+1;
    }
    h=xin[n-1].y;
    for (j=0;j<n;j++){
        xin[j].real=true;
        xin[j+n].x=xin[j].x-W;
        xin[j+n].y=xin[j].y;
        xin[j+n].w=xin[j].w;
        xin[j+n].real=false;
        xin[j+n].len=xin[j].len;
    }
    sort(xin,xin+2*n,cmpx);
    jian(1,1,h);
    int max=-1;
    for (j=0;j<2*n;j++){
        if (xin[j].real) l=-1;else l=1;
        inside(xin[j].y,xin[j].y+xin[j].len-1,1,l*xin[j].w);
        if (shu[1].data>max) max=shu[1].data;
    }
    cout<<max<<endl;
    return 0;
}