计算将 N 分在 k 组中的递增方式数

给定两个整数N和K ，任务是计算将 N 分成 K 个正整数组的方法的数量，使它们的总和为N并且组中的元素数量遵循非递减顺序(即 group[i] <= 组[i+1])。
例子：

Input: N = 8, K = 4 
Output: 5 
Explanation: 
Their are 5 groups such that their sum is 8 and the number of positive integers in each group is 4. 
[1, 1, 1, 5], [1, 1, 2, 4], [1, 1, 3, 3], [1, 2, 2, 3], [2, 2, 2, 2]
Input: N = 24, K = 5 
Output: 164 
Explanation: 
There are 164 such groups such that their sum is 24 and number of positive integers in each group is 5

朴素的方法：我们可以使用递归来解决这个问题。在递归的每个步骤中，放置所有大于等于先前计算值的值。
下面是上述方法的实现：

C++

// C++ implementation to count the
// number of ways to divide N in
// groups such that each group
// has K number of elements
 
#include 
 
using namespace std;
 
// Function to count the number
// of ways to divide the number N
// in groups such that each group
// has K number of elements
int calculate(int pos, int prev,
                 int left, int k)
{
    // Base Case
    if (pos == k) {
        if (left == 0)
            return 1;
        else
            return 0;
    }
 
    // if N is divides completely
    // into less than k groups
    if (left == 0)
        return 0;
 
    int answer = 0;
     
    // put all possible values
    // greater equal to prev
    for (int i = prev; i <= left; i++) {
        answer += calculate(pos + 1, i,
                          left - i, k);
    }
    return answer;
}
 
// Function to count the number of
// ways to divide the number N
int countWaystoDivide(int n, int k)
{
    return calculate(0, 1, n, k);
}
 
// Driver Code
int main()
{
    int N = 8;
    int K = 4;
 
    cout << countWaystoDivide(N, K);
    return 0;
}

Java

// Java implementation to count the
// number of ways to divide N in
// groups such that each group
// has K number of elements
import java.util.*;
class GFG{
 
// Function to count the number
// of ways to divide the number N
// in groups such that each group
// has K number of elements
static int calculate(int pos, int prev,
                     int left, int k)
{
     
    // Base Case
    if (pos == k)
    {
        if (left == 0)
            return 1;
        else
            return 0;
    }
 
    // If N is divides completely
    // into less than k groups
    if (left == 0)
        return 0;
 
    int answer = 0;
     
    // Put all possible values
    // greater equal to prev
    for(int i = prev; i <= left; i++)
    {
       answer += calculate(pos + 1, i,
                           left - i, k);
    }
    return answer;
}
 
// Function to count the number of
// ways to divide the number N
static int countWaystoDivide(int n, int k)
{
    return calculate(0, 1, n, k);
}
 
// Driver Code
public static void main(String[] args)
{
    int N = 8;
    int K = 4;
 
    System.out.print(countWaystoDivide(N, K));
}
}
 
// This code is contributed by Rajput-Ji

Python3

# Python3 implementation to count the
# number of ways to divide N in
# groups such that each group
# has K number of elements
 
# Function to count the number
# of ways to divide the number N
# in groups such that each group
# has K number of elements
def calculate(pos, prev, left, k):
     
    # Base Case
    if (pos == k):
        if (left == 0):
            return 1;
        else:
            return 0;
 
    # If N is divides completely
    # into less than k groups
    if (left == 0):
        return 0;
 
    answer = 0;
 
    # Put all possible values
    # greater equal to prev
    for i in range(prev, left + 1):
        answer += calculate(pos + 1, i,
                           left - i, k);
 
    return answer;
 
# Function to count the number of
# ways to divide the number N
def countWaystoDivide(n, k):
     
    return calculate(0, 1, n, k);
 
# Driver Code
if __name__ == '__main__':
     
    N = 8;
    K = 4;
 
    print(countWaystoDivide(N, K));
 
# This code is contributed by 29AjayKumar

C#

// C# implementation to count the
// number of ways to divide N in
// groups such that each group
// has K number of elements
using System;
 
class GFG{
 
// Function to count the number
// of ways to divide the number N
// in groups such that each group
// has K number of elements
static int calculate(int pos, int prev,
                     int left, int k)
{
     
    // Base Case
    if (pos == k)
    {
        if (left == 0)
            return 1;
        else
            return 0;
    }
 
    // If N is divides completely
    // into less than k groups
    if (left == 0)
        return 0;
 
    int answer = 0;
     
    // Put all possible values
    // greater equal to prev
    for(int i = prev; i <= left; i++)
    {
       answer += calculate(pos + 1, i,
                           left - i, k);
    }
    return answer;
}
 
// Function to count the number of
// ways to divide the number N
static int countWaystoDivide(int n, int k)
{
    return calculate(0, 1, n, k);
}
 
// Driver Code
public static void Main(String[] args)
{
    int N = 8;
    int K = 4;
 
    Console.Write(countWaystoDivide(N, K));
}
}
 
