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 <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(2ⁿ), 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)