到达终点的最小跳数集合2(O(n)解)

给定一个整数数组，其中每个元素代表可以从该元素进行的最大步数。编写一个函数以返回到达数组末尾的最小跳转数(从第一个元素开始)。如果一个元素为0，那么我们将无法遍历该元素。如果无法到达终点，则返回-1。
例子：

Input:  arr[] = {1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9}
Output: 3 (1-> 3 -> 8 -> 9)
Explanation: Jump from 1st element to 
2nd element as there is only 1 step, 
now there are three options 5, 8 or 9. 
If 8 or 9 is chosen then the end node 9 
can be reached. So 3 jumps are made.

Input:  arr[] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}
Output: 10
Explanation: In every step a jump is 
needed so the count of jumps is 10.

在这篇文章中，将讨论其O(n)解决方案。

在集合-1中，讨论了O(n ² )解。
执行：
要使用的变量：

1. maxReach变量maxReach始终存储数组中的最大可达索引。
2. step变量step存储我们仍然可以执行的步骤数(并使用索引0的值进行初始化，即初始步骤数)
3. 跳转跳转存储达到该最大可到达位置所需的跳转量。

给定数组arr = 1、3、5、8、9、2、6、7、6、8、9

• maxReach = arr [0]; // arr [0] = 1，因此我们目前可以达到的最大索引为1。
  步骤= arr [0]; // arr [0] = 1，我们仍然可以执行的步骤数也为1。
  跳跃= 1; //我们总是需要至少跳一次。
• 现在，从索引1开始迭代，上述值将更新如下：
  1. 首先，我们测试是否已经到达数组的末尾，在这种情况下，我们只需要返回跳转变量即可。

if (i == arr.length - 1)
    return jump;

2.接下来，我们更新maxReach。这等于maxReach和i + arr [i]的最大值(我们可以从当前位置开始执行的步数)。

maxReach = Math.max(maxReach, i+arr[i]);

3.我们用了一个步骤来获取当前索引，因此必须减少步骤。

step--;

4.如果没有更多的剩余步数(即，steps = 0，则必须使用了一个跳转。因此请增加跳转。)由于我们知道有可能达到maxReach，因此我们再次将步数初始化为要达到的步数从位置i开始的maxReach，但是在重新初始化步骤之前，我们还检查了步骤是变为零还是变为负值，在这种情况下，无法进一步到达。

if (step == 0) {
    jump++;
    if(i>=maxReach)
       return -1;
    step = maxReach - i;
} 

C++

// C++ program to count Minimum number
// of jumps to reach end
#include 
using namespace std;
 
int max(int x, int y)
{
    return (x > y) ? x : y;
}
 
// Returns minimum number of jumps
// to reach arr[n-1] from arr[0]
int minJumps(int arr[], int n)
{
 
    // The number of jumps needed to
    // reach the starting index is 0
    if (n <= 1)
        return 0;
 
    // Return -1 if not possible to jump
    if (arr[0] == 0)
        return -1;
 
    // initialization
    // stores all time the maximal
    // reachable index in the array.
    int maxReach = arr[0];
 
    // stores the number of steps
    // we can still take
    int step = arr[0];
 
    // stores the number of jumps
    // necessary to reach that maximal
    // reachable position.
    int jump = 1;
 
    // Start traversing array
    int i = 1;
    for (i = 1; i < n; i++) {
        // Check if we have reached the end of the array
        if (i == n - 1)
            return jump;
 
        // updating maxReach
        maxReach = max(maxReach, i + arr[i]);
 
        // we use a step to get to the current index
        step--;
 
        // If no further steps left
        if (step == 0) {
            // we must have used a jump
            jump++;
 
            // Check if the current index/position or lesser index
            // is the maximum reach point from the previous indexes
            if (i >= maxReach)
                return -1;
 
            // re-initialize the steps to the amount
            // of steps to reach maxReach from position i.
            step = maxReach - i;
        }
    }
 
    return -1;
}
 