// This code is contributed by Rajput-Ji

Javascript

 
// Javascript implementation to count the
// number of ways to divide N in
// groups such that each group
// has K number of elements
 
 
 
// Function to count the number
// of ways to divide the number N
// in groups such that each group
// has K number of elements
function calculate(pos, prev,
                left, k)
{
    // Base Case
    if (pos == k) {
        if (left == 0)
            return 1;
        else
            return 0;
    }
 
    // if N is divides completely
    // into less than k groups
    if (left == 0)
        return 0;
 
    let answer = 0;
     
    // put all possible values
    // greater equal to prev
    for (let i = prev; i <= left; i++) {
        answer += calculate(pos + 1, i,
                        left - i, k);
    }
    return answer;
}
 
// Function to count the number of
// ways to divide the number N
function countWaystoDivide(n, k)
{
    return calculate(0, 1, n, k);
}
 
// Driver Code
 
    let N = 8;
    let K = 4;
 
    document.write(countWaystoDivide(N, K));
     
// This code is contributed by Mayank Tyagi
     

输出：

5

时间复杂度： O(N ^K )
高效方法：在前面的方法中，我们可以看到我们在重复解决子问题，即它遵循重叠子问题的性质。所以我们可以使用 DP 表记住相同的内容。
下面是上述方法的实现：

C++

// C++ implementation to count the
// number of ways to divide N in
// groups such that each group
// has K number of elements
 
#include 
 
using namespace std;
 
// DP Table
int dp[500][500][500];
 
// Function to count the number
// of ways to divide the number N
// in groups such that each group
// has K number of elements
int calculate(int pos, int prev,
                int left, int k)
{
    // Base Case
    if (pos == k) {
        if (left == 0)
            return 1;
        else
            return 0;
    }
    // if N is divides completely
    // into less than k groups
    if (left == 0)
        return 0;
 
    // If the subproblem has been
    // solved, use the value
    if (dp[pos][prev][left] != -1)
        return dp[pos][prev][left];
 
    int answer = 0;
    // put all possible values
    // greater equal to prev
    for (int i = prev; i <= left; i++) {
        answer += calculate(pos + 1, i,
                           left - i, k);
    }
 
    return dp[pos][prev][left] = answer;
}
 
// Function to count the number of
// ways to divide the number N in groups
int countWaystoDivide(int n, int k)
{
    // Initialize DP Table as -1
    memset(dp, -1, sizeof(dp));
 
    return calculate(0, 1, n, k);
}
 
// Driver Code
int main()
{
    int N = 8;
    int K = 4;
 
    cout << countWaystoDivide(N, K);
    return 0;
}

Java

// Java implementation to count the
// number of ways to divide N in
// groups such that each group
// has K number of elements
import java.util.*;
class GFG{
  
// DP Table
static int [][][]dp = new int[500][500][500];
  
// Function to count the number
// of ways to divide the number N
// in groups such that each group
// has K number of elements
static int calculate(int pos, int prev,
                     int left, int k)
{
    // Base Case
    if (pos == k)
    {
        if (left == 0)
            return 1;
        else
            return 0;
    }
   
    // if N is divides completely
    // into less than k groups
    if (left == 0)
        return 0;
  
    // If the subproblem has been
    // solved, use the value
    if (dp[pos][prev][left] != -1)
        return dp[pos][prev][left];
  
    int answer = 0;
   
    // put all possible values
    // greater equal to prev
    for (int i = prev; i <= left; i++)
    {
        answer += calculate(pos + 1, i,
                           left - i, k);
    }
  
    return dp[pos][prev][left] = answer;
}
  
// Function to count the number of
// ways to divide the number N in groups
static int countWaystoDivide(int n, int k)
{
    // Initialize DP Table as -1
        for (int i = 0; i < 500; i++)
        {
            for (int j = 0; j < 500; j++)
            {
                for (int l = 0; l < 500; l++)
                    dp[i][j][l] = -1;
            }
        }
  
    return calculate(0, 1, n, k);
}
  
// Driver Code
public static void main(String[] args)
{
    int N = 8;
    int K = 4;
  
    System.out.print(countWaystoDivide(N, K));
}
}
 
// This code is contributed by Rajput-Ji

蟒蛇3

# Python3 implementation to count the
# number of ways to divide N in
# groups such that each group
# has K number of elements
  
