Subset Sum Problem in O(sum) space (original) (raw)
Last Updated : 16 May, 2024
Given an array of non-negative integers and a value **sum, determine if there is a subset of the given set with sum equal to given sum.
**Examples:
**Input: arr[] = {4, 1, 10, 12, 5, 2}, sum = 9
**Output: TRUE
**Explanation: {4, 5} is a subset with sum 9.**Input: arr[] = {1, 8, 2, 5}, sum = 4
**Output: FALSE
**Explanation: There exists no subset with sum 4.
We have discussed a Dynamic Programming based solution in the post "Dynamic Programming | Set 25 (Subset Sum Problem)".
**Subset Sum Problem in O(sum) space using 2D array:
The solution discussed above requires O(n * sum) space and O(n * sum) time. We can optimize space. We create a boolean 2D array subset[2][sum+1]. Using bottom-up manner we can fill up this table. The idea behind using **2 in "subset[2][sum+1]" is that for filling a row only the values from previous row are required. So alternate rows are used either making the first one as current and second as previous or the first as previous and second as current.
Below is the implementation of the above approach:
C++ `
#include using namespace std;
bool isSubsetSum(int arr[], int n, int sum) { // The value of subset[i][j] will be true // if there exists a subset of sum j in // arr[0, 1, ...., i-1] bool subset[n+1][sum + 1];
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= sum; j++) {
// A subset with sum 0 is always possible
if (j == 0)
subset[i][j] = true;
// If there exists no element no sum
// is possible
else if (i == 0)
subset[i][j] = false;
else if (arr[i - 1] <= j)
subset[i][j] = subset[i - 1][j - arr[i - 1]] || subset[i - 1][j];
else
subset[i][j] = subset[i - 1][j];
}
}
return subset[n][sum];}
// Driver code int main() { int arr[] = { 6, 2, 5 }; int sum = 7; int n = sizeof(arr) / sizeof(arr[0]); if (isSubsetSum(arr, n, sum) == true) cout <<"There exists a subset with given sum"; else cout <<"No subset exists with given sum"; return 0; }
C
// Returns true if there exists a subset // with given sum in arr[] #include <stdio.h> #include <stdbool.h>
bool isSubsetSum(int arr[], int n, int sum) { // The value of subset[i%2][j] will be true // if there exists a subset of sum j in // arr[0, 1, ...., i-1] bool subset[2][sum + 1];
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= sum; j++) {
// A subset with sum 0 is always possible
if (j == 0)
subset[i % 2][j] = true;
// If there exists no element no sum
// is possible
else if (i == 0)
subset[i % 2][j] = false;
else if (arr[i - 1] <= j)
subset[i % 2][j] = subset[(i + 1) % 2]
[j - arr[i - 1]] || subset[(i + 1) % 2][j];
else
subset[i % 2][j] = subset[(i + 1) % 2][j];
}
}
return subset[n % 2][sum];}
// Driver code int main() { int arr[] = { 6, 2, 5 }; int sum = 7; int n = sizeof(arr) / sizeof(arr[0]); if (isSubsetSum(arr, n, sum) == true) printf("There exists a subset with given sum"); else printf("No subset exists with given sum"); return 0; }
Java
// Java Program to get a subset with a // with a sum provided by the user public class Subset_sum {
// Returns true if there exists a subset
// with given sum in arr[]
static boolean isSubsetSum(int arr[], int n, int sum)
{
// The value of subset[i%2][j] will be true
// if there exists a subset of sum j in
// arr[0, 1, ...., i-1]
boolean subset[][] = new boolean[2][sum + 1];
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= sum; j++) {
// A subset with sum 0 is always possible
if (j == 0)
subset[i % 2][j] = true;
// If there exists no element no sum
// is possible
else if (i == 0)
subset[i % 2][j] = false;
else if (arr[i - 1] <= j)
subset[i % 2][j] = subset[(i + 1) % 2]
[j - arr[i - 1]] || subset[(i + 1) % 2][j];
else
subset[i % 2][j] = subset[(i + 1) % 2][j];
}
}
return subset[n % 2][sum];
}
// Driver code
public static void main(String args[])
{
int arr[] = { 1, 2, 5 };
int sum = 7;
int n = arr.length;
if (isSubsetSum(arr, n, sum) == true)
System.out.println("There exists a subset with" +
" given sum");
else
System.out.println("No subset exists with" +
" given sum");
}} // This code is contributed by Sumit Ghosh
Python
Returns true if there exists a subset
with given sum in arr[]
def isSubsetSum(arr, n, sum):
# The value of subset[i%2][j] will be true
# if there exists a subset of sum j in
# arr[0, 1, ...., i-1]
subset = [[False for j in range(sum + 1)] for i in range(3)]
for i in range(n + 1):
for j in range(sum + 1):
# A subset with sum 0 is always possible
if (j == 0):
subset[i % 2][j] = True
# If there exists no element no sum
# is possible
elif (i == 0):
subset[i % 2][j] = False
elif (arr[i - 1] <= j):
subset[i % 2][j] = subset[(i + 1) % 2][j - arr[i - 1]] or subset[(i + 1)
% 2][j]
else:
subset[i % 2][j] = subset[(i + 1) % 2][j]
return subset[n % 2][sum]Driver code
arr = [6, 2, 5] sum = 7 n = len(arr) if (isSubsetSum(arr, n, sum) == True): print("There exists a subset with given sum") else: print("No subset exists with given sum")
This code is contributed by Sachin Bisht
C#
// C# Program to get a subset with a // with a sum provided by the user
using System;
public class Subset_sum {
// Returns true if there exists a subset
// with given sum in arr[]
static bool isSubsetSum(int []arr, int n, int sum)
{
// The value of subset[i%2][j] will be true
// if there exists a subset of sum j in
// arr[0, 1, ...., i-1]
bool [,]subset = new bool[2,sum + 1];
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= sum; j++) {
// A subset with sum 0 is always possible
if (j == 0)
subset[i % 2,j] = true;
// If there exists no element no sum
// is possible
else if (i == 0)
subset[i % 2,j] = false;
else if (arr[i - 1] <= j)
subset[i % 2,j] = subset[(i + 1) % 2,j - arr[i - 1]] || subset[(i + 1) % 2,j];
else
subset[i % 2,j] = subset[(i + 1) % 2,j];
}
}
return subset[n % 2,sum];
}
// Driver code
public static void Main()
{
int []arr = { 1, 2, 5 };
int sum = 7;
int n = arr.Length;
if (isSubsetSum(arr, n, sum) == true)
Console.WriteLine("There exists a subset with" +
"given sum");
else
Console.WriteLine("No subset exists with" +
"given sum");
} } // This code is contributed by Ryuga
JavaScript
PHP
`
Output
There exists a subset with given sum
**Subset Sum Problem in O(sum) space using 1D array:
To further reduce space complexity, we create a boolean 1D array subset[sum+1]. Using bottom-up manner we can fill up this table. The idea is that we can check if the sum till position "i" is possible then if the current element in the array at position j is x, then sum i+x is also possible. We traverse the sum array from back to front so that we don't count any element twice.
Below is the implementation of the above approach:
C++ `
#include using namespace std;
bool isPossible(int elements[], int sum, int n) { int dp[sum + 1] = { 0 };
// Initializing with 1 as sum 0 is
// always possible
dp[0] = 1;
// Loop to go through every element of
// the elements array
for (int i = 0; i < n; i++) {
// To change the values of all possible sum
// values to 1
for (int j = sum; j >= elements[i]; j--) {
if (dp[j - elements[i]] == 1)
dp[j] = 1;
}
}
// If sum is possible then return 1
if (dp[sum] == 1)
return true;
return false;}
// Driver code int main() { int elements[] = { 6, 2, 5 }; int n = sizeof(elements) / sizeof(elements[0]); int sum = 7;
if (isPossible(elements, sum, n))
cout << ("YES");
else
cout << ("NO");
return 0;}
// This code is contributed by Potta Lokesh // This code is modified by Susobhan Akhuli
Java
import java.io.; import java.util.;
class GFG { static boolean isPossible(int elements[], int sum) { int dp[] = new int[sum + 1]; Arrays.fill(dp, 0);
// initializing with 1 as sum 0 is always possible
dp[0] = 1;
// loop to go through every element of the elements
// array
for (int i = 0; i < elements.length; i++) {
// to change the values of all possible sum
// values to 1
for (int j = sum; j >= elements[i]; j--) {
if (dp[j - elements[i]] == 1)
dp[j] = 1;
}
}
// if sum is possible then return 1
if (dp[sum] == 1)
return true;
return false;
}
public static void main(String[] args) throws Exception
{
int elements[] = { 6, 2, 5 };
int sum = 7;
if (isPossible(elements, sum))
System.out.println("YES");
else
System.out.println("NO");
}}
// This code is modified by Susobhan Akhuli
Python
def isPossible(elements, target):
dp = [False]*(target+1)
# initializing with 1 as sum 0 is always possible
dp[0] = True
# loop to go through every element of the elements array
for ele in elements:
# to change the value o all possible sum values to True
for j in range(target, ele - 1, -1):
if dp[j - ele]:
dp[j] = True
# If target is possible return True else False
return dp[target]Driver code
arr = [6, 2, 5] target = 7
if isPossible(arr, target): print("YES") else: print("NO")
The code is contributed by Arpan.
C#
using System;
class GFG { static Boolean isPossible(int[] elements, int sum) { int[] dp = new int[sum + 1]; Array.Fill(dp, 0);
// initializing with 1 as sum 0 is always possible
dp[0] = 1;
// loop to go through every element of the elements
// array
for (int i = 0; i < elements.Length; i++) {
// to change the values of all possible sum
// values to 1
for (int j = sum; j >= elements[i]; j--) {
if (dp[j - elements[i]] == 1)
dp[j] = 1;
}
}
// if sum is possible then return 1
if (dp[sum] == 1)
return true;
return false;
}
// Driver code
public static void Main(String[] args)
{
int[] elements = { 6, 2, 5 };
int sum = 7;
if (isPossible(elements, sum))
Console.Write("YES");
else
Console.Write("NO");
}}
// This code is contributed by shivanisinghss2110 // This code is modified by Susobhan Akhuli
JavaScript
`
**Time Complexity: O(N*K) where N is the number of elements in the array and K is total sum.
**Auxiliary Space: O(K), since K extra space has been taken.