GFG App
Open App
Browser
Continue

# Count of all possible combinations of K numbers that sums to N

Given a number N, the task is to count the combinations of K numbers from 1 to N having a sum equal to N, with duplicates allowed.

Example:

Input: N = 7, K = 3
Output:15
Explanation:The combinations which lead to the sum N = 7 are: {1, 1, 5}, {1, 5, 1}, {5, 1, 1}, {2, 1, 4}, {1, 2, 4}, {1, 4, 2}, {2, 4, 1}, {4, 1, 2}, {4, 2, 1}, {3, 1, 3}, {1, 3, 3}, {3, 3, 1}, {2, 2, 3}, {2, 3, 2}, {3, 2, 2}

Input: N = 5, K = 5
Output: 1
Explanation: {1, 1, 1, 1, 1} is the only combination.

Naive Approach: This problem can be solved using recursion and then memoising the result to improve time complexity. To solve this problem, follow the below steps:

1. Create a function, say countWaysUtil which will accept four parameters that are N, K, sum, and dp. Here N is the sum that K elements are required to have, K is the number of elements consumed, sum is the sum accumulated till now and dp is the matrix to memoise the result. This function will give the number of ways to get the sum in K numbers.
2. Now initially call countWaysUtil with arguments N, K, sum=0 and dp as a matrix filled with all -1.
3. In each recursive call:
• Check for the base cases:
• If the sum is equal to N and K become 0, then return 1.
• If the sum exceeds N and K is still greater than 0, then return 0.
• Now, run a for loop from 1 to N, to check the result for each outcome.
• Sum all the results in a variable cnt and return cnt after memoising.
4. Print the answer according to the above observation.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach`   `#include ` `using` `namespace` `std;`   `// Function to count` `// all the possible combinations` `// of K numbers having sum equals to N` `int` `countWaysUtil(``int` `N, ``int` `K, ``int` `sum,` `                  ``vector >& dp)` `{`   `    ``// Base Cases` `    ``if` `(sum == N and K == 0) {` `        ``return` `1;` `    ``}`   `    ``if` `(sum >= N and K >= 0) {` `        ``return` `0;` `    ``}`   `    ``if` `(K < 0) {` `        ``return` `0;` `    ``}`   `    ``// If the result is already memoised` `    ``if` `(dp[sum][K] != -1) {` `        ``return` `dp[sum][K];` `    ``}`   `    ``// Recursive Calls` `    ``int` `cnt = 0;` `    ``for` `(``int` `i = 1; i <= N; i++) {` `        ``cnt += countWaysUtil(` `            ``N, K - 1,` `            ``sum + i, dp);` `    ``}`   `    ``// Returning answer` `    ``return` `dp[sum][K] = cnt;` `}`   `void` `countWays(``int` `N, ``int` `K)` `{` `    ``vector > dp(N + 1,` `                            ``vector<``int``>(` `                                ``K + 1, -1));` `    ``cout << countWaysUtil(N, K, 0, dp);` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `N = 7, K = 3;` `    ``countWays(N, K);` `}`

## Java

 `// Java implementation for the above approach` `class` `GFG {`   `    ``// Function to count` `    ``// all the possible combinations` `    ``// of K numbers having sum equals to N` `    ``static` `int` `countWaysUtil(``int` `N, ``int` `K, ``int` `sum,` `                             ``int``[][] dp)` `    ``{`   `        ``// Base Cases` `        ``if` `(sum == N && K == ``0``) {` `            ``return` `1``;` `        ``}`   `        ``if` `(sum >= N && K >= ``0``) {` `            ``return` `0``;` `        ``}`   `        ``if` `(K < ``0``) {` `            ``return` `0``;` `        ``}`   `        ``// If the result is already memoised` `        ``if` `(dp[sum][K] != -``1``) {` `            ``return` `dp[sum][K];` `        ``}`   `        ``// Recursive Calls` `        ``int` `cnt = ``0``;` `        ``for` `(``int` `i = ``1``; i <= N; i++) {` `            ``cnt += countWaysUtil(N, K - ``1``, sum + i, dp);` `        ``}`   `        ``// Returning answer` `        ``return` `dp[sum][K] = cnt;` `    ``}`   `    ``static` `void` `countWays(``int` `N, ``int` `K)` `    ``{` `        ``int``[][] dp = ``new` `int``[N + ``1``][K + ``1``];` `        ``for` `(``int` `i = ``0``; i < N + ``1``; i++) {` `            ``for` `(``int` `j = ``0``; j < K + ``1``; j++) {`   `                ``dp[i][j] = -``1``;` `            ``}` `        ``}` `        ``System.out.print(countWaysUtil(N, K, ``0``, dp));` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `N = ``7``, K = ``3``;` `        ``countWays(N, K);` `    ``}` `}`   `// This code is contributed by ukasp.`