// Driver program to test above function
int main()
{
    int arr[] = { 1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9 };
    int size = sizeof(arr) / sizeof(int);
 
    // Calling the minJumps function
    cout << ("Minimum number of jumps to reach end is %d ",
             minJumps(arr, size));
    return 0;
}
// This code is contributed by
// Shashank_Sharma

C

// C program to count Minimum number
// of jumps to reach end
#include 
 
int max(int x, int y) { return (x > y) ? x : y; }
 
// Returns minimum number of jumps
// to reach arr[n-1] from arr[0]
int minJumps(int arr[], int n)
{
 
    // The number of jumps needed to
    // reach the starting index is 0
    if (n <= 1)
        return 0;
 
    // Return -1 if not possible to jump
    if (arr[0] == 0)
        return -1;
 
    // initialization
    // stores all time the maximal
    // reachable index in the array.
    int maxReach = arr[0];
 
    // stores the number of steps
    // we can still take
    int step = arr[0];
 
    // stores the number of jumps
    // necessary to reach that maximal
    // reachable position.
    int jump = 1;
 
    // Start traversing array
    int i = 1;
    for (i = 1; i < n; i++) {
        // Check if we have reached the end of the array
        if (i == n - 1)
            return jump;
 
        // updating maxReach
        maxReach = max(maxReach, i + arr[i]);
 
        // we use a step to get to the current index
        step--;
 
        // If no further steps left
        if (step == 0) {
            // we must have used a jump
            jump++;
 
            // Check if the current index/position or lesser index
            // is the maximum reach point from the previous indexes
            if (i >= maxReach)
                return -1;
 
            // re-initialize the steps to the amount
            // of steps to reach maxReach from position i.
            step = maxReach - i;
        }
    }
    return -1;
}
 
// Driver program to test above function
int main()
{
    int arr[] = { 1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9 };
    int size = sizeof(arr) / sizeof(int);
 
    // Calling the minJumps function
    printf(
        "Minimum number of jumps to reach end is %d ",
        minJumps(arr, size));
    return 0;
}
// This code is contributed by Abhishek Kumar Singh

Java

// Java program to count Minimum number
// of jumps to reach end
 
class Test {
    static int minJumps(int arr[])
    {
        if (arr.length <= 1)
            return 0;
 
        // Return -1 if not possible to jump
        if (arr[0] == 0)
            return -1;
 
        // initialization
        int maxReach = arr[0];
        int step = arr[0];
        int jump = 1;
 
        // Start traversing array
        for (int i = 1; i < arr.length; i++) {
            // Check if we have reached
// the end of the array
            if (i == arr.length - 1)
                return jump;
 
            // updating maxReach
            maxReach = Math.max(maxReach, i + arr[i]);
 
            // we use a step to get to the current index
            step--;
 
            // If no further steps left
            if (step == 0) {
                // we must have used a jump
                jump++;
 
                // Check if the current
// index/position or lesser index
                // is the maximum reach point
// from the previous indexes
                if (i >= maxReach)
                    return -1;
 
                // re-initialize the steps to the amount
                // of steps to reach maxReach from position i.
                step = maxReach - i;
            }
        }
 
        return -1;
    }
 
    // Driver method to test the above function
    public static void main(String[] args)
    {
        int arr[] = new int[] { 1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9 };
 
        // calling minJumps method
        System.out.println(minJumps(arr));
    }
}

Python

# python program to count Minimum number
# of jumps to reach end
  
