# Count possible splits of sum N into K integers such that the minimum is at least P

Given three integers N, P, and K, the task is to find the total number of ways to divide N into K integers having sum N where each integer is ≥ P.

Examples:

Input: K = 3, N = 8, P = 2
Output: 6
Explanation:
Six possible solutions are: {2, 2, 4}, {2, 3, 3}, {2, 4, 2}, {3, 2, 3}, {3, 3, 2}, {4, 2, 2}
Each of the above integers in all combinations are ≥ P(= 2) and sum of all the combinations is N(=8).

Input: K = 2, N = 7, P = 2
Output: 4
Explanation:
Four possible solutions are: {4, 3}, {3, 4}, {5, 2}, {2, 5}
Each of the above integers in all combinations are ≥ P(= 2) and sum of all the combinations is N(= 7).

Naive Approach: The simplest approach is to try all possible combinations of K integers having sum N and check if they satisfy the above conditions or not. There are K positions and in each position, N integers can be placed. Therefore, the total number of combinations to check is NK

Time Complexity: O(NK)
Auxiliary Space: O(1)

Efficient Approach: To optimize the above approach, the idea is to use the approach discussed in this article and the given above conditions can be written in terms of a linear equation is:

To find the number of solutions for the equation X1 + X2 + X3 + … + XK = N where Xi ≥ P.

Assume Xi‘ = Xi – P.
Therefore, the equation reduces to:
X1‘ + X2‘ + X3‘ + … + XK‘ = N – K*P

As per the above equations, the given problem reduces to finding total number of ways to split N – K * P into K integers. Print the total number of ways found above as the required answer.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach`   `#include ` `using` `namespace` `std;`   `// Function that finds the value of` `// the Binomial Coefficient C(n, k)` `int` `binomialCoeff(``int` `n, ``int` `k)` `{` `    ``int` `C[n + 1][k + 1];` `    ``int` `i, j;`   `    ``// Stores the value of Binomial` `    ``// Coefficient in bottom up manner` `    ``for` `(i = 0; i <= n; i++) {`   `        ``for` `(j = 0; j <= min(i, k); j++) {`   `            ``// Base Case` `            ``if` `(j == 0 || j == i)` `                ``C[i][j] = 1;`   `            ``// Find the value using` `            ``// previously stored values` `            ``else` `                ``C[i][j] = C[i - 1][j - 1]` `                          ``+ C[i - 1][j];` `        ``}` `    ``}`   `    ``// Return the value of C(N, K)` `    ``return` `C[n][k];` `}`   `// Function that count the number of` `// ways to divide N into K integers` `// >= P such that their sum is N` `int` `waysToSplitN(``int` `k, ``int` `n, ``int` `P)` `{` `    ``// Update the value of N` `    ``int` `new_N = n - k * P;`   `    ``// Find the binomial coeffient` `    ``// recursively` `    ``return` `binomialCoeff(new_N + k - 1,` `                         ``new_N);` `}`   `// Driver Code` `int` `main()` `{` `    ``// Given K, N, and P` `    ``int` `K = 3, N = 8, P = 2;`   `    ``cout << waysToSplitN(K, N, P);`   `    ``return` `0;` `}`

