Sum of elements of all partitions of number such that no element is less than K
Last Updated :
13 Jan, 2023
Given an integer N, the task is to find an aggregate sum of all integer partitions of this number such that each partition does not contain any integer less than K.
Examples:
Input: N = 6 and K = 2
Output: 24
In this case, there are 4 valid partitions.
1) {6}
2) {4, 2}
3) {3, 3}
4) {2, 2, 2}
Therefore, aggregate sum would be 6 + 4 + 2 + 3 + 3 + 2 + 2 + 2 = 24
Input: N = 10 and K = 3
Output: 50
Here, 5 valid partitions are:
1) {10}
2) {7, 3}
3) {6, 4}
4) {5, 5}
5) {3, 3, 4}
Aggregate sum in this case would be 10 + 7 + 3 + 6 + 4 + 5 + 5 + 3 + 3 + 4 = 50
Approach: This problem has a simple recursive solution. First, we need to count the total number of valid partitions of number N such that each partition contains integers greater than or equal to K. So we will iteratively apply our recursive solution to find valid partitions that have the minimum integer K, K+1, K+2, …, N.
Our final answer would be N * no of valid partitions because each valid partition has a sum equal to N.
Following are some key ideas for designing recursive function to find total number of valid partitions.
- If N < K then no partition is possible.
- If N < 2*K then only one partition is possible and that is the number N itself.
- We can find number partitions in a recursive manner that contains integers at least equal to ‘i’ (‘i’ can be from K to N) and add them all to get final answer.
Pseudo code for recursive function to find number of valid partitions:
f(N,K):
if N < K
return 0
if N < 2K
return 1
Initialize answer = 1
FOR i from K to N
answer = answer + f(N-i,i)
return answer
Below is the Dynamic Programming solution:
C++
#include <bits/stdc++.h>
using namespace std;
long long int countPartitions( int n, int k)
{
long long int dp[201][201];
for ( int i = 0; i < n + 1; i++) {
for ( int j = 0; j < n + 1; j++) {
dp[i][j] = -1;
}
}
if (dp[n][k] >= 0)
return dp[n][k];
if (n < k)
return 0;
if (n < 2 * k)
return 1;
long long int answer = 1;
for ( int i = k; i < n; i++)
answer = answer + countPartitions(n - i, i);
dp[n][k] = answer;
return answer;
}
int main()
{
int n = 10, k = 3;
cout << "Total Aggregate sum of all Valid Partitions: "
<< countPartitions(n, k) * n;
return 0;
}
|
Java
class GFG
{
static long countPartitions( int n, int k)
{
long [][] dp = new long [ 201 ][ 201 ];
for ( int i = 0 ; i < n + 1 ; i++)
{
for ( int j = 0 ; j < n + 1 ; j++)
{
dp[i][j] = - 1 ;
}
}
if (dp[n][k] >= 0 )
return dp[n][k];
if (n < k)
return 0 ;
if (n < 2 * k)
return 1 ;
long answer = 1 ;
for ( int i = k; i < n; i++)
answer = answer +
countPartitions(n - i, i);
dp[n][k] = answer;
return answer;
}
public static void main(String[] args)
{
int n = 10 , k = 3 ;
System.out.println( "Total Aggregate sum of " +
"all Valid Partitions: " +
countPartitions(n, k) * n);
}
}
|
Python3
def countPartitions(n, k):
dp = [[ 0 ] * 201 ] * 201
for i in range (n + 1 ):
for j in range (n + 1 ):
dp[i][j] = - 1
if (dp[n][k] > = 0 ):
return dp[n][k]
if (n < k) :
return 0
if (n < 2 * k):
return 1
answer = 1
for i in range (k, n):
answer = (answer +
countPartitions(n - i, i))
dp[n][k] = answer
return answer
n = 10
k = 3
print ( "Total Aggregate sum of all "
"Valid Partitions: " ,
countPartitions(n, k) * n)
|
C#
using System;
class GFG
{
public static long countPartitions( int n, int k)
{
long [,] dp = new long [201,201];
for ( int i = 0; i < n + 1; i++) {
for ( int j = 0; j < n + 1; j++) {
dp[i,j] = -1;
}
}
if (dp[n,k] >= 0)
return dp[n,k];
if (n < k)
return 0;
if (n < 2 * k)
return 1;
long answer = 1;
for ( int i = k; i < n; i++)
answer = answer + countPartitions(n - i, i);
dp[n,k] = answer;
return answer;
}
static void Main()
{
int n = 10, k = 3;
Console.Write( "Total Aggregate sum of all Valid Partitions: " + countPartitions(n, k) * n);
}
}
|
Javascript
<script>
function countPartitions(n, k)
{
let dp = new Array(201);
for (let i = 0; i < n + 1; i++)
{
dp[i] = new Array(201);
for (let j = 0; j < n + 1; j++)
{
dp[i][j] = -1;
}
}
if (dp[n][k] >= 0)
return dp[n][k];
if (n < k)
return 0;
if (n < 2 * k)
return 1;
let answer = 1;
for (let i = k; i < n; i++)
answer = answer + countPartitions(n - i, i);
dp[n][k] = answer;
return answer;
}
let n = 10, k = 3;
document.write( "Total Aggregate sum of " +
"all Valid Partitions: " +
countPartitions(n, k) * n);
</script>
|
Output:
Total Aggregate sum of all Valid Partitions: 50
Time Complexity: O(N2)
Auxiliary Space: O(201*201) = O(1)
Share your thoughts in the comments
Please Login to comment...