hdu 2155 小黑的镇魂曲(dp) 2008信息工程学院集训队——选拔赛

感觉蛮坑的一道题。

题意很像一个叫“是男人下100层”的游戏。不过多了个时间限制，要求在限定时间内从某一点下落到地面。还多了个最大下落高度，一次最多下落这么高，要不然会摔死。

一开始想dp的，然后想了半天想不到状态，因为如果以下落点位状态的话，一个板子上会有许多状态，然后就没法继续下去了。

然后试着证明贪心，结果证明不出来。贪心也用不了了。

其实放弃了，在比赛结束后又去看了看，然后讨论，然后吧啦吧啦吧啦……还是做不出来。结果还是搜了题解，唉，有些挫败感。

输入：

首行输入整数t，表示共t组数据。

接下来每组数据首行输入n, x, h, maxn, m。分别表示板子数量，初始位置的横坐标，初始位置的高度，最大一次可以下落的高度，限定时间。

接下来n行，每行3个整数，l, r, h。表示第i个板子的左边的坐标，右边的左边，高度。

输出：

如果在m秒内（含m秒）能到达地面，输出“NO”，否则输出“YES”。

题解用的还是dp，只是他稍微拐了个弯，设的状态是每块板子的左端坐标和右端坐标，这样就解决了从不同高板子下落到同一低板子上时会产生不同状态的问题了，不得不感慨，dp真神奇。

核心——判断从第i块板子上的左，右端下落到第j块板子的左，右端（如果可以的话）是否优于原本第j块板子左右端的时间。

#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;

const int N = 1010;

struct Tp
{
    int l, r, h;
}tp[N];

int dp[N][2];
int x, maxn, h;
int n, m, t;

bool cmp(Tp x, Tp y)
{
    return x.h > y.h;
}

void init()
{
    scanf("%d%d%d%d%d", &n, &x, &h, &maxn, &m);
    tp[0].l = x; tp[0].r = x; tp[0].h = h;          //出发点也设为一个板子，左右端都是x，高度为h
    for(int i = 1; i <= n; i++)
    {
        scanf("%d%d%d", &tp[i].l, &tp[i].r, &tp[i].h);
    }
    tp[n+1].l = -1; tp[n+1].r = N; tp[n+1].h = 0;   //地面
    sort(tp, tp+n+1, cmp);          //排序，为了后面可以大规模的break,节省时间
    dp[0][0] = dp[0][1] = 0;        //初始状态
    for(int i = 1; i <= n+1; i++)
    {
        dp[i][0] = dp[i][1] = 1000010;
    }
}

void Dp()
{
    for(int i = 0; i <= n; i++)
    {
        bool p1 = 0, p2 = 0;
        for(int j = i+1; j <= n+1; j++)         //从i上下落的j上
        {
            if(tp[i].h-tp[j].h > maxn) break;        //如果会摔死，则进入下一块i板子。
            
            if(tp[i].l >= tp[j].l && tp[i].l <= tp[j].r && !p1) //如果能从i的左端下落到j上
            {
                p1 = 1;             //i的左端只能下落的某一块固定板子上，无法下落到两个板子上
                if(j != n+1)        //如果不是落到地面，则需要计算纵向位移时间和横向位移时间
                {
                    dp[j][0] = min(dp[j][0], dp[i][0]+tp[i].h-tp[j].h+tp[i].l-tp[j].l);
                    dp[j][1] = min(dp[j][1], dp[i][0]+tp[i].h-tp[j].h+tp[j].r-tp[i].l);
                }
                else                //落到地面，则不需要计算横向位移时间
                {
                    dp[j][0] = min(dp[j][0], dp[i][0]+tp[i].h-tp[j].h);
                    dp[j][1] = min(dp[j][1], dp[i][0]+tp[i].h-tp[j].h);
                }
            }
            if(tp[i].r >= tp[j].l && tp[i].r <= tp[j].r && !p2) //如果能从i的右端下落到j上
            {
                p2 = 1;         //i的右端同样只能下落的某一块固定板子上，无法下落到两个板子上
                if(j != n+1)
                {
                    dp[j][0] = min(dp[j][0], dp[i][1]+tp[i].h-tp[j].h+tp[i].r-tp[j].l);
                    dp[j][1] = min(dp[j][1], dp[i][1]+tp[i].h-tp[j].h+tp[j].r-tp[i].r);
                }
                else
                {
                    dp[j][0] = min(dp[j][0], dp[i][1]+tp[i].h-tp[j].h);
                    dp[j][1] = min(dp[j][1], dp[i][1]+tp[i].h-tp[j].h);
                }
            }
        }
    }
}

void output()
{
    if(dp[n+1][0] <= m || dp[n+1][1] <= m) printf("NO
");
    else printf("YES
");    
}

int main()
{
    //freopen("test.txt", "r", stdin);
    scanf("%d", &t);
    while(t--)
    {
        init();
        Dp();
        output();
    }
    return 0;
}