# Sum of elements of all partitions of number such that no element is less than K

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 = 2Output: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 = 24Input:N = 10 and K = 3Output: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++

`// C++ implementation of above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function that returns total number of valid` `// partitions of integer N` `long` `long` `int` `countPartitions(` `int` `n, ` `int` `k)` `{` ` ` ` ` `// Global declaration of 2D dp array` ` ` `// which will be later used for memoization` ` ` `long` `long` `int` `dp[201][201];` ` ` `// initializing 2D dp array with -1` ` ` `// we will use this 2D array for memoization` ` ` `for` `(` `int` `i = 0; i < n + 1; i++) {` ` ` `for` `(` `int` `j = 0; j < n + 1; j++) {` ` ` `dp[i][j] = -1;` ` ` `}` ` ` `}` ` ` `// if this subproblem is already previously` ` ` `// calculated, then directly return that answer` ` ` `if` `(dp[n][k] >= 0)` ` ` `return` `dp[n][k];` ` ` `// if N < K, then no valid ` ` ` `// partition is possible` ` ` `if` `(n < k)` ` ` `return` `0;` ` ` `// if N is between K to 2*K then` ` ` `// there is only one` ` ` `// partition and that is the number N itself` ` ` `if` `(n < 2 * k)` ` ` `return` `1;` ` ` `// Initialize answer with 1 as ` ` ` `// the number N itself` ` ` `// is always a valid partition` ` ` `long` `long` `int` `answer = 1;` ` ` `// for loop to iterate over K to N` ` ` `// and find number of` ` ` `// possible valid partitions recursively.` ` ` `for` `(` `int` `i = k; i < n; i++)` ` ` `answer = answer + countPartitions(n - i, i);` ` ` `// memoization is done by storing` ` ` `// this calculated answer` ` ` `dp[n][k] = answer;` ` ` `// returning number of valid partitions` ` ` `return` `answer;` `}` `// Driver code` `int` `main()` `{` ` ` `int` `n = 10, k = 3;` ` ` `// Printing total number of valid partitions` ` ` `cout << ` `"Total Aggregate sum of all Valid Partitions: "` ` ` `<< countPartitions(n, k) * n;` ` ` `return` `0;` `}` |

## Java

`// Java implementation of` `// above approach` `class` `GFG` `{` `// Function that returns` `// total number of valid` `// partitions of integer N` `static` `long` `countPartitions(` `int` `n, ` `int` `k)` `{` ` ` `// Global declaration of 2D` ` ` `// dp array which will be ` ` ` `// later used for memoization` ` ` `long` `[][] dp = ` `new` `long` `[` `201` `][` `201` `];` ` ` `// initializing 2D dp array ` ` ` `// with -1 we will use this ` ` ` `// 2D array for memoization` ` ` `for` `(` `int` `i = ` `0` `; i < n + ` `1` `; i++)` ` ` `{` ` ` `for` `(` `int` `j = ` `0` `; j < n + ` `1` `; j++)` ` ` `{` ` ` `dp[i][j] = -` `1` `;` ` ` `}` ` ` `}` ` ` `// if this subproblem is already ` ` ` `// previously calculated, then ` ` ` `// directly return that answer` ` ` `if` `(dp[n][k] >= ` `0` `)` ` ` `return` `dp[n][k];` ` ` `// if N < K, then no valid ` ` ` `// partition is possible` ` ` `if` `(n < k)` ` ` `return` `0` `;` ` ` `// if N is between K to 2*K ` ` ` `// then there is only one` ` ` `// partition and that is ` ` ` `// the number N itself` ` ` `if` `(n < ` `2` `* k)` ` ` `return` `1` `;` ` ` `// Initialize answer with 1` ` ` `// as the number N itself` ` ` `// is always a valid partition` ` ` `long` `answer = ` `1` `;` ` ` `// for loop to iterate over ` ` ` `// K to N and find number of` ` ` `// possible valid partitions` ` ` `// recursively.` ` ` `for` `(` `int` `i = k; i < n; i++)` ` ` `answer = answer + ` ` ` `countPartitions(n - i, i);` ` ` `// memoization is done by storing` ` ` `// this calculated answer` ` ` `dp[n][k] = answer;` ` ` `// returning number of` ` ` `// valid partitions` ` ` `return` `answer;` `}` `// Driver code` `public` `static` `void` `main(String[] args)` `{` ` ` `int` `n = ` `10` `, k = ` `3` `;` ` ` `// Printing total number` ` ` `// of valid partitions` ` ` `System.out.println(` `"Total Aggregate sum of "` `+ ` ` ` `"all Valid Partitions: "` `+ ` ` ` `countPartitions(n, k) * n);` `}` `}` `// This code is contributed by mits` |

## Python3