# Returns minimum number of jumps to reach arr[n-1] from arr[0]
def minJumps(arr, n):
  # The number of jumps needed to reach the starting index is 0
  if (n <= 1):
    return 0
  
  # Return -1 if not possible to jump
  if (arr[0] == 0):
    return -1
  
  # initialization
  # stores all time the maximal reachable index in the array
  maxReach = arr[0] 
  # stores the amount of steps we can still take
  step = arr[0]
  # stores the amount of jumps necessary to reach that maximal reachable position
  jump = 1
  
  # Start traversing array
  
  for i in range(1, n):
    # Check if we have reached the end of the array
    if (i == n-1):
      return jump
  
    # updating maxReach
    maxReach = max(maxReach, i + arr[i])
  
    # we use a step to get to the current index
    step -= 1;
  
    # If no further steps left
    if (step == 0):
      # we must have used a jump
      jump += 1
       
      # Check if the current index / position or lesser index
      # is the maximum reach point from the previous indexes
      if(i >= maxReach):
        return -1
  
      # re-initialize the steps to the amount
      # of steps to reach maxReach from position i.
      step = maxReach - i;
  return -1
  
 
# Driver program to test above function
arr = [1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9]
size = len(arr)
  
# Calling the minJumps function
print("Minimum number of jumps to reach end is % d " % minJumps(arr, size))
 
# This code is contributed by Aditi Sharma

C#

// C# program to count Minimum
// number of jumps to reach end
using System;
 
class GFG {
    static int minJumps(int[] arr)
    {
        if (arr.Length <= 1)
            return 0;
 
        // Return -1 if not
        // possible to jump
        if (arr[0] == 0)
            return -1;
 
        // initialization
        int maxReach = arr[0];
        int step = arr[0];
        int jump = 1;
 
        // Start traversing array
        for (int i = 1; i < arr.Length; i++) {
            // Check if we have reached
            // the end of the array
            if (i == arr.Length - 1)
                return jump;
 
            // updating maxReach
            maxReach = Math.Max(maxReach, i + arr[i]);
 
            // we use a step to get
            // to the current index
            step--;
 
            // If no further steps left
            if (step == 0) {
                // we must have used a jump
                jump++;
 
                // Check if the current index/position
                // or lesser index is the maximum reach
                // point from the previous indexes
                if (i >= maxReach)
                    return -1;
 
                // re-initialize the steps to
                // the amount of steps to reach
                // maxReach from position i.
                step = maxReach - i;
            }
        }
 
        return -1;
    }
 
    // Driver Code
    public static void Main()
    {
        int[] arr = new int[] { 1, 3, 5, 8, 9, 2,
                                6, 7, 6, 8, 9 };
 
        // calling minJumps method
        Console.Write(minJumps(arr));
    }
}
 
// This code is contributed
// by nitin mittal

PHP

= $maxReach)
                return -1;
  
            // re-initialize the steps to the amount
            // of steps to reach maxReach from position i.
            $step = $maxReach - $i;
        }
    }
  
    return -1;
}
  
// Driver program to test above function
 
$arr=array(1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9);
$size = sizeof($arr)/sizeof($arr[0]);
  
// Calling the minJumps function
echo "Minimum number of jumps to reach end is "
     . minJumps($arr, $size);
return 0;
// This code is contribute by Ita_c.
?>

输出

3

复杂度分析：

• 时间复杂度： O(n)。
  只需要遍历数组一次。
• 辅助空间： O(1)。
  不需要空间。

另一种方法：

1. 为了解决到达数组末尾的最小跳转，
2. 对于每个跳转索引，我们考虑需要评估索引中相应的步长值，并使用索引值将数组划分为多个子部分，并找出覆盖索引的最大步长。
3. 以下代码和说明将为您提供清晰的思路：
4. 在每个子数组中找到最大距离覆盖索引作为数组的第一部分和第二个数组

Input Array : {1, 3, 5, 9, 6, 2, 6, 7, 6, 8, 9} -> index position starts with 0

Steps :

Initial step is considering the first index and incrementing the jump

Jump = 1

1, { 3, 5, 9, 6, 2, 6, 7, 6, 8, 9} -> 1 is considered as a first jump

next step

From the initial step, there is only one step to move so

Jump = 2

1,3, { 5, 9, 6,2, 6, 7, 6, 8, 9} -> 1 is considered as a first jump

next step

Now we have the flexibility to choose any of {5,9,6} because the last step says we can move up to 3 steps

Consider it as a subarray, evaluate the max distance covers with each index position

