“奔跑吧，牛客“---是男人就下100层

题目描述

相信大家都听说过“是男人就下100层”系列游戏，游戏中包括多个长度和高度各不相同的平台，地面是最低的平台，高度为零，长度无限。
一个男人在开始的时候从高于所有平台的某处开始下落，它的下落速度始终为1米/秒。当他落到某个平台上时，游戏者选择让他向左或向右跑，跑动的速度也是1米/秒。当他跑到平台的边缘时会继续下落。要求每次下落的高度不能超过MAX米，不然就会摔死，游戏也会结束。
请帮忙设计一个程序，计算最快到达地面所用的时间。

输入描述:
输入包含多组数据。

每组测试数据的第一行是四个整数N、X、Y、MAX，用空格分隔。N是平台的数目（不包括地面），X和Y是游戏开始时男人所在位置的坐标，MAX是一次下落的最大高度。

紧接着有N行，每行描述一个平台的信息，包括三个整数，X1[i]，X2[i]和H[i]。H[i]表示平台的高度，X1[i]和X2[i]表示平台左右端点的横坐标。

1 ≤ N ≤ 1000；-20000 ≤ X, X1[i], X2[i] ≤ 20000；1 ≤ H[i] < Y ≤ 20000（1≤i≤N）。所有坐标的单位都是米。

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

输出描述:
对应每一组输入，输出一个整数，为到达地面最早的时间。

输入例子:
3 8 17 20
0 10 8
0 10 13
4 14 3

输出例子:
23

思路：用left_time,right_time记录到达平台左右端点时间的最小值。从高到低遍历每一个平台，判断从这个平台的左右端点在下落MAX内，是否会降落于其他平台上。如果会， 就更新降落的平台的左右端点时间。这样遍历的好处是，当我们考虑平台A时，他的左右端点的时间值，必然是所有到达平台A的可能路径的最小时间。

#include <iostream>
#include <vector>
#include <algorithm>
#include <limits.h>
#include <map>

using namespace std;

struct Platform{
    int left;
    int right;
    int height;
    int left_time;
    int right_time;
};

bool cmp(Platform a, Platform b){
    if (a.height > b.height){
        return true;
    }
    else{
        return false;
    }
}

int main(){
    int N, x, y, MAX;
    Platform node;
    node.left_time = node.right_time = INT_MAX;//表示从初始点到达此平台的左右端点值的时间，初始设为INT_MAX，表示暂未有路径到达此平台，
    vector<Platform> vec;//存储平台信息
    while (cin >> N){
        vec.clear();
        cin >> x >> y >> MAX;
        for (int i = 0; i < N; i++){
            cin >> node.left >> node.right >> node.height;
            vec.push_back(node);
        }
        sort(vec.begin(), vec.end(), cmp);//对容器vector的平台做从高到低的排序

        int time = INT_MAX;//记录到达地面的最短时间
        //当y<MAX时，主角可能直接落于地面，那必然为最小值，也可能落在某个平台上，就先遍历所有平台，判断是否会落于某平台上
        if (y <= MAX){
            int j = 0;
            for (; j < N; j++){
                if (x >= vec[j].left&&x <= vec[j].right)
                    break;
            }
            //j==N,表示主角直接落于地面上，那就必为最小值，直接输出即可。
            if (j == N){
                cout << y << endl;
                continue;
            }
        }

        //经过上面的判断，主角不会直接落于地面，那么，就找出主角会落于哪个平台上，并更新到达此平台的左右端点的时间值
        int i = 0;
        //在下落高度小于MAX内寻找平台
        while (y - vec[i].height <= MAX){
            //此为第一次落在平台上，因此vec[i].left_time,vec[i].right_time必为INT_MAX，就无需判断，直接对其进行更新。
            if (x >= vec[i].left&&x <= vec[i].right){
                vec[i].left_time = x - vec[i].left + y - vec[i].height;
                vec[i].right_time = y - vec[i].height + vec[i].right - x;
                //终于搜索
                break;
            }
            else{
                //不会落到i平台，就看是否会落在下一个平台
                i++;
            }
        }

        //接下来，就是从第一个降落的平台依次遍历
        while (i < vec.size()){
            //是表示从i降落可能会到的平台
            int j = i + 1;
            //vec[i].left_time为INT_MAX,表示从出发点开始并没有下落路径可以到达平台i上，那么就不必考虑此平台了。（前面思路中的方案从讲了，我们的思路是从高到低遍历平台，计算从高处的平台落下后，会到达哪个平台，并记录下最短的时间。
            if (vec[i].left_time != INT_MAX){       

                while (j<N&&vec[i].height - vec[j].height <= MAX){
                    //判断是否落于j平台上
                    if (vec[i].left >= vec[j].left&&vec[i].left <= vec[j].right){
                        //在落于此平台上后，判断一下，此次路线所用的时间，是否比之前的时间短，即vec[i].left_time,vec[i].right_time只记录最短到达时间。
                        if (vec[i].left_time + vec[i].left - vec[j].left + vec[i].height - vec[j].height < vec[j].left_time){
                            vec[j].left_time = vec[i].left - vec[j].left + vec[i].height - vec[j].height + vec[i].left_time;
                        }
                        if (vec[j].right_time > vec[j].right - vec[i].left + vec[i].height - vec[j].height + vec[i].left_time){
                            vec[j].right_time = vec[j].right - vec[i].left + vec[i].height - vec[j].height + vec[i].left_time;
                        }
                        break;
                    }
                    else{
                        j++;
                    }
                }
            }
            //这是从平台i的右端点降落，找平台
            j = i + 1;
            if (vec[i].right_time != INT_MAX){
                while (j<N&&vec[i].height - vec[j].height <= MAX){
                    if (vec[i].right >= vec[j].left&&vec[i].right <= vec[j].right){
                        if (vec[j].left_time > vec[i].right - vec[j].left + vec[i].height - vec[j].height + vec[i].right_time){
                            vec[j].left_time = vec[i].right - vec[j].left + vec[i].height - vec[j].height + vec[i].right_time;
                        }
                        if (vec[j].right_time > vec[j].right - vec[i].right + vec[i].height - vec[j].height + vec[i].right_time){
                            vec[j].right_time = vec[j].right - vec[i].right + vec[i].height - vec[j].height + vec[i].right_time;
                        }
                        break;
                    }
                    else{
                        j++;
                    }
                }
            }
            //接下来是分别分析平台左右端点，判断从平台的左右端点是否会直接落于地面，如果会，则计算出时间与time对比，并记录小的值。
            if (vec[i].left_time!=INT_MAX&&vec[i].height <= MAX){
                int j = i + 1;
                for (; j < N; j++){
                    if (vec[i].left <= vec[j].right&&vec[i].left >= vec[j].left){
                        break;
                    }
                }
                if (j == N){
                    if (time > vec[i].left_time + vec[i].height){
                        time = vec[i].left_time + vec[i].height;
                    }
                }
            }
            if (vec[i].right_time != INT_MAX&&vec[i].height <= MAX){
                int j = i + 1;
                for (; j < N; j++){
                    if (vec[i].right <= vec[j].right&&vec[i].right >= vec[j].left){
                        break;
                    }
                }
                if (j == N){
                    if (time > vec[i].right_time + vec[i].height){
                        time = vec[i].right_time + vec[i].height;
                    }
                }
            }
            i++;

        }

        cout << time << endl;
    }
    return 0;
}

上述 代码，有些地方可以忧化，如从平台左端点如果会降落到另一平台，那必然就不会落于地面，就无需再去判断一次了。我小偷个懒，就不改了。
如果有更好的方法，望不吝赐教。