动态规划-Help JimmyV2

完成的游戏：场景中包括多个长度和高度各不相同的平台。地面是最低的平台，高度为零，长度无限。
Jimmy老鼠在时刻0从高于所有平台的某处开始下落，它的下落速度始终为1米/秒。当Jimmy
落到某个平台上时，游戏者选择让它向左还是向右跑，它跑动的速度也是1米/秒。当Jimmy
跑到平台的边缘时，开始继续下落。Jimmy每次下落的高度不能超过MAX米，不然就会摔死，
游戏也会结束。设计一个程序，计算Jimmy到地面时可能的最早时间。

输入数据
第一行是测试数据的组数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恰好落在某个平台的
边缘，被视为落在平台上。所有的平台均不重叠或相连。测试数据保Jimmy
一定能安全到达地面。

输出要求：对输入的每组测试数据，输出一个整数，Jimmy到地面时可能的最早时间。
输入样例
1
3 8 17 20
0 10 8
0 10 13
4 14 3
输出样例
23


思路：递归实现
求到达地面的最短时间，将初始位置看作一个平台，地面也看作一个平台，
对各个平台的高度进行排序，用递归来做用最大的一直往下找到地位的最短时间
为了提高效率，利用leftMinList, rightMinList两个列表分别记录平台
左右方向下落的最小时间

python算法实现：

# 二维列表的列索引含义：0表示平台左边坐标、1表示平台右边坐标、2表示平台的高度
plat_list = []
# 递归中为了避免重复计算，提高运算效率，需存储每个i平台左右下落的最小时间
# 存储i平台左右下落的最小时间，-1表示没有计算过，
leftMinList, rightMinList = [], []
# 定义无穷大
inf = float('inf')
N, MaxHeight = 0, 0


# 计算从平台i到地面的最短时间，往左往右都需要计算才能找到最小值
# jimmy从出发下落到第1块板有可能走左边也可能走右边
# N表示平台的个数
def minDropTime(i, isGoLeft):
    global plat_list, N, MaxHeight, leftMinList, rightMinList
    x = 0
    y = plat_list[i][2]  # 当前点的高度
    # 如果是去左边，就走到左边边上，如果去右边，就走到右边边上
    if isGoLeft:
        x = plat_list[i][0]
    else:
        x = plat_list[i][1]
    # 查找如果从左边或者右边下落，是否能到达下一块板
    # k记录可以下落板的编号
    k = 0
    for j in range(i + 1, N + 1):
        # 如果x落在下一块板的中间，则说明可以从i下落到j板
        if plat_list[j][0] <= x <= plat_list[j][1]:
            k = j
            break
    # 说明往i下面没有板可以下落
    if k == 0:
        if y > MaxHeight:
            return inf
        else:
            return y
    else:  # 有可以下落的板
        if y - plat_list[k][2] > MaxHeight:
            return inf
        else:
            # =-1，说明该平台下落的最小时间没有计算过
            if leftMinList[k] == -1:
                leftMinList[k] = minDropTime(k, True)
            if rightMinList[k] == -1:
                rightMinList[k] = minDropTime(k, False)
            # 如果计算过k平台下落的最小时间，则可以直接计算，不需要重新递归提高效率
            # 返回平台i往左或者右方向下落的最小值=高度差+min(走k平台左端最小时间,走k平台右端最小时间)
            return (y - plat_list[k][2]) + min(x - plat_list[k][0] + leftMinList[k],
                                               plat_list[k][1] - x + rightMinList[k])


def main():
    global plat_list, N, MaxHeight, leftMinList, rightMinList
    # t表示测试数据的组数
    t = int(input())
    while t > 0:
        # N: 平台数目 X, Y: 开始下落位置坐标 MAX: 一次下落最大高度
        N, X, Y, MaxHeight = 0, 0, 0, 0
        N, X, Y, MaxHeight = map(int, input().split())
        # 记录从该平台左边下落的最小时间
        leftMinList = [-1 for i in range(N + 1)]
        # 记录从该平台右边下落的最小时间
        rightMinList = [-1 for i in range(N + 1)]
        # 平台的二维数组列表
        plat_list = [[0 for i in range(3)] for i in range(N + 1)]

        # 把jimmy的出发点也当做一个平台，即递归的出发点
        plat_list[0][0], plat_list[0][1], plat_list[0][2] = X, X, Y
        for i in range(1, N + 1):
            plat_list[i] = [int(n) for n in input().split()]  # 输入各平台参数
        # 对平台按高度排序,sorted这个函数要重新覆盖原来的列表内容才会排序
        plat_list = sorted(plat_list, key=(lambda x: x[2]), reverse=True)
        # [[8, 8, 17], [0, 10, 13], [0, 10, 8], [4, 14, 3]]
        min_value = minDropTime(0, True)
        print("Jimmy到底地面时可能的最早时间为：%d" % min_value)
        t = t - 1


if __name__ == '__main__':
    main()