POJ 1661 暴力dp

题意略。

思路：

很有意思的一个题，我采用的是主动更新未知点的方式，也即刷表法来dp。

我们可以把整个路径划分成横向移动和纵向移动，题目一开始就给出了Jimmy的高度，这就是纵向移动的距离。

我们dp的目标是每个线段端点的横向移动最小值。

有一个小trick，就是有可能Jimmy开始就可以落在地上，没有必要或者说在下落过程中不会有间隔来阻拦。

代码附上：

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
using namespace std;
const int maxn = ;
const int INF = 0x3f3f3f3f;
const int F = 0x3f;

struct segment{
    int l,r,h;
    segment(int l = ,int r = ,int h = ){
        this->l = l,this->r = r,this->h = h;
    }
};

segment store[maxn];
int dp[maxn<<],N,x,h,MAX,t;
bool covered[maxn<<];

bool cmp(const segment& s0,const segment& s1){
    return s0.h > s1.h;
}
bool inSegment(int x,segment s){
    return s.l <= x && x <= s.r;
}

int main(){
    scanf("%d",&t);
    while(t--){
        scanf("%d%d%d%d",&N,&x,&h,&MAX);
        for(int i = ;i < N;++i) scanf("%d%d%d",&store[i].l,&store[i].r,&store[i].h);
        memset(dp,F,sizeof(dp));
        memset(covered,false,sizeof(covered));
        sort(store,store + N,cmp);
        int ans = h,lft,rht,lp,rp,nlft,nrht,nlp,nrp;
        for(int i = ;i < N;++i){
            lft = i<<,rht = lft + ;
            if(inSegment(x,store[i])){
                dp[lft] = x - store[i].l,dp[rht] = store[i].r - x;
                break;
            }
        }
        for(int i = ;i < N;++i){
            lft = i<<,rht = lft + ;
            lp = store[i].l,rp = store[i].r;
            int cnt0 = ,cnt1 = ;
            if(dp[lft] == INF) continue;
            for(int j = i + ;store[i].h - store[j].h <= MAX && j < N && cnt0 + cnt1 < ;++j){
                if(store[i].h == store[j].h) continue;
                nlft = j<<,nrht = nlft + ;
                nlp = store[j].l,nrp = store[j].r;
                if(!cnt0 && inSegment(lp,store[j])){
                    dp[nlft] = min(dp[nlft],dp[lft] + lp - nlp);
                    dp[nrht] = min(dp[nrht],dp[lft] + nrp - lp);
                    cnt0 = ;
                }
                if(!cnt1 && inSegment(rp,store[j])){
                    dp[nlft] = min(dp[nlft],dp[rht] + rp - nlp);
                    dp[nrht] = min(dp[nrht],dp[rht] + nrp - rp);
                    cnt1 = ;
                }
            }
        }

        for(int i = ;i < N;++i){
            if(store[i].h > MAX) continue;
            for(int j = i + ;j < N;++j){
                if(inSegment(store[i].l,store[j])) covered[i<<] = true;
                if(inSegment(store[i].r,store[j])) covered[i<< | ] = true;
            }
        }

        int minn = INF;
        for(int i = N - ;i >=  && store[i].h <= MAX;--i){
            lft = i<<,rht = lft + ;
            if(!covered[lft]) minn = min(minn,dp[lft]);
            if(!covered[rht]) minn = min(minn,dp[rht]);
        }
        if(minn == INF) minn = ;
        ans += minn;
        printf("%d\n",ans);
    }
    return ;
}

/*

1
3 4 4 5
3 5 3
1 7 2
2 6 1
*/