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 = 2Output:6Explanation:

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 = 2Output:4Explanation:

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 **N ^{K}**.

**Time Complexity:** O(N^{K})**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 X

_{1 }+ X_{2 }+ X_{3 }+ … + X_{K }= N where X_{i }≥ P.Assume

X._{i}‘ = X_{i}– P

Therefore, the equation reduces to:X_{1}‘ + X_{2}‘ + X_{3}‘ + … + X_{K}‘ = 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 <bits/stdc++.h>` `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;` `}` |

*chevron_right*

*filter_none*

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

*chevron_right*

*filter_none*

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

*chevron_right*

*filter_none*

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

*chevron_right*

*filter_none*

**Output:**

6

**Time Complexity:** O(N^{2})**Auxiliary Space:** O(N^{2})

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.

## Recommended Posts:

- Minimum splits required to convert a number into prime segments
- Minimum splits in a binary string such that every substring is a power of 4 or 6.
- Maximum splits in binary string such that each substring is divisible by given odd number
- Maximize the numbers of splits in an Array having sum divisible by 3
- Minimum number of integers required such that each Segment contains at least one of them
- Minimum possible value T such that at most D Partitions of the Array having at most sum T is possible
- Minimum sum subsequence such that at least one of every four consecutive elements is picked
- Partition an array of non-negative integers into two subsets such that average of both the subsets is equal
- Pair of integers having least GCD among all given pairs having GCD exceeding K
- Minimum value to be added to X such that it is at least Y percent of N
- Count pairs in an array such that frequency of one is at least value of other
- Count of all possible pairs of disjoint subsets of integers from 1 to N
- Split N powers of 2 into two subsets such that their difference of sum is minimum
- Split array into two subarrays such that difference of their sum is minimum
- Maximum sub-sequence sum such that indices of any two adjacent elements differs at least by 3
- Median in a stream of integers (running integers)
- Mode in a stream of integers (running integers)
- Lexicographically smallest permutation of size A having B integers exceeding all preceeding integers
- Print all possible ways to write N as sum of two or more positive integers
- Maximum possible GCD for a pair of integers with sum N

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.