 GFG App
Open App Browser
Continue

# Count of subsets with sum one less than the sum of Array

Given an array arr[ ] of size N. The task is to find the no of subsets with sum as (sum of the array – 1) when 0 occurs in an array or return -1 if there is no subset possible.

Examples:

Input: arr[ ] : {3, 0, 5, 2, 4}
Output: -1
Explanation: sum of array arr[ ] is 14 and there is not any subset with sum 13.
Input: arr[ ] : {0, 0, 2, 1}
Output: 4
Explanation: sum of array arr[ ]  is 3 and {0, 2}, {0, 2}, {0, 0, 2}, {2} are the four subsets with sum 2 .

Naive Approach: The task can be solved by generating all possible subsets of the array using recursion, and increment the count if a subset with sum as (sum of the array – 1) is encountered.
Below is the implementation of the above approach:

## C++

 `// C++ program to print the count of` `// subsets with sum equal to the given value X`   `#include ` `using` `namespace` `std;`   `// Recursive function to return the count` `// of subsets with sum equal to the given value` `int` `subsetSum(``int` `arr[], ``int` `n, ``int` `i,` `              ``int` `sum, ``int` `count)` `{` `    ``// The recursion is stopped at N-th level` `    ``// where all the subsets of the given array` `    ``// have been checked` `    ``if` `(i == n) {`   `        ``// Incrementing the count if sum is` `        ``// equal to 0 and returning the count` `        ``if` `(sum == 0) {` `            ``count++;` `        ``}` `        ``return` `count;` `    ``}`   `    ``// Recursively calling the` `    ``// function for two cases` `    ``// Either the element can be` `    ``// counted in the subset` `    ``// If the element is counted,` `    ``// then the remaining sum` `    ``// to be checked is` `    ``// sum - the selected element` `    ``// If the element is not included,` `    ``// then the remaining sum` `    ``// to be checked is the total sum` `    ``count = subsetSum(arr, n, i + 1,` `                      ``sum - arr[i], count);` `    ``count = subsetSum(arr, n, i + 1,` `                      ``sum, count);` `    ``return` `count == 0 ? -1 : count;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `arr[] = { 0, 0, 2, 1 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);`   `    ``// Sum of array - 1` `    ``int` `sum = accumulate(arr, arr + n, 0) - 1;` `    ``cout << subsetSum(arr, n, 0, sum, 0);` `}`

## Java

 `// Java program to print the count of` `// subsets with sum equal to the given value X`   `public` `class` `GFG {` `    `  `    ``// Recursive function to return the count` `    ``// of subsets with sum equal to the given value` `    ``static` `int` `subsetSum(``int` `arr[], ``int` `n, ``int` `i,` `                  ``int` `sum, ``int` `count)` `    ``{` `        ``// The recursion is stopped at N-th level` `        ``// where all the subsets of the given array` `        ``// have been checked` `        ``if` `(i == n) {` `    `  `            ``// Incrementing the count if sum is` `            ``// equal to 0 and returning the count` `            ``if` `(sum == ``0``) {` `                ``count++;` `            ``}` `            ``return` `count;` `        ``}` `    `  `        ``// Recursively calling the` `        ``// function for two cases` `        ``// Either the element can be` `        ``// counted in the subset` `        ``// If the element is counted,` `        ``// then the remaining sum` `        ``// to be checked is` `        ``// sum - the selected element` `        ``// If the element is not included,` `        ``// then the remaining sum` `        ``// to be checked is the total sum` `        ``count = subsetSum(arr, n, i + ``1``,` `                          ``sum - arr[i], count);` `        ``count = subsetSum(arr, n, i + ``1``,` `                          ``sum, count);` `        ``return` `count == ``0` `? -``1` `: count;` `    ``}` `    `  `    ``static` `int` `accumulate(``int` `[]arr)` `    ``{` `        ``int` `sum = ``0``;` `        ``for``(``int` `i = ``0``; i < arr.length; i++)` `            ``sum += arr[i];` `            `  `        ``return` `sum;` `    ``}` `    `  `    ``// Driver code` `    ``public` `static` `void` `main (String[] args)` `    ``{` `        ``int` `arr[] = { ``0``, ``0``, ``2``, ``1` `};` `        ``int` `n = arr.length;` `    `  `        ``// Sum of array - 1` `        ``int` `sum = accumulate(arr) - ``1``;` `        `  `        ``System.out.println(subsetSum(arr, n, ``0``, sum, ``0``));` `    ``}` `}`   `// This code is contributed by AnkThon`