`# Python3 implementation of above approach ` `# Function that returns total number of valid ` `# partitions of integer N ` `def` `countPartitions(n, k): ` ` ` `# Global declaration of 2D dp array ` ` ` `# which will be later used for memoization ` ` ` `dp ` `=` `[[` `0` `] ` `*` `201` `] ` `*` `201` ` ` `# Initializing 2D dp array with -1 ` ` ` `# we will use this 2D array for memoization ` ` ` `for` `i ` `in` `range` `(n ` `+` `1` `):` ` ` `for` `j ` `in` `range` `(n ` `+` `1` `):` ` ` `dp[i][j] ` `=` `-` `1` ` ` ` ` `# If this subproblem is already previously ` ` ` `# calculated, then directly return that answer ` ` ` `if` `(dp[n][k] >` `=` `0` `):` ` ` `return` `dp[n][k] ` ` ` `# If N < K, then no valid ` ` ` `# partition is possible ` ` ` `if` `(n < k) :` ` ` `return` `0` ` ` `# If N is between K to 2*K then ` ` ` `# there is only one partition ` ` ` `# and that is the number N itself ` ` ` `if` `(n < ` `2` `*` `k):` ` ` `return` `1` ` ` `# Initialize answer with 1 as ` ` ` `# the number N itself ` ` ` `# is always a valid partition ` ` ` `answer ` `=` `1` ` ` `# For loop to iterate over K to N ` ` ` `# and find number of possible valid ` ` ` `# partitions recursively. ` ` ` `for` `i ` `in` `range` `(k, n): ` ` ` `answer ` `=` `(answer ` `+` ` ` `countPartitions(n ` `-` `i, i)) ` ` ` `# Memoization is done by storing ` ` ` `# this calculated answer ` ` ` `dp[n][k] ` `=` `answer ` ` ` `# Returning number of valid partitions ` ` ` `return` `answer ` `# Driver code ` `n ` `=` `10` `k ` `=` `3` `# Printing total number of valid partitions ` `print` `(` `"Total Aggregate sum of all "` ` ` `"Valid Partitions: "` `, ` ` ` `countPartitions(n, k) ` `*` `n)` `# This code is contributed by sanjoy_62` |

## C#

`// C# implementation of above approach` `using` `System; ` ` ` `class` `GFG ` `{ ` ` ` `// Function that returns total number of valid ` ` ` `// partitions of integer N ` ` ` `public` `static` `long` `countPartitions(` `int` `n, ` `int` `k) ` ` ` `{ ` ` ` ` ` `// Global declaration of 2D dp array ` ` ` `// which will be later used for memoization ` ` ` `long` `[,] dp = ` `new` `long` `[201,201]; ` ` ` ` ` `// initializing 2D dp array with -1 ` ` ` `// we will use this 2D array for memoization ` ` ` `for` `(` `int` `i = 0; i < n + 1; i++) { ` ` ` `for` `(` `int` `j = 0; j < n + 1; j++) { ` ` ` `dp[i,j] = -1; ` ` ` `} ` ` ` `} ` ` ` ` ` `// if this subproblem is already previously ` ` ` `// calculated, then directly return that answer ` ` ` `if` `(dp[n,k] >= 0) ` ` ` `return` `dp[n,k]; ` ` ` ` ` `// if N < K, then no valid ` ` ` `// partition is possible ` ` ` `if` `(n < k) ` ` ` `return` `0; ` ` ` ` ` `// if N is between K to 2*K then ` ` ` `// there is only one ` ` ` `// partition and that is the number N itself ` ` ` `if` `(n < 2 * k) ` ` ` `return` `1; ` ` ` ` ` `// Initialize answer with 1 as ` ` ` `// the number N itself ` ` ` `// is always a valid partition ` ` ` `long` `answer = 1; ` ` ` ` ` `// for loop to iterate over K to N ` ` ` `// and find number of ` ` ` `// possible valid partitions recursively. ` ` ` `for` `(` `int` `i = k; i < n; i++) ` ` ` `answer = answer + countPartitions(n - i, i); ` ` ` ` ` `// memoization is done by storing ` ` ` `// this calculated answer ` ` ` `dp[n,k] = answer; ` ` ` ` ` `// returning number of valid partitions ` ` ` `return` `answer; ` ` ` `} ` ` ` ` ` `// Driver code ` ` ` `static` `void` `Main() ` ` ` `{ ` ` ` `int` `n = 10, k = 3; ` ` ` ` ` `// Printing total number of valid partitions ` ` ` `Console.Write(` `"Total Aggregate sum of all Valid Partitions: "` `+ countPartitions(n, k) * n); ` ` ` `}` ` ` `//This code is contributed by DrRoot_` `}` |

## Javascript

`<script>` ` ` `// Javascript implementation of above approach` ` ` ` ` `// Function that returns` ` ` `// total number of valid` ` ` `// partitions of integer N` ` ` `function` `countPartitions(n, k)` ` ` `{` ` ` `// Global declaration of 2D` ` ` `// dp array which will be ` ` ` `// later used for memoization` ` ` `let dp = ` `new` `Array(201);` ` ` `// initializing 2D dp array ` ` ` `// with -1 we will use this ` ` ` `// 2D array for memoization` ` ` `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 this subproblem is already ` ` ` `// previously calculated, then ` ` ` `// directly return that answer` ` ` `if` `(dp[n][k] >= 0)` ` ` `return` `dp[n][k];` ` ` `// if N < K, then no valid ` ` ` `// partition is possible` ` ` `if` `(n < k)` ` ` `return` `0;` ` ` `// if N is between K to 2*K ` ` ` `// then there is only one` ` ` `// partition and that is ` ` ` `// the number N itself` ` ` `if` `(n < 2 * k)` ` ` `return` `1;` ` ` `// Initialize answer with 1` ` ` `// as the number N itself` ` ` `// is always a valid partition` ` ` `let answer = 1;` ` ` `// for loop to iterate over ` ` ` `// K to N and find number of` ` ` `// possible valid partitions` ` ` `// recursively.` ` ` `for` `(let i = k; i < n; i++)` ` ` `answer = answer + countPartitions(n - i, i);` ` ` `// memoization is done by storing` ` ` `// this calculated answer` ` ` `dp[n][k] = answer;` ` ` `// returning number of` ` ` `// valid partitions` ` ` `return` `answer;` ` ` `}` ` ` ` ` `let n = 10, k = 3;` ` ` ` ` `// Printing total number` ` ` `// of valid partitions` ` ` `document.write(` `"Total Aggregate sum of "` `+ ` ` ` `"all Valid Partitions: "` `+ ` ` ` `countPartitions(n, k) * n);` `// This code is contributed by rameshtravel07.` `</script>` |

**Output:**

Total Aggregate sum of all Valid Partitions: 50

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