POJ1661 Help Jimmy

Help Jimmy

Time Limit: 1000MS
Memory Limit: 10000K

Total Submissions: 9863
Accepted: 3201

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

[Submit]   [Go Back]   [Status]   [Discuss]

解题思路：

Jimmy跳到一块板上时有向左向右两种选择。通过左端为起点和右端为起点到达地面的最短时间可以判断出选择那条路，然后开始递归。首先要将平台从高到低排序。

 #include<stdio.h>
 #include<string.h>
 #include<iostream>
 #include<stdlib.h>
 #include<algorithm>
 #define MAX_N 1000
 #define INFINITE 1000000
 int t, n, x, y, Max;
 struct Platform {
     int Lx, Rx, h;
 };
 Platform aPlatform[MAX_N + ];
 int aLeftMinTime[MAX_N + ];
 int aRightMinTime[MAX_N + ];

 int MyCompare(const void * e1, const void * e2) {
     Platform* p1, * p2;
     p1 = (Platform*) e1;
     p2 = (Platform*) e2;
     return p2 -> h - p1 -> h;
 }

 int MinTime(int L, bool bLeft) {
     int y = aPlatform[L].h;
     int x, i;
     if(bLeft)
         x = aPlatform[L].Lx;
     else
         x = aPlatform[L].Rx;
     for(i = L + ; i <= n; i++) {
         if(aPlatform[i].Lx <= x && aPlatform[i].Rx >= x)
             break;
     }
     if(i <= n) {
         if(y - aPlatform[i].h > Max)
             return INFINITE;
     } else {
         if(y > Max)
             return INFINITE;
         else
             return y;
     }
     int nLeftTime = y - aPlatform[i].h + x - aPlatform[i].Lx;
     int nRightTime = y - aPlatform[i].h + aPlatform[i].Rx - x;
     if(aLeftMinTime[i] == -)
         aLeftMinTime[i] = MinTime(i, true);
     if(aRightMinTime[i] == -)
         aRightMinTime[i] = MinTime(i, false);
     nLeftTime += aLeftMinTime[i];
     nRightTime += aRightMinTime[i];
     if(nLeftTime < nRightTime)
         return nLeftTime;
     return nRightTime;
 }

 int main() {
     scanf("%d", &t);
     for(int i = ; i < t; i++) {
         memset(aLeftMinTime, -, sizeof(aLeftMinTime));
         memset(aRightMinTime, -, sizeof(aRightMinTime));
         scanf("%d%d%d%d", &n, &x, &y, &Max);
         aPlatform[].Lx = x;
         aPlatform[].Rx = x;
         aPlatform[].h = y;
         for(int j = ; j <= n; j++) {
             scanf("%d%d%d", &aPlatform[j].Lx, &aPlatform[j].Rx, &aPlatform[j].h);
         }
         qsort(aPlatform, n + , sizeof(Platform), MyCompare);
         printf("%d\n", MinTime(, true));
     }
     return ;
 }

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

 23

 */

 #include<iostream>
 #include<stdio.h>
 #include<string.h>
 #include<algorithm>
 #include<stdlib.h>
 #define MAX 1010
 #define INI 1000000

 struct Platform {
     int x1, x2, h;
 } p[MAX];

 int LeftMinTime[MAX];
 int RightMinTime[MAX];
 int n, x, y, Max;

 int cmp(const void *e1, const void *e2) {
     Platform *p1, *p2;
     p1 = (Platform*) e1;
     p2 = (Platform*) e2;
     return p2 -> h - p1 -> h;
 }

 int main() {
     int t;
     scanf("%d", &t);
     while(t--) {
         memset(LeftMinTime, -, sizeof(LeftMinTime));
         memset(RightMinTime, -, sizeof(RightMinTime));
         scanf("%d%d%d%d", &n, &x, &y, &Max);
         p[].x1 = x;
         p[].x2 = x;
         p[].h = y;
         for(int i = ; i <= n; i++) {
             scanf("%d%d%d", &p[i].x1, &p[i].x2, &p[i].h);
         }
         qsort(p, n + , sizeof(Platform), cmp);
         LeftMinTime[n] = p[n].h;
         RightMinTime[n] = p[n].h;
         for(int i = n - ; i >= ; i--) {
             for(int j = i + ; j <= n; j++) {
                 if(p[i].x1 >= p[j].x1 && p[i].x1 <= p[j].x2 && LeftMinTime[i] == -) {
                     int nLeftMinTime = LeftMinTime[j] + p[i].h - p[j].h + p[i].x1 - p[j].x1;
                     int nRightMinTime = RightMinTime[j] + p[i].h - p[j].h + p[j].x2 - p[i].x1;
                     if(nLeftMinTime < nRightMinTime) {
                         LeftMinTime[i] = nLeftMinTime;
                     } else LeftMinTime[i] = nRightMinTime;
                 }
                 if(p[i].x2 >= p[j].x1 && p[i].x2 <= p[j].x2 && RightMinTime[i] == -) {
                     int nLeftMinTime = LeftMinTime[j] + p[i].h - p[j].h + p[i].x2 - p[j].x1;
                     int nRightMinTime = RightMinTime[j] + p[i].h - p[j].h + p[j].x2 - p[i].x2;
                     if(nLeftMinTime < nRightMinTime)
                         RightMinTime[i] = nLeftMinTime;
                     else RightMinTime[i] = nRightMinTime;
                 }
                 if(LeftMinTime[i] == -) {
                     if(p[i].h > Max)
                         LeftMinTime[i] = INI;
                     else LeftMinTime[i] = p[i].h;
                 }
                 if(RightMinTime[i] == -) {
                     if(p[i].h > Max)
                         RightMinTime[i] = INI;
                     else RightMinTime[i] = p[i].h;
                 }
             }
         }
         printf("%d\n", LeftMinTime[]);
     }
     return ;
 }

第一种是递归的方法（摘自教材）。第二种为非递归方法，然而并没有AC，暂时没有改对。