计算跳跃到达终点的方式数

给定一个数字数组，其中每个元素代表可以从该元素向前跳转的最大次数。对于每个数组元素，计算可以从该元素跳转到数组末尾的方式数。如果元素为 0，则无法通过该元素进行移动。不能到达末尾的元素应该有一个计数“-1”。

例子：

Input : {3, 2, 0, 1}
Output : 2 1 -1 0
For 3 number of steps or jumps that 
can be taken are 1, 2 or 3. The different ways are:
3 -> 2 -> 1
3 -> 1

For 2 number of steps or jumps that 
can be taken are 1, or 2. The different ways are:
2 -> 1

For 0 number of steps or jumps that 
can be taken are 0. 
One cannot move forward from this point.

For 1 number of steps or jumps that 
can be taken are 1. But the element is at
the end so no jump is required.

Input : {1, 3, 5, 8, 9, 1, 0, 7, 6, 8, 9}
Output : 52 52 28 16 8 -1 -1 4 2 1 0

此问题是到达终点的最小跳跃次数(方法 3)的变体。这里我们需要计算从每个单元格到达终点的所有方式。
该解决方案是对到达终点的最小跳跃次数问题的解决方案(方法3)的修改版本。
这个问题旨在计算从每个元素跳转到终点的不同方式。对于每个元素，计数的计算方法是将所有可以到达末尾且当前元素可以到达的所有前向元素的计数相加 + 1(如果元素可以直接到达末尾)。

算法：

countWays(arr, n)
    Initialize array count_jump[n] = {0}

    count_jump[n-1] = 0
    for i = n-2 to 0
        if arr[i] >= (n-i-1)
         count_jump[i]++
        for j=i+1; j < n-1 && j <= arr[i]+i; i++
          if count_jump[j] != -1
             count_jump[i] += count_jump[j]
        if count_jump[i] == 0
         count_jump[i] = -1

    for i = 0 to n-1
        print count_jump[i]

C++

// C++ implementation to count number
// of ways to jump to reach end
#include 
using namespace std;
 
