最小跳跃问题

题目一：

给定一个非负整数数组，假定你的初始位置为数组第一个下标。 数组中的每个元素代表你在那个位置能够跳跃的最大长度。请确认你是否能够跳跃到数组的最后一个下标。
例如：A = [2,3,1,1,4]A=[2,3,1,1,4] 能够跳跃到最后一个下标，输出true；
A = [3,2,1,0,4]A=[3,2,1,0,4] 不能跳跃到最后一个下标，输出false。

输入格式
第一行输入一个正整数 n (1≤n≤500)，接下来的一行 n 个整数，输入数组 A_i。

输出格式
如果能跳到最后一个下标，输出true，否则输出false。

样例输入
5
2 0 2 0 1

样例输出
true

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int max=0,count;
    int a[500];
    cin>>count;
    for(int i=0;i<count;i++)
        cin>>a[i];
    for(int i=0;i<count;i++)
    {
        if(i>max)
        {
            cout<<"false";
            return 0;
        }
        if((a[i]+i)>max)
            max=i+a[i];
    }
    cout<<"true";
    return 0;
}

　　

题目二：

给定非负整数数组，初始时在数组起始位置放置一机器人，数组的每个元素表示在当前位置机器人一步最大能够跳跃的数目。它的目的是用最少的步数到达数组末端。

例如：

给定数组A=[2,3,1,1,2]，最少跳步数目为2，对应的跳法是2->3->2，数组位置变化为0->1->4。

[2,3,1,1,2,4,1,1,6,1,7]，所需步数为5。

思路：

代码：

#include<iostream>
using namespace std;

int jump(int A[],int n){
    if(n==1)
        return 0;

    int step=0;
    int i=0,j=0;
    int k,j2;

    while(j<n){
        step++;
        j2=j;
        for(k=i;k<=j;k++){
            j2=max(j2,k+A[k]);
            if(j2>=n-1)
                return step;
        }
        i=j+1;
        j=j2;
        if(j<i)
            return -1;
    }

    return step;
}


int main(){
    int A[]={2,3,1,1,2,4,1,1,6,1,7};
    int n=sizeof(A)/sizeof(A[0]);
    cout << jump(A,n) <<endl;
    return 0;
}

　　

问题三        

给定一个非负整数数组，初始情况位于数组的第一个索引处。数组中的每个元素表示该位置的最大跳跃长度。要求达到最后一个索引花费的最小跳跃次数。

<举例>

输入: [2,3,1,1,4]
输出: 2
解释: 跳到最后一个索引的最小跳数为2。从索引0跳到1跳1步，然后跳3步到最后一个索引。

二、解题方法一：动态规划 -- 超时
g(i)表示能否从前面的j位置元素跳到当前的i位置，则状态转移方程为：

g(i) = g(j) && (i-j)∈nums[j]   0 <= j < i < numsSize
边界条件为：g(0) = true
f(i)表示到达i位置的最小跳步数，则状态转移方程为(在g(i)的基础上)

f(i) = min(f(j)+1,f(i))
边界条件为：f(0)=0

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
 
#define min(a,b) (a<b?a:b)
int jump(int* nums, int numsSize) {
    int f[numsSize];
    bool g[numsSize];
    int i,j;
    g[0] = true;
    for(i=0; i<numsSize; i++) f[i] = 65535;
    f[0] = 0;
    for(i=1;i<numsSize;i++)
    {
        for(j=0;j<i;j++)
        {
            if( g[j] && (i-j) <= nums[j] )
            {
                g[i] = true;
                f[i] = min(f[i],f[j]+1);
            }
        }
    }
    return f[numsSize-1];
}

　　

三、解题方法二：贪心 -- accept
        分别用left和right两个游标记录当前能跳的区间范围，尝试从每一个区间范围中跳较远new_right，更新较远的right游标right=new_right，每一个区间处理完毕后更新新的左游标left=left+old_right

int jump(int* nums, int numsSize)
{
    int left = 0;  //最小步数
    int right = 0;
    int step = 0;  //[left,right]为当前跳步区间
    int i;
 
    //特殊情况处理
    if( numsSize==1 ) return 0; //当只有一个元素时，当前就在这个位置，不用跳步，所以返回0
 
    //更新游标区间-----最右游标
    while(left<=right)
    {
        step++;
        int old_right = right;
 
        for(i=left; i<=old_right; i++)
        {
            int new_right = i+nums[i];
 
            //最右的情况可以到达目标位置，则为最小跳步数
            if( new_right >= numsSize-1 ) return step;
 
            //更新最右游标
            if( new_right > right ) right = new_right;
        }
        //一个区间处理完后，则更新left，继续处理[left,new_Right]区间
        left=old_right+1;
    }
    return 0;  //到达不了目标位置，则返回0
}

　

题解：
在 跳跃问题1 中求能否到达最后位置，用一个 reach 变量 记录能够到达的最远的下标，每走一步比较更新该值，到达最终位置前，如果当前下标大于reach，说明失败。如果能到达最后，说明成功。

而这道题，需要求的是最少的步数。因此需要添加 count 变量记录最少步数。什么时候 count++ 是问题的关键？答案是当前的位置 i 超过了上一跳所能到达的最远位置。所以需要引入变量 last 记录上一跳可达最远坐标。此题代码在跳跃问题1 代码基础上修改。

class Solution {
    public int jump(int[] nums) {
        if (nums == null || nums.length == 0) {
            return -1;
        }
        int reach = 0;//当前所能到达的最远坐标
        int last = 0;//上一跳可达最远坐标
        int count = 0;//跳跃次数
        for (int i = 0; i < nums.length; i++) {
            if (i > reach) {
                return -1;
            }
            if (i > last) {
                count++;
                last = reach;
            }
            if (i + nums[i] > reach) {
                reach = i + nums[i];
            }
        }
        return count;
    }
}

　　

动态规划解法：
复杂度是 O(n2)O(n2)，会超时，但是依然需要掌握。

定义状态：dp[i] 表示到达 i 位置的最小跳数
起始装填：dp[0]=0 到达下标0的最小跳数是0
终止状态：dp[nums.length-1] 即到达最后一个位置的最小跳数
决策：选择 i 之前的能跳到 i 的所有位置j 中， dp[j] 值最小的位置 j 作为上一步要跳到 i 的位置
费用表示：dp[i]=dp[j]+1 ,从 j 跳到 i ,步数加1
无后效性：收益1 是个常数，不随状态改变

class Solution {
    public int jump(int[] nums) {
        int[] dp = new int[nums.length];//dp[i] 为到达 i 位置的最小跳数
        dp[0] = 0;//到达下标0的最小跳数是0
        for (int i = 1; i < nums.length; i++) {
            dp[i] = Integer.MAX_VALUE;
            for (int j = 0; j < i; j++) {
                if (i - j <= nums[j]) {
                    dp[i] = Math.min(dp[i], dp[j] + 1);
                }
            }
        }
        return dp[nums.length - 1];
    }
}