 Open in App
Not now

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

• Last Updated : 23 Nov, 2021

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