 Open in App
Not now

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

• Last Updated : 22 Nov, 2021

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 coefficient``    ``// 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 coefficient``  ``// 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 coefficient``    ``# 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 coefficient``    ``// 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`

## Javascript

 ``

Output:

`6`

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

My Personal Notes arrow_drop_up