## Python3

 `# Python3 program for the above approach`   `# Function to count all the possible ` `# combinations of K numbers having ` `# sum equals to N` `def` `countWaysUtil(N, K, ``sum``, dp):`   `    ``# Base Cases` `    ``if` `(``sum` `=``=` `N ``and` `K ``=``=` `0``):` `        ``return` `1`   `    ``if` `(``sum` `>``=` `N ``and` `K >``=` `0``):` `        ``return` `0`   `    ``if` `(K < ``0``):` `        ``return` `0`   `    ``# If the result is already memoised` `    ``if` `(dp[``sum``][K] !``=` `-``1``):` `        ``return` `dp[``sum``][K]`   `    ``# Recursive Calls` `    ``cnt ``=` `0` `    ``for` `i ``in` `range``(``1``, N``+``1``):` `        ``cnt ``+``=` `countWaysUtil(N, K ``-` `1``, ``sum` `+` `i, dp)`   `    ``# Returning answer` `    ``dp[``sum``][K] ``=` `cnt` `    ``return` `dp[``sum``][K]`   `def` `countWays(N, K):` `    `  `    ``dp ``=` `[[``-``1` `for` `_ ``in` `range``(K ``+` `1``)] ` `              ``for` `_ ``in` `range``(N ``+` `1``)]` `    ``print``(countWaysUtil(N, K, ``0``, dp))`   `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:`   `    ``N ``=` `7` `    ``K ``=` `3` `    `  `    ``countWays(N, K)`   `# This code is contributed by rakeshsahni`

## C#

 `// C# implementation for the above approach` `using` `System;` `class` `GFG` `{` `    `  `// Function to count` `// all the possible combinations` `// of K numbers having sum equals to N` `static` `int` `countWaysUtil(``int` `N, ``int` `K, ``int` `sum,` `                  ``int` `[,]dp)` `{`   `    ``// Base Cases` `    ``if` `(sum == N && K == 0) {` `        ``return` `1;` `    ``}`   `    ``if` `(sum >= N && K >= 0) {` `        ``return` `0;` `    ``}`   `    ``if` `(K < 0) {` `        ``return` `0;` `    ``}`   `    ``// If the result is already memoised` `    ``if` `(dp[sum, K] != -1) {` `        ``return` `dp[sum, K];` `    ``}`   `    ``// Recursive Calls` `    ``int` `cnt = 0;` `    ``for` `(``int` `i = 1; i <= N; i++) {` `        ``cnt += countWaysUtil(` `            ``N, K - 1,` `            ``sum + i, dp);` `    ``}`   `    ``// Returning answer` `    ``return` `dp[sum, K] = cnt;` `}`   `static` `void` `countWays(``int` `N, ``int` `K)` `{` `    ``int` `[,]dp = ``new` `int``[N + 1, K + 1];` `    ``for``(``int` `i = 0; i < N + 1; i++) {` `        ``for``(``int` `j = 0; j < K + 1; j++) {` `            `  `            ``dp[i, j] = -1;` `        ``}` `    ``}` `    ``Console.Write(countWaysUtil(N, K, 0, dp));` `}`   `// Driver Code` `public` `static` `void` `Main()` `{` `    ``int` `N = 7, K = 3;` `    ``countWays(N, K);` `}` `}`   `// This code is contributed by Samim Hossain Mondal.`

## Javascript

 ``

Output

`15`

Time Complexity: O(N*K)
Space Complexity: O(N*K)

Efficient Approach:  This problem can also be solved using the binomial theorem. As the required sum is N with K elements, so suppose the K numbers are:

a1 + a2 + a3 + a4 + …….. + aK = N
According to the standard principle of partitioning in the binomial theorem, the above equation has a solution which is  N+K-1CK-1, where K>=0.
But in our case, K>=1.
So, therefore N should be substituted with N-K and the equation becomes  N-1CK-1

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Method to find factorial of given number` `int` `factorial(``int` `n)` `{` `    ``if` `(n == 0)` `        ``return` `1;` `        `  `    ``return` `n * factorial(n - 1);` `}`   `// Function to count all the possible ` `// combinations of K numbers having` `// sum equals to N` `int` `totalWays(``int` `N, ``int` `K)` `{` `    `  `    ``// If N

## C

 `// C Program for the above approach` `#include `   ` ``// method to find factorial of given number` ` ``int` `factorial(``int` `n)` ` ``{` `    ``if` `(n == 0)` `      ``return` `1;`   `    ``return` `n*factorial(n - 1);` ` ``}`   ` ``// Function to count` ` ``// all the possible combinations` ` ``// of K numbers having sum equals to N` ` ``int` `totalWays(``int` `N, ``int` `K) {`   `    ``// If N

## Java

 `// Java Program for the above approach` `class` `Solution{`   `  ``// method to find factorial of given number` `  ``static` `int` `factorial(``int` `n)` `  ``{` `    ``if` `(n == ``0``)` `      ``return` `1``;`   `    ``return` `n*factorial(n - ``1``);` `  ``}`   `  ``// Function to count` `  ``// all the possible combinations` `  ``// of K numbers having sum equals to N` `  ``static`  `int` `totalWays(``int` `N, ``int` `K) {`   `    ``// If N

## Python3

 `# Python Program for the above approach`   `from` `math ``import` `factorial`     `class` `Solution:`   `    ``# Function to count` `    ``# all the possible combinations` `    ``# of K numbers having sum equals to N` `    ``def` `totalWays(``self``, N, K):`   `        ``# If N

## C#

 `// C# Program for the above approach` `using` `System;` `public` `class` `Solution {`   `  ``// method to find factorial of given number` `  ``static` `int` `factorial(``int` `n) {` `    ``if` `(n == 0)` `      ``return` `1;`   `    ``return` `n * factorial(n - 1);` `  ``}`   `  ``// Function to count` `  ``// all the possible combinations` `  ``// of K numbers having sum equals to N` `  ``static` `int` `totalWays(``int` `N, ``int` `K) {`   `    ``// If N

## Javascript

 ``

Output

`15`

Time complexity: O(N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up