最小跳躍問題


題目一:

給定一個非負整數數組,假定你的初始位置為數組第一個下標。 數組中的每個元素代表你在那個位置能夠跳躍的最大長度。請確認你是否能夠跳躍到數組的最后一個下標。
例如: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];
    }
}

  

 


免責聲明!

本站轉載的文章為個人學習借鑒使用,本站對版權不負任何法律責任。如果侵犯了您的隱私權益,請聯系本站郵箱yoyou2525@163.com刪除。



 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM