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.代码：

  1 #include <iostream>

  2 #include <cstdio>

  3 #include <cstdlib>

  4 

  5 using namespace std;

  6 

  7 struct FLAT

  8 {

  9     int x[2];

 10     int h;

 11 };

 12 

 13 int cmp(const void* a,const void* b)

 14 {

 15     FLAT flat1 = *((FLAT *)a);

 16     FLAT flat2 = *((FLAT *)b);

 17 

 18     return flat1.h - flat2.h;

 19 }

 20 

 21 int main()

 22 {

 23     //freopen("C://input.txt","r",stdin);

 24 

 25     int t;

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

 27 

 28     int i,j,k;

 29 

 30     int n,x,y,max;

 31     while(t--)

 32     {

 33         //1 <= N <= 1000，-20000 <= X, X1[i], X2[i] <= 20000，0 < H[i] < Y <= 20000（i = 1..N）

 34         cin >> n >> x >> y >> max;

 35 

 36         FLAT *arr_flat = new FLAT[n];

 37 

 38         for(i = 0; i < n; ++i) cin >> arr_flat[i].x[0] >> arr_flat[i].x[1] >> arr_flat[i].h;

 39         qsort(arr_flat,n,sizeof(FLAT),cmp);

 40 

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

 42 

 43         int m;

 44         for(m = n - 1; m >= 0; --m)

 45         {

 46             if(y - arr_flat[m].h <= max && x >= arr_flat[m].x[0] && arr_flat[m].x[1] >= x) break; 

 47         }

 48         if(m < 0)

 49         {

 50             cout << y << endl;

 51             continue;

 52         }

 53 

 54         //dp

 55         int **dp = new int*[m + 1];

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

 57 

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

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

 60 

 61         for(i = 1; i <= m; ++i)

 62         {

 63             for(j = 0; j < 2; ++j)

 64             {

 65                 int flag = 0;

 66                 for(k = i - 1; k >= 0; --k)

 67                 {

 68                     if(arr_flat[i].h - arr_flat[k].h > max) break;

 69                     else

 70                     {

 71                         if(arr_flat[k].x[0] <= arr_flat[i].x[j] && arr_flat[k].x[1] >= arr_flat[i].x[j])

 72                         {

 73                             flag = 1;

 74                             break;

 75                         }

 76                     }

 77                 }

 78                 if(flag == 0)

 79                 {

 80                     if(arr_flat[i].h < max) dp[i][j] = arr_flat[i].h;

 81                     else dp[i][j] = -1;

 82                 }

 83                 else

 84                 {

 85                     if(dp[k][0] == -1 && dp[k][1] == -1) dp[i][j] = -1;

 86                     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]);

 87                     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]);

 88                     else

 89                     {

 90                         int temp1 = dp[k][0] + (arr_flat[i].h - arr_flat[k].h) + (arr_flat[i].x[j] - arr_flat[k].x[0]);

 91                         int temp2 = dp[k][1] + (arr_flat[i].h - arr_flat[k].h) + (arr_flat[k].x[1] - arr_flat[i].x[j]);

 92                         dp[i][j] = temp1 < temp2 ? temp1 : temp2;

 93                     }

 94                 }

 95             }

 96         }

 97 

 98         if(dp[m][0] == -1) cout << dp[m][1] + (arr_flat[m].x[1] - x) + (y - arr_flat[m].h) << endl;

 99         else if(dp[m][1] == -1) cout << dp[m][0] + (x - arr_flat[m].x[0]) + (y - arr_flat[m].h) << endl;

100         else

101         {

102             int temp1 = dp[m][1] + (arr_flat[m].x[1] - x) + (y - arr_flat[m].h);

103             int temp2 = dp[m][0] + (x - arr_flat[m].x[0]) + (y - arr_flat[m].h);

104             cout << (temp1 < temp2 ? temp1 : temp2) << endl;

105         }

106 

107 

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

109         delete [] dp;

110 

111         delete [] arr_flat;

112     }

113 

114 

115     return 0;

116 }