最多进行K次跳跃即可到达N楼的方法数量

给定N个楼梯。还给出了一个跳跃最多可以覆盖的步数(K)。任务是找到一个(仅考虑组合)可以从地下以K个跃点或更短的距离爬升到建筑物顶部的可能方法的数量。

例子：

Input: N = 5, K = 3
Output: 5
To reach stair no-5 we can choose following combination of leaps:
1 1 1 1 1
1 1 1 2
1 2 2
1 1 3
2 3
Therefore the answer is 5.

Input: N = 29, K = 5
Output: 603

设combo [i]为到达第i层的方式的数量。因此，通过跳跃ij从combo [j]到达combo [i]的方式将是combo [i] + = combo [j]。因此，对所有可能的跳跃进行迭代，并为每个可能的跳跃将可能的组合添加到组合数组中。最终答案将存储在combo [N]中。

下面是上述方法的实现。

C++

// C++ program to reach N-th stair 
// by taking a maximum of K leap 
#include  
  
using namespace std; 
  
int solve(int N, int K) 
{ 
  
    // elements of combo[] stores the no of 
    // possible ways to reach it by all 
    // combinations of k leaps or less 
  
    int combo[N + 1] = { 0 }; 
  
    // assuming leap 0 exist and assigning 
    // its value to 1 for calculation 
    combo[0] = 1; 
  
    // loop to iterate over all 
    // possible leaps upto k; 
    for (int i = 1; i <= K; i++) { 
  
        // in this loop we count all possible 
        // leaps to reach the jth stair with 
        // the help of ith leap or less 
        for (int j = 0; j <= N; j++) { 
  
            // if the leap is not more than the i-j 
            if (j >= i) { 
  
                // calculate the value and 
                // store in combo[j] 
                // to reuse it for next leap 
                // calculation for the jth stair 
                combo[j] += combo[j - i]; 
            } 
        } 
    } 
  
    // returns the no of possible number 
    // of leaps to reach the top of 
    // building of n stairs 
    return combo[N]; 
} 
  
// Driver Code 
int main() 
{ 
    // N i the no of total stairs 
    // K is the value of the greatest leap 
    int N = 29; 
    int K = 5; 
  
    cout << solve(N, K); 
  
    solve(N, K); 
    return 0; 
}

Java

// Java program to reach N-th 
// stair by taking a maximum 
// of K leap
class GFG
{
static int solve(int N, int K)
{
  
    // elements of combo[] stores 
    // the no. of possible ways 
    // to reach it by all combinations
    // of k leaps or less
    int[] combo;
    combo = new int[50];
  
    // assuming leap 0 exist 
    // and assigning its value
    // to 1 for calculation
    combo[0] = 1;
  
    // loop to iterate over all
    // possible leaps upto k;
    for (int i = 1; i <= K; i++) 
    {
  
        // in this loop we count all
        // possible leaps to reach
        // the jth stair with the 
        // help of ith leap or less
        for (int j = 0; j <= N; j++) 
        {
  
            // if the leap is not
            // more than the i-j
            if (j >= i)
            {
  
                // calculate the value and 
                // store in combo[j] to 
                // reuse it for next leap
                // calculation for the 
                // jth stair
                combo[j] += combo[j - i];
            }
        }
    }
  
    // returns the no of possible 
    // number of leaps to reach 
    // the top of building of 
    // n stairs
    return combo[N];
}
  
// Driver Code
public static void main(String args[])
{
    // N i the no of total stairs
    // K is the value of the 
    // greatest leap
    int N = 29;
    int K = 5;
  
    System.out.println(solve(N, K));
  
    solve(N, K);
}
}
  
// This code is contributed 
// by ankita_saini

Python 3

# Python3 program to reach N-th stair
# by taking a maximum of K leap 
  
def solve(N, K) :
  
    # elements of combo[] stores the no of  
    # possible ways to reach it by all  
    # combinations of k leaps or less 
    combo = [0] * (N + 1)
  
    # assuming leap 0 exist and assigning  
    # its value to 1 for calculation 
    combo[0] = 1
  
    # loop to iterate over all  
    # possible leaps upto k; 
    for i in range(1, K + 1) :
  
        #  in this loop we count all possible  
        # leaps to reach the jth stair with  
        # the help of ith leap or less  
        for j in range(0, N + 1) :
  
            # if the leap is not more than the i-j  
            if j >= i :
  
                # calculate the value and  
                # store in combo[j]  
                # to reuse it for next leap  
                # calculation for the jth stair 
                combo[j] += combo[j - i]
  
  
    # returns the no of possible number  
    # of leaps to reach the top of  
    # building of n stairs  
    return combo[N]
    
# Driver Code
if __name__ == "__main__" :
  
    # N i the no of total stairs  
    # K is the value of the greatest leap 
    N, K = 29, 5
  
    print(solve(N, K))
  
# This code is contributed by ANKITRAI1

C#

// C# program to reach N-th 
// stair by taking a maximum 
// of K leap
using System;
  
class GFG
{
static int solve(int N, int K)
{
  
    // elements of combo[] stores 
    // the no. of possible ways 
    // to reach it by all combinations
    // of k leaps or less
    int[] combo;
    combo = new int[50];
  
    // assuming leap 0 exist 
    // and assigning its value
    // to 1 for calculation
    combo[0] = 1;
  
    // loop to iterate over all
    // possible leaps upto k;
    for (int i = 1; i <= K; i++) 
    {
  
        // in this loop we count all
        // possible leaps to reach
        // the jth stair with the 
        // help of ith leap or less
        for (int j = 0; j <= N; j++) 
        {
  
            // if the leap is not
            // more than the i-j
            if (j >= i)
            {
  
                // calculate the value and 
                // store in combo[j] to 
                // reuse it for next leap
                // calculation for the 
                // jth stair
                combo[j] += combo[j - i];
            }
        }
    }
  
    // returns the no of possible 
    // number of leaps to reach 
    // the top of building of 
    // n stairs
    return combo[N];
}
  
// Driver Code
public static void Main()
{
    // N i the no of total stairs
    // K is the value of the 
    // greatest leap
    int N = 29;
    int K = 5;
  
    Console.WriteLine(solve(N, K));
    solve(N, K);
}
}
  
// This code is contributed 
// by Akanksha Rai(Abby_akku)

PHP

= $i)
            { 
  
                // calculate the value and 
                // store in combo[j] 
                // to reuse it for next leap 
                // calculation for the jth stair 
                $combo[$j] += $combo[$j - $i]; 
            } 
        } 
    } 
  
    // returns the no of possible 
    // number of leaps to reach 
    // the top of building of n stairs 
    return $combo[$N]; 
} 
  
// Driver Code 
  
// N i the no of total stairs 
// K is the value of the greatest leap 
$N = 29; 
$K = 5; 
  
echo solve($N, $K); 
  
solve($N, $K); 
  
// This code is contributed 
// by Akanksha Rai(Abby_akku) 
?>

输出：

603

时间复杂度： O(N * K)
辅助空间： O(N)