Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

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 <bits/stdc++.h>
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[0]);
 
    // 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




<script>
        // JavaScript 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
        function 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++;
                }
                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;
        }
 
        function accumulate(arr) {
            let sum = 0;
            for (let i = 0; i < arr.length; i++) {
                sum += arr[i];
            }
            return sum;
        }
         
        // Driver code
 
        let arr = [0, 0, 2, 1];
        let n = arr.length;
 
        // Sum of array - 1
        let sum = accumulate(arr) - 1;
        document.write(subsetSum(arr, n, 0, sum, 0));
 
    // This code is contributed by Potta Lokesh
    </script>
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 <bits/stdc++.h>
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[0]);
    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




<script>
// Javascript implementation of the above approach
 
// Function to find the no of
// possible subsets
function subsetCount(arr, n)
{
    // Count the no of 0s and 1s
    // in array
    let zeros = 0, ones = 0;
 
    for (let i = 0; i < n; i++) {
        if (arr[i] == 0) {
            zeros++;
        }
        else if (arr[i] == 1) {
            ones++;
        }
    }
 
    // Store no of ways to remove 0
    let no_of_ways_0 = Math.pow(2, zeros);
 
    // Store no of ways to remove 1
    let no_of_ways_1 = ones;
 
    // Store the total count of subsets
    let 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
let arr = [ 0, 0, 2, 1 ];
let n = arr.length;
document.write(subsetCount(arr, n));
 
// This code is contributed by Samim Hossain Mondal.
</script>
Output
4

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




My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!