HDU 3016 Man Down——线段树

传送门
Problem Description
The Game “Man Down 100 floors” is an famous and interesting game.You can enjoy the game from

We take a simplified version of this game. We have only two kinds of planks. One kind of the planks contains food and the other one contains nails. And if the man falls on the plank which contains food his energy will increase but if he falls on the plank which contains nails his energy will decrease. The man can only fall down vertically .We assume that the energy he can increase is unlimited and no borders exist on the left and the right.

First the man has total energy 100 and stands on the topmost plank of all. Then he can choose to go left or right to fall down. If he falls down from the position (Xi,Yi),he will fall onto the nearest plank which satisfies (xl <= xi <= xr)(xl is the leftmost position of the plank and xr is the rightmost).If no planks satisfies that, the man will fall onto the floor and he finishes his mission. But if the man’s energy is below or equal to 0 , he will die and the game is Over.

Now give you the height and position of all planks. And ask you whether the man can falls onto the floor successfully. If he can, try to calculate the maximum energy he can own when he is on the floor.(Assuming that the floor is infinite and its height is 0,and all the planks are located at different height).

Input
There are multiple test cases.

For each test case, The first line contains one integer N (2 <= N <= 100,000) representing the number of planks.

Then following N lines representing N planks, each line contain 4 integers (h,xl,xr,value)(h > 0, 0 < xl < xr < 100,000, -1000 <= value <= 1000), h represents the plank’s height, xl is the leftmost position of the plank and xr is the rightmost position. Value represents the energy the man will increase by( if value > 0) or decrease by( if value < 0) when he falls onto this plank.

Output
If the man can falls onto the floor successfully just output the maximum energy he can own when he is on the floor. But if the man can not fall down onto the floor anyway ,just output “-1”(not including the quote)

Sample Input

4
10 5 10 10
5 3 6 -100
4 7 11 20
2 2 1000 10

Sample Output

140

题意： 人物具有100的初始分值，从最高的木板上可以选择左边或右边垂直往下跳，注意是垂直的（落地点的坐标与落下时的初始坐标相同），不同木板上具有不同的分值，输出到达地面时所能达到的最高分值；如果分值≤0，则输出-1.
题解： 我一开始真的被线段树的模板给限制住了，花了很长很长的时间在思考，我到底要怎么修改区间更新函数。此题特殊的在于，只能从某块木板的两端下落，下落之后人物又可以移动到下一块木板的两端，所以我真的真的不知道该怎么处理区间更新函数。直到吃完饭，我才反应过来，只要去判断木块两端下落之后分数的变动，然后取最大值，用这个最大值冲洗覆盖原先木板这个区间的分数值就可以了，相通之后其实是非常简单的。然后就是套模板了。

#include<iostream>
#include<algorithm>
using namespace std;
const int N = 100005;
typedef long long LL;

int n, q;
LL a[N];
LL  lazy[N << 2];
struct node{
    int h, l, r, c;
    friend bool operator<(const node &a, const node &b){
        return a.h < b.h;}
} plank[N];

struct Tree{
	int l, r;
	LL sum, max_sum;
	int mid(){	return (l + r) >> 1;}
}tree[N<<2];

void PushUp(int rt){ 
    tree[rt].max_sum = max(tree[rt << 1].max_sum, tree[rt << 1 | 1].max_sum);
}

void PushDown(int rt){
	if(lazy[rt]){
		lazy[rt << 1] = lazy[rt];
		lazy[rt << 1 | 1] = lazy[rt];
        tree[rt << 1].max_sum = lazy[rt];
        tree[rt << 1 | 1].max_sum = lazy[rt];
        lazy[rt] = 0;
	}
}

void build(int l, int r, int rt){
	tree[rt].l = l;
	tree[rt].r = r;
	lazy[rt] = 0;
	if (l == r)	{
		tree[rt].sum = tree[rt].max_sum = a[l];
        return;
	}
	int m = tree[rt].mid();
	
	build(l, m, (rt << 1));
	build(m + 1, r, (rt << 1 | 1));
	
	PushUp(rt);
}

void update(LL c, int l, int r, int rt){
	if(tree[rt].l==l && tree[rt].r==r){
		lazy[rt] = c;
        tree[rt].max_sum = c;//
        return;
	}
	 
	if(tree[rt].l == tree[rt].r)	return;
	
	int m = tree[rt].mid();
	PushDown(rt);
	if (r <= m)		update(c, l, r, rt << 1);
	else if(l > m)	update(c, l, r, rt << 1 | 1);
	else {
		update(c, l, m, rt << 1);
		update(c, m + 1, r, rt << 1 | 1);
    }
	PushUp(rt);
}


LL Max(int l, int r, int rt){//
	if (l==tree[rt].l && r==tree[rt].r)
		return tree[rt].max_sum;
	int m = tree[rt].mid(); 
	PushDown(rt);
	LL res = 0;
	if(r <= m)		res = Max(l, r, rt << 1);
	else if(l > m)	res = Max(l, r, rt << 1 | 1);
	else
        res = max(Max(l, m, rt << 1), Max(m + 1, r, rt << 1 | 1));
    return res;
}

int main(){
    while(~scanf("%d", &n)){
        for (int i = 1; i <= 100000; i++)
            a[i] = 100;
        build(1, 100000, 1);
        for (int i = 1; i <= n; i++)
            scanf("%d%d%d%d", &plank[i].h, &plank[i].l, &plank[i].r, &plank[i].c);
        sort(plank + 1, plank + n + 1);
        for (int i = 1; i <= n; i++){
			int l = plank[i].l, r = plank[i].r;
			LL c = plank[i].c;
			LL add = max(c + Max(l, l, 1), c + Max(r, r, 1));
			update(add, plank[i].l, plank[i].r, 1);
		}

		LL ans = Max(plank[n].l, plank[n].r, 1);
		if(ans>0)
			printf("%lld\n", ans);
		else
			printf("-1\n");
	}
    return 0;
}