 GFG App
Open App Browser
Continue

# Subset Sum Problem in O(sum) space

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
{4, 5} is a subset with sum 9.

Input : arr[] = {1, 8, 2, 5},
sum = 4
Output : FALSE
There exists no subset with sum 4.```

We have discussed a Dynamic Programming based solution in below post.
Dynamic Programming | Set 25 (Subset Sum Problem)
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[sum+1]. Using bottom-up manner we can fill up this table. The idea behind using 2 in “subset[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.

## C++

 `// Returns true if there exists a subset` `// with given sum in arr[]` `#include ` `using` `namespace` `std;`   `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[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);` `    ``if` `(isSubsetSum(arr, n, sum) == ``true``)` `        ``cout <<``"There exists a subset with given sum"``;` `    ``else` `        ``cout <<``"No subset exists with given sum"``;` `    ``return` `0;` `}`   `// This code is contributed by shivanisinghss2110`

## C

 `// Returns true if there exists a subset` `// with given sum in arr[]` `#include ` `#include `   `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[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);` `    ``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 `

## PHP

 ``

## Javascript

 ``

Output

`There exists a subset with given sum`

Another Approach: 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.

Here’s the code for the given approach:

## C++

 `#include ` `using` `namespace` `std;`   `bool` `isPossible(``int` `elements[], ``int` `sum, ``int` `n)` `{` `    ``int` `dp[sum + 1];` `    `  `    ``// Initializing with 1 as sum 0 is ` `    ``// always possible` `    ``dp = 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);` `    ``int` `sum = 7;` `    `  `    ``if` `(isPossible(elements, sum, n))` `        ``cout << (``"YES"``);` `    ``else` `        ``cout << (``"NO"``);`   `    ``return` `0;` `}`   `// This code is contributed by Potta Lokesh`

## Java

 `import` `java.io.*;` `import` `java.util.*;` `class` `GFG {` `    ``static` `boolean` `isPossible(``int` `elements[], ``int` `sum)` `    ``{` `        ``int` `dp[] = ``new` `int``[sum + ``1``];` `        ``// 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"``);` `    ``}` `}`

## Python3

 `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];` `      `  `        ``// initializing with 1 as sum 0 is always possible` `        ``dp = 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`

## Javascript

 ``

Output

`YES`

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.

This article is contributed by Neelesh (Neelesh_Sinha). If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.