OpenJudge/Poj 1661 帮助 Jimmy

1.链接地址：

bailian.openjudge.cn/practice/1661

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

2.题目：

总Time Limit:

1000ms

Memory Limit:

65536kB

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

3.思路：

动态规划题目

注意Jimmy老鼠直接落到0高度的情况

4.代码：

#include <iostream>
#include <cstdio>
#include <cstdlib>

using namespace std;

struct FLAT
{
    int x[2];
    int h;
};

int cmp(const void* a,const void* b)
{
    FLAT flat1 = *((FLAT *)a);
    FLAT flat2 = *((FLAT *)b);

    return flat1.h - flat2.h;
}

int main()
{
    //freopen("C://input.txt","r",stdin);

    int t;
    cin >> t; // 0 <= t <= 20

    int i,j,k;

    int n,x,y,max;
    while(t--)
    {
        //1 <= N <= 1000，-20000 <= X, X1[i], X2[i] <= 20000，0 < H[i] < Y <= 20000（i = 1..N）
        cin >> n >> x >> y >> max;

        FLAT *arr_flat = new FLAT[n];

        for(i = 0; i < n; ++i) cin >> arr_flat[i].x[0] >> arr_flat[i].x[1] >> arr_flat[i].h;
        qsort(arr_flat,n,sizeof(FLAT),cmp);

        //for(i = 0; i < n; ++i) cout << arr_flat[i].x[0] << " " << arr_flat[i].x[1] << " " << arr_flat[i].h << endl;

        int m;
        for(m = n - 1; m >= 0; --m)
        {
            if(y - arr_flat[m].h <= max && x >= arr_flat[m].x[0] && arr_flat[m].x[1] >= x) break; 
        }
        if(m < 0)
        {
            cout << y << endl;
            continue;
        }

        //dp
        int **dp = new int*[m + 1];
        for(i = 0; i <= m; ++i) dp[i] = new int[2];

        dp[0][0] = arr_flat[0].h;
        dp[0][1] = arr_flat[0].h;

        for(i = 1; i <= m; ++i)
        {
            for(j = 0; j < 2; ++j)
            {
                int flag = 0;
                for(k = i - 1; k >= 0; --k)
                {
                    if(arr_flat[i].h - arr_flat[k].h > max) break;
                    else
                    {
                        if(arr_flat[k].x[0] <= arr_flat[i].x[j] && arr_flat[k].x[1] >= arr_flat[i].x[j])
                        {
                            flag = 1;
                            break;
                        }
                    }
                }
                if(flag == 0)
                {
                    if(arr_flat[i].h < max) dp[i][j] = arr_flat[i].h;
                    else dp[i][j] = -1;
                }
                else
                {
                    if(dp[k][0] == -1 && dp[k][1] == -1) dp[i][j] = -1;
                    else if(dp[k][0] == -1) dp[i][j] = dp[k][1] + (arr_flat[i].h - arr_flat[k].h) + (arr_flat[k].x[1] - arr_flat[i].x[j]);
                    else if(dp[k][1] == -1) dp[i][j] = dp[k][0] + (arr_flat[i].h - arr_flat[k].h) + (arr_flat[i].x[j] - arr_flat[k].x[0]);
                    else
                    {
                        int temp1 = dp[k][0] + (arr_flat[i].h - arr_flat[k].h) + (arr_flat[i].x[j] - arr_flat[k].x[0]);
                        int temp2 = dp[k][1] + (arr_flat[i].h - arr_flat[k].h) + (arr_flat[k].x[1] - arr_flat[i].x[j]);
                        dp[i][j] = temp1 < temp2 ? temp1 : temp2;
                    }
                }
            }
        }

        if(dp[m][0] == -1) cout << dp[m][1] + (arr_flat[m].x[1] - x) + (y - arr_flat[m].h) << endl;
        else if(dp[m][1] == -1) cout << dp[m][0] + (x - arr_flat[m].x[0]) + (y - arr_flat[m].h) << endl;
        else
        {
            int temp1 = dp[m][1] + (arr_flat[m].x[1] - x) + (y - arr_flat[m].h);
            int temp2 = dp[m][0] + (x - arr_flat[m].x[0]) + (y - arr_flat[m].h);
            cout << (temp1 < temp2 ? temp1 : temp2) << endl;
        }


        for(i = 0; i <= m; ++i) delete [] dp[i];
        delete [] dp;

        delete [] arr_flat;
    }


    return 0;
}