Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

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



<script>
 
// Javascript program to implement
// the above approach
 
// Function that finds the value of
// the Binomial Coefficient C(n, k)
function binomialCoeff(n, k)
{
      let C = new Array(n + 1);
   
    // Loop to create 2D array using 1D array
    for (let i = 0; i < C.length; i++) {
        C[i] = new Array(2);
    }
     
  let 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
function waysToSplitN(k, n, P)
{
  // Update the value of N
  let 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
  let K = 3, N = 8, P = 2;
  
  document.write(waysToSplitN(K, N, P));
     
</script>
Output: 
6
 
Time Complexity: O(N2)
Auxiliary Space: O(N2)

My Personal Notes
arrow_drop_up
Previous
Find Nth term of the series 3, 14, 39, 84...
Next

Number of ways to write N as a sum of K non-negative integers
Recommended Articles
Page :
Minimum splits required to convert a number into prime segments
26, Mar 20
Minimum splits in a binary string such that every substring is a power of 4 or 6.
11, Jun 18
Smallest index that splits an array into two subarrays with equal product
13, May 21
Minimize maximum array element possible by at most K splits on the given array
31, Mar 21
Maximum possible balanced binary substring splits with at most cost K
18, Nov 21
Maximum splits in binary string such that each substring is divisible by given odd number
13, May 20
Maximize the numbers of splits in an Array having sum divisible by 3
07, Jul 20
Minimum number of integers required such that each Segment contains at least one of them
28, Jul 20
Minimum days to make Array elements with value at least K sum at least X
07, Jul 21
Split array into minimum number of subsets such that elements of all pairs are present in different subsets at least once
04, Jan 21
Count numbers up to N that cannot be expressed as sum of at least two consecutive positive integers
03, May 21
Minimum possible value T such that at most D Partitions of the Array having at most sum T is possible
21, Aug 20
Split array into maximum possible subsets having product of their length with the maximum element at least K
30, Jul 21
Count of distinct integers belonging to first N terms of at least one of given GPs
20, Sep 21
Count integers up to N that are equal to at least 2nd power of any integer exceeding 1
13, Apr 21
Maximum number of subsets an array can be split into such that product of their minimums with size of subsets is at least K
21, Apr 21
Check if a number can be represented as sum of K positive integers out of which at least K - 1 are nearly prime
26, Feb 21
Check if N can be represented as sum of positive integers containing digit D at least once
11, May 21
Sum of length of two smallest subsets possible from a given array with sum at least K
10, Mar 21
Minimum sum subsequence such that at least one of every four consecutive elements is picked
02, Jan 17
Count even sum pairs possible by selecting two integers from two given ranges respectively
22, Jan 21
Partition an array of non-negative integers into two subsets such that average of both the subsets is equal
11, Jul 19
Maximize sum of selected integers from an Array of pair of integers as per given condition
19, Jan 22
Count of index subsets such that maximum of values over these indices in A is at least total sum over B
20, Sep 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
a_kash
@a_kash
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!