As {5,9,6} index positions are {2,3,4}

so the total farther steps we can cover:

{7,12,10} -> we can assume it as {7,12} & {10} are 2 sub-arrays where left part of arrays says max distance covered with 2 steps and right side array says max steps cover with remaining values

next step:

Considering the maximum distance covered in first array we iterate the remaining next elements

1,3,9 {6,2, 6, 7, 6, 8, 9}

From above step we already visited the 4th index we continue with next 5th index as explained above

{6,2, 6, 7, 6, 8, 9} index positions {4,5,6,7,8,9,10}

{10,7,12,14,14,17,19}

Max step covers here is 19 which corresponding index is 10

C++

// C++ program to illustrate Minimum
// number of jumps to reach end
#include 
using namespace std;
 
// Returns minimum number of jumps
// to reach arr[n-1] from arr[0]
int minJumps(int arr[], int n)
{
    // The number of jumps needed to
    // reach the starting index is 0
    if (n <= 1)
        return 0;
 
    // Return -1 if not possible to jump
    if (arr[0] == 0)
        return -1;
 
    // Stores the number of jumps
    // necessary to reach that maximal
    // reachable position.
    int jump = 1;
 
    // Stores the subarray last index
    int subArrEndIndex = arr[0];
 
    int i = 1;
 
    // Maximum steps covers in
    // first half of sub array
    int subArrFistHalfMaxSteps = 0;
 
    // Maximum steps covers
    // in second half of sub array
    int subArrSecondHalfMaxSteps = 0;
   
    // Start traversing array
    for (i = 1; i < n;) {
 
        subArrEndIndex = i + subArrEndIndex;
       
        // Check if we have reached
        // the end of the array
        if (subArrEndIndex >= n)
            return jump;
 
        int firstHalfMaxStepIndex = 0;
       
        // Iterate the sub array
        // and find out the maxsteps
        // cover index
        for (; i < subArrEndIndex; i++) {
            int stepsCanCover = arr[i] + i;
            if (subArrFistHalfMaxSteps < stepsCanCover) {
                subArrFistHalfMaxSteps = stepsCanCover;
                subArrSecondHalfMaxSteps = 0;
                firstHalfMaxStepIndex = i;
            }
            else if (subArrSecondHalfMaxSteps
                     < stepsCanCover) {
                subArrSecondHalfMaxSteps = stepsCanCover;
            }
        }
        if (i > subArrFistHalfMaxSteps)
            return -1;
        jump++;
       
        // Next subarray end index
        // and so far calculated sub
        // array max step cover value
        subArrEndIndex = arr[firstHalfMaxStepIndex];
        subArrFistHalfMaxSteps = subArrSecondHalfMaxSteps;
    }
 
    return -1;
}
 
// Driver program to test above function
int main()
{
    int arr[] = { 1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9 };
    int size = sizeof(arr) / sizeof(int);
 
    // Calling the minJumps function
    cout << ("Minimum number of jumps to reach end is %d ",
             minJumps(arr, size));
    return 0;
}
// This code is contributed by praveen.kanike

Java

// Java program to illustrate Minimum
// number of jumps to reach end
import java.io.*;
class GFG {
 
