Python 到达终点的最小跳跃

问题陈述: 给定数组：[1,0,1,0,1,1,1,1,1,0,1,1,1,0] 输出：到达终点所需的最小步数

条件：

• 0上的步骤是退出
• 一次最多可以走1步或2步

我已经完成了不使用DP的情况下的使用，是否存在针对此问题的DP解决方案

我的代码：

def minjump(arr):
    n = len(arr)
    if n <= 0 or arr[0] == 0:
        return 0

    index = jump = 0
    while index < n:
        if index == n-1:
            return jump

        if arr[index] == 0 and arr[index+1] == 0:
            return 0

        if arr[index] == 1:
            if index < n-2 and arr[index+2] == 1:
                jump +=1
                index +=2
            else:
                jump += 1
                index += 1
    return jump

def最小跳跃（arr）：
n=长度（arr）
如果n您可以使用dp解决更一般的问题，则在伪代码中，以下k表示您可以跳转的最大步数：

int n = arr.Length
int dp[n]
for (i = 0 ; i < n; i++) {
    int lowerBound = max(i - k, 0)
    for (j = i - 1; j >= lowerBound; j--) {
        if (arr[j] == 1 && (j == 0 || dp[j] > 0)) {
            dp[i] = min(dp[i], 1 + dp[j])
        }
    }
}
return dp[n - 1]

int n=阵列长度
int-dp[n]
对于（i=0；i=lowerBound；j--）{
如果（arr[j]==1&（j==0 | | dp[j]>0））{
dp[i]=min（dp[i]，1+dp[j]）
}
}
}
返回dp[n-1]
您可以使用dp解决更一般的问题，在伪代码中，下面的k表示您可以跳转的最大步数：

int n = arr.Length
int dp[n]
for (i = 0 ; i < n; i++) {
    int lowerBound = max(i - k, 0)
    for (j = i - 1; j >= lowerBound; j--) {
        if (arr[j] == 1 && (j == 0 || dp[j] > 0)) {
            dp[i] = min(dp[i], 1 + dp[j])
        }
    }
}
return dp[n - 1]

int n=阵列长度
int-dp[n]
对于（i=0；i=lowerBound；j--）{
如果（arr[j]==1&（j==0 | | dp[j]>0））{
dp[i]=min（dp[i]，1+dp[j]）
}
}
}
返回dp[n-1]
一个没有记忆的天真解决方案只是在列表中重复出现，采取一个或两个步骤，并保留所需的最小步骤：

def最小步长（数组、当前计数、当前位置）：
如果当前位置>=len（数组）：#如果已到达末端，则为终端条件
返回当前计数
返回(
闵(
最小步数（数组，当前步数+1，当前步位置+1），
最小步数（数组，当前步数+1，当前步位置+2），
)#采取一步或两步后的最小计数
如果数组[当前位置]#如果当前步长有效（非零）
else float（“inf”）#else，返回float.infinity（很好，因为我们没有在这个原型上强加类型）
)
def最小跳跃（arr）：
结果=最小步数（arr，0，0）
如果结果==float（“inf”）else结果，则返回0
一个没有记忆的天真解决方案只是在列表中重复出现，采取一个或两个步骤，并保留所需的最小步骤：

def最小步长（数组、当前计数、当前位置）：
如果当前位置>=len（数组）：#如果已到达末端，则为终端条件
返回当前计数
返回(
闵(
最小步数（数组，当前步数+1，当前步位置+1），
最小步数（数组，当前步数+1，当前步位置+2），
)#采取一步或两步后的最小计数
如果数组[当前位置]#如果当前步长有效（非零）
else float（“inf”）#else，返回float.infinity（很好，因为我们没有在这个原型上强加类型）
)
def最小跳跃（arr）：
结果=最小步数（arr，0，0）
如果结果==float（“inf”）else结果，则返回0
跳跃范围在[1,2]时，这不是DP问题。如果你愿意，你可以通过DP来解决它，就像你在[1,2]范围内跳跃时解决1的一般[r，k]问题一样，这不是DP问题。如果你愿意，你可以通过DP来解决它，就像你解决1的一般[r，k]问题一样。你可以构造一个DP解，从右向左移动。你可以构造一个DP解，从右向左移动