## Java

 `// Java program for ` `// the above approach` `import` `java.util.*;` `class` `GFG{`   `// Function that finds the value of` `// the Binomial Coefficient C(n, k)` `static` `int` `binomialCoeff(``int` `n, ``int` `k)` `{` `  ``int` `[][]C = ``new` `int``[n + ``1``][k + ``1``];` `  ``int` `i, j;`   `  ``// Stores the value of Binomial` `  ``// Coefficient in bottom up manner` `  ``for` `(i = ``0``; i <= n; i++) ` `  ``{` `    ``for` `(j = ``0``; j <= Math.min(i, k); j++) ` `    ``{` `      ``// Base Case` `      ``if` `(j == ``0` `|| j == i)` `        ``C[i][j] = ``1``;`   `      ``// Find the value using` `      ``// previously stored values` `      ``else` `        ``C[i][j] = C[i - ``1``][j - ``1``] + ` `                  ``C[i - ``1``][j];` `    ``}` `  ``}`   `  ``// Return the value of C(N, K)` `  ``return` `C[n][k];` `}`   `// Function that count the number of` `// ways to divide N into K integers` `// >= P such that their sum is N` `static` `int` `waysToSplitN(``int` `k, ` `                        ``int` `n, ``int` `P)` `{` `  ``// Update the value of N` `  ``int` `new_N = n - k * P;`   `  ``// Find the binomial coeffient` `  ``// recursively` `  ``return` `binomialCoeff(new_N + k - ``1``,` `                       ``new_N);` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `  ``// Given K, N, and P` `  ``int` `K = ``3``, N = ``8``, P = ``2``;`   `  ``System.out.print(waysToSplitN(K, N, P));` `}` `}`   `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 program for the above approach `   `# Function that finds the value of` `# the Binomial Coefficient C(n, k)` `def` `binomialCoeff(n, k):`   `    ``C ``=` `[[``0` `for` `x ``in` `range``(k ``+` `1``)]` `            ``for` `y ``in` `range``(n ``+` `1``)]`   `    ``# Stores the value of Binomial` `    ``# Coefficient in bottom up manner` `    ``for` `i ``in` `range``(n ``+` `1``):` `        ``for` `j ``in` `range``(``min``(i, k) ``+` `1``):`   `            ``# Base Case` `            ``if``(j ``=``=` `0` `or` `j ``=``=` `i):` `                ``C[i][j] ``=` `1` `                `  `            ``# Find the value using` `            ``# previously stored values` `            ``else``:` `                ``C[i][j] ``=` `(C[i ``-` `1``][j ``-` `1``] ``+` `                           ``C[i ``-` `1``][j])`   `    ``# Return the value of C(N, K)` `    ``return` `C[n][k]`   `# Function that count the number of` `# ways to divide N into K integers` `# >= P such that their sum is N` `def` `waysToSplitN(k, n, P):`   `    ``# Update the value of N` `    ``new_N ``=` `n ``-` `k ``*` `P`   `    ``# Find the binomial coeffient` `    ``# recursively` `    ``return` `binomialCoeff(new_N ``+` `k ``-` `1``,` `                         ``new_N)`   `# Driver Code`   `# Given K, N, and P ` `K ``=` `3` `N ``=` `8` `P ``=` `2`   `print``(waysToSplitN(K, N, P))`   `# This code is contributed by Shivam Singh`

## C#

 `// C# program for the above approach` `using` `System;`   `class` `GFG{` ` `  `// Function that finds the value of` `// the Binomial Coefficient C(n, k)` `static` `int` `binomialCoeff(``int` `n, ``int` `k)` `{` `    ``int` `[,] C = ``new` `int``[n + 1, k + 1];` `    ``int` `i, j;` `    `  `    ``// Stores the value of Binomial` `    ``// Coefficient in bottom up manner` `    ``for``(i = 0; i <= n; i++) ` `    ``{` `        ``for``(j = 0; j <= Math.Min(i, k); j++) ` `        ``{` `            `  `            ``// Base Case` `            ``if` `(j == 0 || j == i)` `                ``C[i, j] = 1;` `            `  `            ``// Find the value using` `            ``// previously stored values` `            ``else` `                ``C[i, j] = C[i - 1, j - 1] + ` `                          ``C[i - 1, j];` `        ``}` `    ``}` `    `  `    ``// Return the value of C(N, K)` `    ``return` `C[n, k];` `}` ` `  `// Function that count the number of` `// ways to divide N into K integers` `// >= P such that their sum is N` `static` `int` `waysToSplitN(``int` `k, ``int` `n, ` `                        ``int` `P)` `{` `    `  `    ``// Update the value of N` `    ``int` `new_N = n - k * P;` `    `  `    ``// Find the binomial coeffient` `    ``// recursively` `    ``return` `binomialCoeff(new_N + k - 1,` `                         ``new_N);` `}` ` `  `// Driver Code` `public` `static` `void` `Main()` `{` `    `  `    ``// Given K, N, and P` `    ``int` `K = 3, N = 8, P = 2;` `    `  `    ``Console.Write(waysToSplitN(K, N, P));` `}` `}`   `// This code is contributed by sanjoy_62`

Output:

```6

```

Time Complexity: O(N2)
Auxiliary Space: O(N2)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.