Given a positive integer n, the task is to generate all possible unique ways to represent n as sum of positive integers.
Examples:
Input: 4
Output:
4
3 1
2 2
2 1 1
1 1 1 1
Input: 3
Output:
3
2 1
1 1 1
Approach: We have already discussed the implementation of generating unique partitions in this post. This post contains another and far more intuitive implementation for the above problem using recursion.
The idea is simple and is kind of same approach as used here. We have to move recursively from n to 1 and keep on appending the numbers used to form sum in the array. When the sum becomes equal to n then we print the array and return. The base cases considered in the implementation are: remSum == 0: Required n is formed so print the array.
Then we have started forming required sum using the max value number used in the previous partition. If that number becomes greater than n we ignore it else we append that number to the array and move recursively to next iteration to form sum = (remSum – i) and where max value
number that could be used is i or less than i. This way we can generate the required unique partitions.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int dp[200];
int count = 0;
void print(int idx)
{
for (int i = 1; i < idx; i++) {
cout << dp[i] << " ";
}
cout << endl;
}
void solve(int remSum, int maxVal, int idx, int& count)
{
if (remSum == 0) {
print(idx);
count++;
return;
}
for (int i = maxVal; i >= 1; i--) {
if (i > remSum) {
continue;
}
else if (i <= remSum) {
dp[idx] = i;
solve(remSum - i, i, idx + 1, count);
}
}
}
int main()
{
int n = 4, count = 0;
solve(n, n, 1, count);
return 0;
}
|
Java
import java.util.*;
class GFG
{
static int[] dp = new int[200];
static int count = 0;
static void print(int idx)
{
for (int i = 1; i < idx; i++)
{
System.out.print(dp[i] + " ");
}
System.out.println("");
}
static void solve(int remSum, int maxVal,
int idx, int count)
{
if (remSum == 0)
{
print(idx);
count++;
return;
}
for (int i = maxVal; i >= 1; i--)
{
if (i > remSum)
{
continue;
}
else if (i <= remSum)
{
dp[idx] = i;
solve(remSum - i, i, idx + 1, count);
}
}
}
public static void main(String[] args)
{
int n = 4, count = 0;
solve(n, n, 1, count);
}
}
|
Python3
dp = [0 for i in range(200)]
count = 0
def print1(idx):
for i in range(1,idx,1):
print(dp[i],end = " ")
print("\n",end = "")
def solve(remSum,maxVal,idx,count):
if (remSum == 0):
print1(idx)
count += 1
return
i = maxVal
while(i >= 1):
if (i > remSum):
i -= 1
continue
elif (i <= remSum):
dp[idx] = i
solve(remSum - i, i, idx + 1, count)
i -= 1
if __name__ == '__main__':
n = 4
count = 0
solve(n, n, 1, count)
|
C#
using System;
class GFG
{
static int[] dp = new int[200];
static void print(int idx)
{
for (int i = 1; i < idx; i++)
{
Console.Write(dp[i] + " ");
}
Console.WriteLine("");
}
static void solve(int remSum, int maxVal,
int idx, int count)
{
if (remSum == 0)
{
print(idx);
count++;
return;
}
for (int i = maxVal; i >= 1; i--)
{
if (i > remSum)
{
continue;
}
else if (i <= remSum)
{
dp[idx] = i;
solve(remSum - i, i, idx + 1, count);
}
}
}
public static void Main()
{
int n = 4, count = 0;
solve(n, n, 1, count);
}
}
|
Javascript
<script>
var dp = Array.from({length: 200}, (_, i) => 0);
var count = 0;
function print(idx)
{
for (var i = 1; i < idx; i++)
{
document.write(dp[i] + " ");
}
document.write('<br>');
}
function solve(remSum , maxVal,idx , count)
{
if (remSum == 0)
{
print(idx);
count++;
return;
}
for (var i = maxVal; i >= 1; i--)
{
if (i > remSum)
{
continue;
}
else if (i <= remSum)
{
dp[idx] = i;
solve(remSum - i, i, idx + 1, count);
}
}
}
var n = 4, count = 0;
solve(n, n, 1, count);
</script>
|
Output: 4
3 1
2 2
2 1 1
1 1 1 1