# DP Table
dp = [[[0 for i in range(50)]
             for j in range(50)]
          for j in range(50)]
 
# Function to count the number
# of ways to divide the number N
# in groups such that each group
# has K number of elements
def calculate(pos, prev, left, k):
    
    # Base Case
    if (pos == k):
        if (left == 0):
            return 1;
        else:
            return 0;
  
    # if N is divides completely
    # into less than k groups
    if (left == 0):
        return 0;
  
    # If the subproblem has been
    # solved, use the value
    if (dp[pos][prev][left] != -1):
        return dp[pos][prev][left];
  
    answer = 0;
  
    # put all possible values
    # greater equal to prev
    for i in range(prev,left+1):
        answer += calculate(pos + 1, i,
                            left - i, k);
    dp[pos][prev][left] = answer;
    return dp[pos][prev][left];
  
# Function to count the number of
# ways to divide the number N in groups
def countWaystoDivide(n, k):
   
    # Initialize DP Table as -1
    for i in range(50):
        for j in range(50):
            for l in range(50):
                dp[i][j][l] = -1;
  
    return calculate(0, 1, n, k);
  
# Driver Code
if __name__ == '__main__':
    N = 8;
    K = 4;
  
    print(countWaystoDivide(N, K));
  
# This code is contributed by Rajput-Ji

C＃

// C# implementation to count the
// number of ways to divide N in
// groups such that each group
// has K number of elements
using System;
class GFG{
  
// DP Table
static int [,,]dp = new int[50, 50, 50];
  
// Function to count the number
// of ways to divide the number N
// in groups such that each group
// has K number of elements
static int calculate(int pos, int prev,
                     int left, int k)
{
    // Base Case
    if (pos == k)
    {
        if (left == 0)
            return 1;
        else
            return 0;
    }
   
    // if N is divides completely
    // into less than k groups
    if (left == 0)
        return 0;
  
    // If the subproblem has been
    // solved, use the value
    if (dp[pos, prev, left] != -1)
        return dp[pos, prev, left];
  
    int answer = 0;
   
    // put all possible values
    // greater equal to prev
    for (int i = prev; i <= left; i++)
    {
        answer += calculate(pos + 1, i,
                           left - i, k);
    }
  
    return dp[pos, prev, left] = answer;
}
  
// Function to count the number of
// ways to divide the number N in groups
static int countWaystoDivide(int n, int k)
{
    // Initialize DP Table as -1
        for (int i = 0; i < 50; i++)
        {
            for (int j = 0; j < 50; j++)
            {
                for (int l = 0; l < 50; l++)
                    dp[i, j, l] = -1;
            }
        }
  
    return calculate(0, 1, n, k);
}
  
// Driver Code
public static void Main(String[] args)
{
    int N = 8;
    int K = 4;
  
    Console.Write(countWaystoDivide(N, K));
}
}
 
// This code is contributed by gauravrajput1

Javascript

 
// JavaScript implementation to count the
// number of ways to divide N in
// groups such that each group
// has K number of elements
 
// DP Table
let dp = new Array(500);
for(let i=0;i<500;i++)
{
    dp[i]=new Array(500);
    for(let j=0;j<500;j++)
    {
        dp[i][j]=new Array(500);
        for(let k=0;k<500;k++)
            dp[i][j][k]=0;
    }
}
 
// Function to count the number
// of ways to divide the number N
// in groups such that each group
// has K number of elements
function calculate(pos,prev,left,k)
{
    // Base Case
    if (pos == k)
    {
        if (left == 0)
            return 1;
        else
            return 0;
    }
    
    // if N is divides completely
    // into less than k groups
    if (left == 0)
        return 0;
   
    // If the subproblem has been
    // solved, use the value
    if (dp[pos][prev][left] != -1)
        return dp[pos][prev][left];
   
    let answer = 0;
    
    // put all possible values
    // greater equal to prev
    for (let i = prev; i <= left; i++)
    {
        answer += calculate(pos + 1, i,
                           left - i, k);
    }
   
    return dp[pos][prev][left] = answer;
}
 
// Function to count the number of
// ways to divide the number N in groups
function countWaystoDivide(n,k)
{
    // Initialize DP Table as -1
        for (let i = 0; i < 500; i++)
        {
            for (let j = 0; j < 500; j++)
            {
                for (let l = 0; l < 500; l++)
                    dp[i][j][l] = -1;
            }
        }
   
    return calculate(0, 1, n, k);
}
 
// Driver Code
let N = 8;
let K = 4;
 
document.write(countWaystoDivide(N, K));
 
 
// This code is contributed by unknown2108
 

输出：

5

时间复杂度： O(N^3 * K)