  // Returns minimum number of jumps
  // to reach arr[n-1] from arr[0]
  static int minJumps(int arr[], int n)
  {
 
    // The number of jumps needed to
    // reach the starting index is 0
    if (n <= 1)
      return 0;
 
    // Return -1 if not possible to jump
    if (arr[0] == 0)
      return -1;
 
    // Stores the number of jumps
    // necessary to reach that maximal
    // reachable position.
    int jump = 1;
 
    // Stores the subarray last index
    int subArrEndIndex = arr[0];
 
    int i = 1;
 
    // Maximum steps covers in
    // first half of sub array
    int subArrFistHalfMaxSteps = 0;
 
    // Maximum steps covers
    // in second half of sub array
    int subArrSecondHalfMaxSteps = 0;
 
    // Start traversing array
    for (i = 1; i < n;) {
 
      subArrEndIndex = i + subArrEndIndex;
 
      // Check if we have reached
      // the end of the array
      if (subArrEndIndex >= n)
        return jump;
 
      int firstHalfMaxStepIndex = 0;
 
      // Iterate the sub array
      // and find out the maxsteps
      // cover index
      for (; i < subArrEndIndex; i++) {
        int stepsCanCover = arr[i] + i;
        if (subArrFistHalfMaxSteps < stepsCanCover) {
          subArrFistHalfMaxSteps = stepsCanCover;
          subArrSecondHalfMaxSteps = 0;
          firstHalfMaxStepIndex = i;
        }
        else if (subArrSecondHalfMaxSteps
                 < stepsCanCover) {
          subArrSecondHalfMaxSteps = stepsCanCover;
        }
      }
      if (i > subArrFistHalfMaxSteps)
        return -1;
      jump++;
 
      // Next subarray end index
      // and so far calculated sub
      // array max step cover value
      subArrEndIndex = arr[firstHalfMaxStepIndex];
      subArrFistHalfMaxSteps = subArrSecondHalfMaxSteps;
    }
 
    return -1;
  }
 
  // Driver program to test above function
  public static void main (String[] args)
  {
 
    int arr[] = { 1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9 };
    int size=arr.length;
 
    // Calling the minJumps function
    System.out.println("Minimum number of jumps to reach end is "+minJumps(arr, size));
  }
}
 
// This code is contributed by rag2127

C＃

// C# program to illustrate Minimum
// number of jumps to reach end
using System;
public class GFG
{
 
  // Returns minimum number of jumps
  // to reach arr[n-1] from arr[0]
  static int minJumps(int[] arr, int n)
  {
 
    // The number of jumps needed to
    // reach the starting index is 0
    if (n <= 1)
      return 0;
 
    // Return -1 if not possible to jump
    if (arr[0] == 0)
      return -1;
 
    // Stores the number of jumps
    // necessary to reach that maximal
    // reachable position.
    int jump = 1;
 
    // Stores the subarray last index
    int subArrEndIndex = arr[0];
 
    int i = 1;
 
    // Maximum steps covers in
    // first half of sub array
    int subArrFistHalfMaxSteps = 0;
 
    // Maximum steps covers
    // in second half of sub array
    int subArrSecondHalfMaxSteps = 0;
 
    // Start traversing array
    for (i = 1; i < n;) {
 
      subArrEndIndex = i + subArrEndIndex;
 
      // Check if we have reached
      // the end of the array
      if (subArrEndIndex >= n)
        return jump;
 
      int firstHalfMaxStepIndex = 0;
 
      // Iterate the sub array
      // and find out the maxsteps
      // cover index
      for (; i < subArrEndIndex; i++)
      {
        int stepsCanCover = arr[i] + i;
        if (subArrFistHalfMaxSteps < stepsCanCover)
        {
          subArrFistHalfMaxSteps = stepsCanCover;
          subArrSecondHalfMaxSteps = 0;
          firstHalfMaxStepIndex = i;
        }
        else if (subArrSecondHalfMaxSteps
                 < stepsCanCover)
        {
          subArrSecondHalfMaxSteps = stepsCanCover;
        }
      }
      if (i > subArrFistHalfMaxSteps)
        return -1;
      jump++;
 
      // Next subarray end index
      // and so far calculated sub
      // array max step cover value
      subArrEndIndex = arr[firstHalfMaxStepIndex];
      subArrFistHalfMaxSteps = subArrSecondHalfMaxSteps;
    }
 
    return -1;
  }
 
  // Driver code
  static public void Main ()
  {
    int[] arr = { 1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9 };
    int size = arr.Length;
 
    // Calling the minJumps function
    Console.WriteLine("Minimum number of jumps to reach end is " +
                      minJumps(arr, size));
  }
}
 
// This code is contributed by avanitrachhadiya2155

输出

3

时间复杂度： O(n)。

辅助空间： O(1)。