## Python3

 `# Python program to print the count of` `# subsets with sum equal to the given value X`   `# Recursive function to return the count` `# of subsets with sum equal to the given value` `def` `subsetSum(arr, n, i, ``sum``, count):`   `    ``# The recursion is stopped at N-th level` `    ``# where all the subsets of the given array` `    ``# have been checked` `    ``if` `(i ``=``=` `n):`   `        ``# Incrementing the count if sum is` `        ``# equal to 0 and returning the count` `        ``if` `(``sum` `=``=` `0``):` `            ``count ``+``=` `1` `        ``return` `count`   `    ``# Recursively calling the` `    ``# function for two cases` `    ``# Either the element can be` `    ``# counted in the subset` `    ``# If the element is counted,` `    ``# then the remaining sum` `    ``# to be checked is` `    ``# sum - the selected element` `    ``# If the element is not included,` `    ``# then the remaining sum` `    ``# to be checked is the total sum` `    ``count ``=` `subsetSum(arr, n, i ``+` `1``,` `                      ``sum` `-` `arr[i], count)` `    ``count ``=` `subsetSum(arr, n, i ``+` `1``,` `                      ``sum``, count)` `    ``return` `-` `1` `if` `count ``=``=` `0` `else` `count`     `def` `accumulate(arr):` `    ``sum` `=` `0` `    ``for` `i ``in` `range``(``len``(arr)):` `        ``sum` `+``=` `arr[i]` `    ``return` `sum`   `# Driver code` `arr ``=` `[``0``, ``0``, ``2``, ``1``]` `n ``=` `len``(arr)`   `# Sum of array - 1` `sum` `=` `accumulate(arr) ``-` `1` `print``(subsetSum(arr, n, ``0``, ``sum``, ``0``))`   `# This code is contributed by gfgking`

## C#

 `// C# program to print the count of` `// subsets with sum equal to the given value X`   `using` `System;`   `public` `class` `GFG {` `    `  `    ``// Recursive function to return the count` `    ``// of subsets with sum equal to the given value` `    ``static` `int` `subsetSum(``int` `[]arr, ``int` `n, ``int` `i,` `                ``int` `sum, ``int` `count)` `    ``{` `        ``// The recursion is stopped at N-th level` `        ``// where all the subsets of the given array` `        ``// have been checked` `        ``if` `(i == n) {` `    `  `            ``// Incrementing the count if sum is` `            ``// equal to 0 and returning the count` `            ``if` `(sum == 0) {` `                ``count++;` `            ``}` `            ``return` `count;` `        ``}` `    `  `        ``// Recursively calling the` `        ``// function for two cases` `        ``// Either the element can be` `        ``// counted in the subset` `        ``// If the element is counted,` `        ``// then the remaining sum` `        ``// to be checked is` `        ``// sum - the selected element` `        ``// If the element is not included,` `        ``// then the remaining sum` `        ``// to be checked is the total sum` `        ``count = subsetSum(arr, n, i + 1,` `                        ``sum - arr[i], count);` `        ``count = subsetSum(arr, n, i + 1,` `                        ``sum, count);` `        ``return` `count == 0 ? -1 : count;` `    ``}` `    `  `    ``static` `int` `accumulate(``int` `[]arr)` `    ``{` `        ``int` `sum = 0;` `        ``for``(``int` `i = 0; i < arr.Length; i++)` `            ``sum += arr[i];` `            `  `        ``return` `sum;` `    ``}` `    `  `    ``// Driver code` `    ``public` `static` `void` `Main (``string``[] args)` `    ``{` `        ``int` `[]arr = { 0, 0, 2, 1 };` `        ``int` `n = arr.Length;` `    `  `        ``// Sum of array - 1` `        ``int` `sum = accumulate(arr) - 1;` `        `  `        ``Console.WriteLine(subsetSum(arr, n, 0, sum, 0));` `    ``}` `}`   `// This code is contributed by AnkThon`

## Javascript

 ``

Output:

`4`

Time complexity: O(2n), where n = array length
Auxiliary Space: O(n), recursion stack space
Efficient Approach:  The above approach can be optimized by finding a possible subset with sum as (array_sum – 1) by removing 0s and one 1 from the array so that the subset-sum becomes equal to (sum of the array – 1 )

• If there are k zeroes in the array, then there are 2^k (k is the number of zeroes) ways to remove 0 from the array.
• The multiplication of these two (no of ways to remove 0 and no of ways to remove 1) results in the no of possible subsets.

Below is the implementation of the above code:

## C++

 `// C++ implementation of the above approach` `#include ` `using` `namespace` `std;`   `// Function to find the no of` `// possible subsets` `int` `subsetCount(``int` `arr[], ``int` `n)` `{` `    ``// Count the no of 0s and 1s` `    ``// in array` `    ``int` `zeros = 0, ones = 0;`   `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``if` `(arr[i] == 0) {` `            ``zeros++;` `        ``}` `        ``else` `if` `(arr[i] == 1) {` `            ``ones++;` `        ``}` `    ``}`   `    ``// Store no of ways to remove 0` `    ``int` `no_of_ways_0 = ``pow``(2, zeros);`   `    ``// Store no of ways to remove 1` `    ``int` `no_of_ways_1 = ones;`   `    ``// Store the total count of subsets` `    ``int` `count_subset = no_of_ways_0` `                       ``* no_of_ways_1;`   `    ``// If there is no subset possible` `    ``// with required sum, return -1` `    ``if` `(count_subset == 0)` `        ``return` `-1;` `    ``return` `count_subset;` `}`   `// Driver Code` `int` `main()` `{`   `    ``int` `arr[] = { 0, 0, 2, 1 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);` `    ``cout << subsetCount(arr, n);` `}`

