HDU 3016

dp+线段树

dp[i]表示到达高度为i的板子上的最大体力值，next[i][0]、next[i][1]分别表示从i的左边、右边下落，将到达的板子高度。（通过排序将高度离散化）

那么递推式就是这样的：dp[next[i][k]]=max(dp[next[i][k]],dp[i]+plank[next[i][k]].v)  (k=0,1)  从上到下推一遍，输出dp[0]。

现在问题是解决next数组的问题。ps：从板子(xl,xr) 左边下落的位置是xl而不是xl-1，同理右边是xr。

从上往下找板子的next不好找，上面板子覆盖下面板子的缘故。所以我们先找下面板子的next，每找完一个板子，就让它覆盖下面的板子。

这就等价于一个染色的问题。用线段树解决即可。

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

#define Maxn 100010
struct node
{
    int h,l,r,v;
}plank[Maxn];

struct T
{
    int l,r,c,lchild,rchild;
}tree[4*Maxn];

int next[Maxn][2],cnt,dp[Maxn],n;

bool cmp(node a,node b)
{
    return a.h<b.h;
}

void Init();
void build(int l,int r);
void revise(int k,int l,int r,int c);
int inquiry(int k,int x);
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        memset(dp,-1,sizeof(dp));
        for(int i=1;i<=n;i++)
            scanf("%d%d%d%d",&plank[i].h,&plank[i].l,&plank[i].r,&plank[i].v);

        sort(plank+1,plank+1+n,cmp);
        Init();
        dp[n]=100+plank[n].v;
        for(int i=n;i>0;i--)
        {
            if(dp[i]<=0)
                continue;
            dp[next[i][0]]=max(dp[next[i][0]],dp[i]+plank[next[i][0]].v);
            dp[next[i][1]]=max(dp[next[i][1]],dp[i]+plank[next[i][1]].v);
        }
        printf("%d\n",dp[0]);
    }
    return 0;
}

void build(int l,int r)
{
    int i=cnt;
    tree[i].l=l,tree[i].r=r,tree[i].c=0;
    if(l==r)
        return;
    tree[i].lchild=++cnt;
    build(l,(r+l)/2);
    tree[i].rchild=++cnt;
    build((r+l)/2+1,r);
}

void revise(int k,int l,int r,int c)
{
    if(l>r)
        return;
    int cntl,cntr,cntm;
    cntl=tree[k].l,cntr=tree[k].r;
    cntm=(cntl+cntr)/2;
    if(l==cntl && r==cntr)
    {
        tree[k].c=c;
        revise(tree[k].lchild,l,cntl-1,c);
        revise(tree[k].rchild,cntr+1,r,c);
        return;
    }
    if(tree[k].c!=-1)
    {
        tree[tree[k].lchild].c=tree[k].c;
        tree[tree[k].rchild].c=tree[k].c;
        tree[k].c=-1;
    }
    if(l<=cntm)
    {
        if(r<=cntm)
            revise(tree[k].lchild,l,r,c);
        else
        {
            revise(tree[k].lchild,l,cntm,c);
            revise(tree[k].rchild,cntm+1,r,c);
        }
    }
    else
    {
        revise(tree[k].rchild,l,r,c);
    }
}
void Init()
{
    cnt=0;
    build(0,Maxn);
    for(int i=1;i<=n;i++)
    {
        next[i][0]=inquiry(0,plank[i].l);
        next[i][1]=inquiry(0,plank[i].r);
        revise(0,plank[i].l,plank[i].r,i);
    }
}

int inquiry(int k,int x)
{
    if(tree[k].c!=-1)
        return tree[k].c;
    if(x<=(tree[k].l+tree[k].r)/2)
        return inquiry(tree[k].lchild,x);
    else
        return inquiry(tree[k].rchild,x);
}