POJ 1661 (DP)

题目链接：

http://poj.org/problem?id=1661

Help Jimmy

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 10233		Accepted: 3347

Description

"Help Jimmy" 是在下图所示的场景上完成的游戏。

场景中包括多个长度和高度各不相同的平台。地面是最低的平台，高度为零，长度无限。

Jimmy老鼠在时刻0从高于所有平台的某处开始下落，它的下落速度始终为1米/秒。当Jimmy落到某个平台上时，游戏者选择让它向左还是向右跑，它跑动的速度也是1米/秒。当Jimmy跑到平台的边缘时，开始继续下落。Jimmy每次下落的高度不能超过MAX米，不然就会摔死，游戏也会结束。

设计一个程序，计算Jimmy到底地面时可能的最早时间。

Input

第一行是测试数据的组数t（0 <= t <= 20）。每组测试数据的第一行是四个整数N，X，Y，MAX，用空格分隔。N是平台的数目（不包括地面），X和Y是Jimmy开始下落的位置的横竖坐标，MAX是一次下落的最大高度。接下来的N行每行描述一个平台，包括三个整数，X1[i]，X2[i]和H[i]。H[i]表示平台的高度，X1[i]和X2[i]表示平台左右端点的横坐标。1 <= N <= 1000，-20000 <= X, X1[i], X2[i] <= 20000，0 < H[i] < Y <= 20000（i = 1..N）。所有坐标的单位都是米。

Jimmy的大小和平台的厚度均忽略不计。如果Jimmy恰好落在某个平台的边缘，被视为落在平台上。所有的平台均不重叠或相连。测试数据保证问题一定有解。

Output

对输入的每组测试数据，输出一个整数，Jimmy到底地面时可能的最早时间。

Sample Input

1
3 8 17 20
0 10 8
0 10 13
4 14 3

Sample Output

23

Source

POJ Monthly--2004.05.15 CEOI 2000

题意：Jimmy 初始位置是水平 x 和y高度 ，给你n个木板，每个木板都给定左右的两个顶点位置 l ,  r  。当Jimmy 位置x满足 ， l ≤ x ≤ r ,即Jimmy可以落到这个地板。Jimmy可以从木板的左边下落，也可以从右边下落。但Jimmy不能一次下降超过Max米。求Jimmy安全下落地板的最少需要时间(保证数据 Jimmy可以安全到达地板)

解题思路： Jimmy有2种下落到地板的方式，一种是从开始位置，直接落到地板（如果没有木板档到他的话），一种是通过不停的下降到木板，保证下降距离小于Max.

因为数据保证肯定有解，所以只要考虑这两种情况就好。

我们假设DP[i][0] 为从初始位置下降到 i 木板左边的水平距离，DP[I][1]为初始位置下降到i木板右边的水平距离。因为总的垂直距离是固定的也就是一开始，Jimmy的高度，所以不用做保存。我们先按每块木板的高度进行降序排列。

若 从 能 从j 转移到 i ，即没有其余其他木板格挡到的话，就证明dp[i][0 or 1]可以由 dp[j][0 or 1]转移。（本人是用O（n）的办法判断的，比较蠢，有更好的解法，以后会做更新）

具体代码如下：

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<set>
#include<cmath>
#include<vector>
#include<map>
using namespace std;
typedef long long ll;
const int maxn = 1000 + 10;
const int INF  = 0x7fffffff;
struct tmp
{
    int l;
    int r;
    int h;
};
tmp node[maxn];
int dp[maxn][2];
int pre[maxn];
int vis[maxn][2];
bool cmp(const tmp &a,const tmp &b)
{
    return a.h>b.h;
}
bool check(int x,int y,int _max)
{
    if(node[y].h-node[x].h>0&&node[y].h-node[x].h<=_max)
        return 1;
    return 0;
}
bool judge(int x,int y,int cc)
{
    for(int i = y + 1 ; i < x ; i ++)
        if(node[i].l<=cc&&node[i].r>=cc)
        return 0;
    return 1;
}
int main()
{
    int t;
//    cout << INF <<endl;
    cin >> t;
    while(t--)
    {
        int n,x,y,_max;
        cin >> n >> x >> y >> _max;
        for(int i = 1 ; i <= n ; i ++)
        {
            scanf("%d%d%d",&node[i].l,&node[i].r,&node[i].h);
        }
        node[0].l = node[0].r = x;
        node[0].h = y;
        sort(node,node+n+1,cmp);
        memset(vis,0,sizeof(vis));
        dp[0][1] = dp[0][0] = 0;

        for(int i = 1 ; i <= n ; i ++)
        {
            dp[i][1] = dp[i][0] = INF;
            for(int j = 0 ; j < i ; j ++)
            {

                if(check(i,j,_max))
                {
                    if(node[j].r>=node[i].l&&node[j].r<=node[i].r&&judge(i,j,node[j].r)&&dp[j][1]!=INF)
                    {
                        dp[i][0] = min(dp[i][0],dp[j][1]+node[j].r-node[i].l);
                        dp[i][1] = min(dp[i][1],dp[j][1]+node[i].r-node[j].r);
                    }
                    if(node[j].l>=node[i].l&&node[j].l<=node[i].r&&judge(i,j,node[j].l)&&dp[j][0]!=INF)
                    {
                        dp[i][0] = min(dp[i][0],dp[j][0]+node[j].l-node[i].l);
                        dp[i][1] = min(dp[i][1],dp[j][0]+node[i].r-node[j].l);
                    }
                }
                 if(node[j].r>=node[i].l&&node[j].r<=node[i].r)
                    vis[j][1] =1;

                if(node[j].l>= node[i].l&&node[j].l<=node[i].r)
                    vis[j][0] =1;
            }
//
//            cout << dp[i][0] <<' '<<dp[i][1]<<endl;
        }
        int minf = INF;
        for(int i = 0 ; i <= n ; i ++)
        {
            if(!vis[i][0]&&node[i].h<=_max)
                minf = min(dp[i][0],minf);
            if(!vis[i][1]&&node[i].h<=_max)
                minf = min(dp[i][1],minf);
        }
//        cout << dp[n-1][0] <<' '<<dp[n-1][1]<<endl;
        cout << minf+y<<endl;
    }

    return 0;
}