## Java

 `// Java implementation of the above approach` `import` `java.util.*;` `public` `class` `GFG` `{` `// Function to find the no of` `// possible subsets` `static` `int` `subsetCount(``int` `[]arr, ``int` `n)` `{` `    ``// Count the no of 0s and 1s` `    ``// in array` `    ``int` `zeros = ``0``, ones = ``0``;`   `    ``for` `(``int` `i = ``0``; i < n; i++) {` `        ``if` `(arr[i] == ``0``) {` `            ``zeros++;` `        ``}` `        ``else` `if` `(arr[i] == ``1``) {` `            ``ones++;` `        ``}` `    ``}`   `    ``// Store no of ways to remove 0` `    ``int` `no_of_ways_0 = (``int``)Math.pow(``2``, zeros);`   `    ``// Store no of ways to remove 1` `    ``int` `no_of_ways_1 = ones;`   `    ``// Store the total count of subsets` `    ``int` `count_subset = no_of_ways_0` `                       ``* no_of_ways_1;`   `    ``// If there is no subset possible` `    ``// with required sum, return -1` `    ``if` `(count_subset == ``0``)` `        ``return` `-``1``;` `    ``return` `count_subset;` `}`   `// Driver Code` `public` `static` `void` `main(String args[])` `{`   `    ``int` `[]arr = { ``0``, ``0``, ``2``, ``1` `};` `    ``int` `n = arr.length;` `    ``System.out.println(subsetCount(arr, n));` `}` `}` `// This code is contributed by Samim Hossain Mondal.`

## Python3

 `# Python 3 implementation of the above approach`   `# Function to find the no of` `# possible subsets`     `def` `subsetCount(arr, n):`   `    ``# Count the no of 0s and 1s` `    ``# in array` `    ``zeros ``=` `0` `    ``ones ``=` `0`   `    ``for` `i ``in` `range``(n):` `        ``if` `(arr[i] ``=``=` `0``):` `            ``zeros ``+``=` `1`   `        ``elif` `(arr[i] ``=``=` `1``):` `            ``ones ``+``=` `1`   `    ``# Store no of ways to remove 0` `    ``no_of_ways_0 ``=` `pow``(``2``, zeros)`   `    ``# Store no of ways to remove 1` `    ``no_of_ways_1 ``=` `ones`   `    ``# Store the total count of subsets` `    ``count_subset ``=` `no_of_ways_0 ``*` `no_of_ways_1`   `    ``# If there is no subset possible` `    ``# with required sum, return -1` `    ``if` `(count_subset ``=``=` `0``):` `        ``return` `-``1` `    ``return` `count_subset`     `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:`   `    ``arr ``=` `[``0``, ``0``, ``2``, ``1``]` `    ``n ``=` `len``(arr)` `    ``print``(subsetCount(arr, n))`   `    ``# This code is contributed by ukasp.`

## C#

 `// C# implementation of the above approach` `using` `System;`   `class` `GFG` `{` `// Function to find the no of` `// possible subsets` `static` `int` `subsetCount(``int` `[]arr, ``int` `n)` `{` `    ``// Count the no of 0s and 1s` `    ``// in array` `    ``int` `zeros = 0, ones = 0;`   `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``if` `(arr[i] == 0) {` `            ``zeros++;` `        ``}` `        ``else` `if` `(arr[i] == 1) {` `            ``ones++;` `        ``}` `    ``}`   `    ``// Store no of ways to remove 0` `    ``int` `no_of_ways_0 = (``int``)Math.Pow(2, zeros);`   `    ``// Store no of ways to remove 1` `    ``int` `no_of_ways_1 = ones;`   `    ``// Store the total count of subsets` `    ``int` `count_subset = no_of_ways_0` `                    ``* no_of_ways_1;`   `    ``// If there is no subset possible` `    ``// with required sum, return -1` `    ``if` `(count_subset == 0)` `        ``return` `-1;` `    ``return` `count_subset;` `}`   `// Driver Code` `public` `static` `void` `Main()` `{`   `    ``int` `[]arr = { 0, 0, 2, 1 };` `    ``int` `n = arr.Length;` `    ``Console.Write(subsetCount(arr, n));` `}` `}`   `// This code is contributed by Samim Hossain Mondal.`

## Javascript

 ``

Output

`4`

Time complexity: O(n), where n = array length
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up