动态规划 - 最小化数组的总和答案

【问题标题】：Dynamic Programming - minimize the sum of the array动态规划 - 最小化数组的总和
【发布时间】：2019-12-02 18:58:24
【问题描述】：

我的问题是：给定一个负整数和正整数数组。你被赋予价值 j 跳跃和 r 休息。每次跳跃后，您需要休息 r 步。此外，即使您有跳跃能力，您也可以再向前移动 1 步。问题是最小化数组的总和。

Ex.1 r = 2, j = 2, [5, 3, -4, -2, 1, 2, 3] => -4 + -2 + 3 = -3（跳跃 5、3、休息 -4、-2、跳跃 1,2、休息 3）

Ex.2 r = 2, j = 3, [90, 91, 92, -2, 3, 55, 3] => -2 + 3 + 55 + 3 = 59（跳跃 90,91,92 休息 -2,3,55,3）

我的想法：我决定使用 DP 来解决这个问题。这是我的伪代码。

def minimalSum (MIN, array, jump, rest, steps_left_to_jump, i):
    if MIN[i] is not empty:
        return MIN[i]
    if i == len(array) - 1:
        MIN[i] = array[i]
    else:
        if steps_left_to_jump == 0:
            if i == 0:
                MIN[i] = minimalSum(MIN, array, jump, rest, rest - 1, jump)
            else:
                if i + jump + 1 < len(array):
                    MIN[i] = array[i] + minimalSum(MIN, array, jump, rest, rest - 1, i + jump + 1)
            o1 = array[i] + minimalSum(MIN, array, jump, rest, 0, i + 1)
            if MIN[i] is not None:
                if o1 < MIN[i]:
                    MIN[i] = o1
            else:
                MIN[i] = o1
        else:
            MIN[i] = array[i] + minimalSum(MIN, array, jump, rest, steps_left_to_jump - 1, i + 1)
    return MIN[i]

MIN 是用于存储最佳和的数组。

它不适用于所有输入的问题，你能帮我找出哪里出错了。考虑这个例子 r = 2, j = 2 , [2 ,-2 ,-3,1 ,3 ,4]。答案应该是 1（访问 2，-2，跳转 -3，休息 4）2-2-3+4 = 1，但我的程序输出 5

【问题讨论】：

“它不适用于所有输入的问题” - 哪些输入？给我们一个例子，有预期的结果和实际的结果。 stackoverflow.com/help/minimal-reproducible-example
@kaya3 我看不到它不起作用的输入，但我知道它至少有 10 个数字的输入
你在哪里定义discomfort？这是什么？
这是您的代码，您可以选择为其提供哪些输入。如果这是针对网站根据隐藏的测试用例判断您的代码的网络挑战，那么您自己发明一个测试用例，您的代码会给出错误的答案。
问题陈述不清楚。你能链接到这个问题吗？或者更好的是，发布确切的问题陈述。

标签： python arrays algorithm dynamic-programming

【解决方案1】：

您的问题似乎在这一行：

if i == 0:
    MIN[i] = minimalSum(MIN, array, jump, rest, rest - 1, jump)

这可以防止您在 i 为 0 时选择访问，因为您总是在第一步中跳。我不知道你的完整代码，但这部分应该是：

if i == 0:
    MIN[i] = min(minimalSum(MIN, array, jump, rest, rest - 1, jump) , # case where you jump at 0
                 array[0] + minimalSum(MIN, array, jump, rest, 0, 1)  # case where you visit index 0
                )

此外，如果jump>len(MIN)-1，您的代码会给您一个越界错误。如果这种情况是真实的，你知道你应该总是访问。鉴于所有这些，我将编写递归公式，然后您可以记住它：

def opt_sum(array, r, j):
    if j > len(array)-1:
        return sum(array)  # cannot jump, return sum of full array
    else:
        visit_val = array[0] + opt_sum(array[1:], r, j)  # best sum if you choose to visit index 0
        jump_val = (
                sum(array[j:j+r])     # total mandatory resting visits
                + opt_sum(array[j+r:], r, j)  # the optimal sum of the subarray
                )                             # starting after the rest
        return min(visit_val, jump_val)  # return best of both policies

【讨论】：