// function to count ways to jump to
// reach end for each array element
void countWaysToJump(int arr[], int n)
{
    // count_jump[i] store number of ways
    // arr[i] can reach to the end
    int count_jump[n];
    memset(count_jump, 0, sizeof(count_jump));
 
    // Last element does not require to jump.
    // Count ways to jump for remaining
    // elements
    for (int i=n-2; i>=0; i--)
    {
        // if the element can directly
        // jump to the end
        if (arr[i] >= n - i - 1)
            count_jump[i]++;
 
        // add the count of all the elements
        // that can reach to end and arr[i] can
        // reach to them
        for (int j=i+1; j < n-1 && j <= arr[i] + i; j++)
 
            // if element can reach to end then add
            // its count to count_jump[i]
            if (count_jump[j] != -1)
                 count_jump[i] += count_jump[j];
 
        // if arr[i] cannot reach to the end
        if (count_jump[i] == 0)
            count_jump[i] = -1;
    }
 
    // print count_jump for each
    // array element
    for (int i=0; i

---

Java

// Java implementation to count number
// of ways to jump to reach end
import java.util.Arrays;
 
class GFG {
     
    // function to count ways to jump to
    // reach end for each array element
    static void countWaysToJump(int arr[], int n)
    {
         
        // count_jump[i] store number of ways
        // arr[i] can reach to the end
        int count_jump[] = new int[n];
        Arrays.fill(count_jump, 0);
     
        // Last element does not require to jump.
        // Count ways to jump for remaining
        // elements
        for (int i = n-2; i >= 0; i--)
        {
             
            // if the element can directly
            // jump to the end
            if (arr[i] >= n - i - 1)
                count_jump[i]++;
     
            // add the count of all the elements
            // that can reach to end and arr[i] can
            // reach to them
            for (int j = i+1; j < n-1 && j <= arr[i] + i; j++)
     
                // if element can reach to end then add
                // its count to count_jump[i]
                if (count_jump[j] != -1)
                    count_jump[i] += count_jump[j];
     
            // if arr[i] cannot reach to the end
            if (count_jump[i] == 0)
                count_jump[i] = -1;
        }
     
        // print count_jump for each
        // array element
        for (int i = 0; i < n; i++)
            System.out.print(count_jump[i] + " ");
    }
     
    //driver code
    public static void main (String[] args)
    {
         
        int arr[] = {1, 3, 5, 8, 9, 1, 0, 7, 6, 8, 9};
        int n = arr.length;
         
        countWaysToJump(arr, n);
    }
}
 
// This code is contributed by Anant Agarwal.

Python3

# Python3 implementation to count
# number of ways to jump to reach end
 
# Function to count ways to jump to
# reach end for each array element
def countWaysToJump(arr, n):
 
    # count_jump[i] store number of ways
    # arr[i] can reach to the end
    count_jump = [0 for i in range(n)]
 
    # Last element does not require
    # to jump. Count ways to jump for
    # remaining elements
    for i in range(n - 2, -1, -1):
     
        # if the element can directly
        # jump to the end
        if (arr[i] >= n - i - 1):
            count_jump[i] += 1
 
        # Add the count of all the elements
        # that can reach to end and arr[i]
        # can reach to them
        j = i + 1
        while(j < n-1 and j <= arr[i] + i):
 
            # if element can reach to end then
            # add its count to count_jump[i]
            if (count_jump[j] != -1):
                count_jump[i] += count_jump[j]
            j += 1
             
        # if arr[i] cannot reach to the end
        if (count_jump[i] == 0):
            count_jump[i] = -1
     
 
    # print count_jump for each
    # array element
    for i in range(n):
        print(count_jump[i], end = " ")
 
# Driver code
arr = [1, 3, 5, 8, 9, 1, 0, 7, 6, 8, 9]
n = len(arr)
countWaysToJump(arr, n)
 
# This code is contributed by Anant Agarwal.

C#

// C# implementation to count number
// of ways to jump to reach end
using System;
 
class GFG {
     
    // function to count ways to jump to
    // reach end for each array element
    static void countWaysToJump(int[] arr, int n)
    {
         
        // count_jump[i] store number of ways
        // arr[i] can reach to the end
        int[] count_jump = new int[n];
         
        for(int i = 0; i < n; i++)
            count_jump[i] = 0;
         
     
        // Last element does not require to jump.
        // Count ways to jump for remaining
        // elements
        for (int i = n-2; i >= 0; i--)
        {
             
            // if the element can directly
            // jump to the end
            if (arr[i] >= n - i - 1)
                count_jump[i]++;
     
            // add the count of all the elements
            // that can reach to end and arr[i] can
            // reach to them
            for (int j = i+1; j < n-1 && j <= arr[i] + i; j++)
     
                // if element can reach to end then add
                // its count to count_jump[i]
                if (count_jump[j] != -1)
                    count_jump[i] += count_jump[j];
     
            // if arr[i] cannot reach to the end
            if (count_jump[i] == 0)
                count_jump[i] = -1;
        }
     
        // print count_jump for each
        // array element
        for (int i = 0; i < n; i++)
            Console.Write(count_jump[i] + " ");
    }
     
    // Driver code
    public static void Main ()
    {
        int[] arr = {1, 3, 5, 8, 9,
                 1, 0, 7, 6, 8, 9};
        int n = arr.Length;
        countWaysToJump(arr, n);
    }
}
 
// This code is contributed by ChitraNayal

PHP

= 0; $i--)
    {
        // if the element can directly
        // jump to the end
        if ($arr[$i] >= $n - $i - 1)
            $count_jump[$i]++;
 
        // add the count of all the elements
        // that can reach to end and arr[i]
        // can reach to them
        for ($j = $i + 1; $j < $n - 1 &&
             $j <= $arr[$i] + $i; $j++)
 
            // if element can reach to end then
            // add its count to count_jump[i]
            if ($count_jump[$j] != -1)
                $count_jump[$i] += $count_jump[$j];
 
        // if arr[i] cannot reach to the end
        if ($count_jump[$i] == 0)
            $count_jump[$i] = -1;
    }
 
    // print count_jump for each
    // array element
    for ($i = 0; $i < $n; $i++)
        echo $count_jump[$i] . " ";
}
 
// Driver Code
$arr = array(1, 3, 5, 8, 9, 1,
                0, 7, 6, 8, 9);
$n = count($arr);
countWaysToJump($arr, $n);
 
// This code is contributed by Rajput-Ji
?>

Javascript

 
// Javascript implementation to count number
// of ways to jump to reach end
     
    // function to count ways to jump to
    // reach end for each array element
    function countWaysToJump(arr,n)
    {
        // count_jump[i] store number of ways
        // arr[i] can reach to the end
        let count_jump = new Array(n);
        for(let i=0;i<n;i++)
        {
            count_jump[i]=0;
        }
       
        // Last element does not require to jump.
        // Count ways to jump for remaining
        // elements
        for (let i = n-2; i >= 0; i--)
        {
               
            // if the element can directly
            // jump to the end
            if (arr[i] >= n - i - 1)
                count_jump[i]++;
       
            // add the count of all the elements
            // that can reach to end and arr[i] can
            // reach to them
            for (let j = i+1; j < n-1 && j <= arr[i] + i; j++)
       
                // if element can reach to end then add
                // its count to count_jump[i]
                if (count_jump[j] != -1)
                    count_jump[i] += count_jump[j];
       
            // if arr[i] cannot reach to the end
            if (count_jump[i] == 0)
                count_jump[i] = -1;
        }
       
        // print count_jump for each
        // array element
        for (let i = 0; i < n; i++)
            document.write(count_jump[i] + " ");
    }
     
    //driver code
    let arr=[1, 3, 5, 8, 9, 1, 0, 7, 6, 8, 9];
    let n = arr.length;
    countWaysToJump(arr, n);
     
     
     
    // This code is contributed by avanitrachhadiya2155

输出：

52 52 28 16 8 -1 -1 4 2 1 0

时间复杂度：在最坏情况下为 O(n ² )。

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。