Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Sum of subsets of all the subsets of an array | O(3^N)

  • Difficulty Level : Medium
  • Last Updated : 14 May, 2021

Given an array arr[] of length N, the task is to find the overall sum of subsets of all the subsets of the array.
Examples: 
 

Input: arr[] = {1, 1} 
Output: 6 
All possible subsets: 
a) {} : 0 
All the possible subsets of this subset 
will be {}, Sum = 0 
b) {1} : 1 
All the possible subsets of this subset 
will be {} and {1}, Sum = 0 + 1 = 1 
c) {1} : 1 
All the possible subsets of this subset 
will be {} and {1}, Sum = 0 + 1 = 1 
d) {1, 1} : 4 
All the possible subsets of this subset 
will be {}, {1}, {1} and {1, 1}, Sum = 0 + 1 + 1 + 2 = 4 
Thus, ans = 0 + 1 + 1 + 4 = 6
Input: arr[] = {1, 4, 2, 12} 
Output: 513 
 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

 

Approach: In this article, an approach with O(3N) time complexity to solve the given problem will be discussed. 
First, generate all the possible subsets of the array. There will be 2N subsets in total. Then for each subset, find the sum of all of its subset. 
Now, let’s understand the time-complexity of this solution. 
There are NCk subsets of length K and time to find the subsets of an array of length K is 2K. 
Total time = (NC1 * 21) + (NC2 * 22) + … + (NCk * K) = 3K
Below is the implementation of the above approach: 
 

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to sum of all subsets of a
// given array
void subsetSum(vector<int>& c, int i,
               int& ans, int curr)
{
    // Base case
    if (i == c.size()) {
        ans += curr;
        return;
    }
 
    // Recursively calling subsetSum
    subsetSum(c, i + 1, ans, curr + c[i]);
    subsetSum(c, i + 1, ans, curr);
}
 
// Function to generate the subsets
void subsetGen(int* arr, int i, int n,
               int& ans, vector<int>& c)
{
    // Base-case
    if (i == n) {
 
        // Finding the sum of all the subsets
        // of the generated subset
        subsetSum(c, 0, ans, 0);
        return;
    }
 
    // Recursively accepting and rejecting
    // the current number
    subsetGen(arr, i + 1, n, ans, c);
    c.push_back(arr[i]);
    subsetGen(arr, i + 1, n, ans, c);
    c.pop_back();
}
 
// Driver code
int main()
{
    int arr[] = { 1, 1 };
    int n = sizeof(arr) / sizeof(int);
 
    // To store the final ans
    int ans = 0;
    vector<int> c;
 
    subsetGen(arr, 0, n, ans, c);
    cout << ans;
 
    return 0;
}
Java



// Java implementation of the approach
import java.util.*;
 
class GFG
{
    static Vector<Integer> c = new Vector<>();
 
    // To store the final ans
    static int ans = 0;
 
    // Function to sum of all subsets of a
    // given array
    static void subsetSum(int i, int curr)
    {
 
        // Base case
        if (i == c.size())
        {
            ans += curr;
            return;
        }
 
        // Recursively calling subsetSum
        subsetSum(i + 1, curr + c.elementAt(i));
        subsetSum(i + 1, curr);
    }
 
    // Function to generate the subsets
    static void subsetGen(int[] arr, int i, int n)
    {
 
        // Base-case
        if (i == n)
        {
 
            // Finding the sum of all the subsets
            // of the generated subset
            subsetSum(0, 0);
            return;
        }
 
        // Recursively accepting and rejecting
        // the current number
        subsetGen(arr, i + 1, n);
        c.add(arr[i]);
        subsetGen(arr, i + 1, n);
        c.remove(c.size() - 1);
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int[] arr = { 1, 1 };
        int n = arr.length;
 
        subsetGen(arr, 0, n);
        System.out.println(ans);
    }
}
 
// This code is contributed by
// sanjeev2552
Python3



# Python3 implementation of the approach
 
# Function to sum of all subsets
# of a given array
c = []
ans = 0
 
def subsetSum(i, curr):
    global ans, c
     
    # Base case
    if (i == len(c)):
        ans += curr
        return
 
    # Recursively calling subsetSum
    subsetSum(i + 1, curr + c[i])
    subsetSum(i + 1, curr)
 
# Function to generate the subsets
def subsetGen(arr, i, n):
    global ans, c
     
    # Base-case
    if (i == n):
 
        # Finding the sum of all the subsets
        # of the generated subset
        subsetSum(0, 0)
        return
 
    # Recursively accepting and rejecting
    # the current number
    subsetGen(arr, i + 1, n)
    c.append(arr[i])
    subsetGen(arr, i + 1, n)
    del c[-1]
 
# Driver code
arr = [1, 1]
n = len(arr)
 
subsetGen(arr, 0, n)
 
print(ans)
 
# This code is contributed by Mohit Kumar
C#



// C# implementation of the approach
using System;
using System.Collections.Generic;
 
class GFG
{
    static List<int> c = new List<int>();
 
    // To store the readonly ans
    static int ans = 0;
 
    // Function to sum of all subsets of a
    // given array
    static void subsetSum(int i, int curr)
    {
 
        // Base case
        if (i == c.Count)
        {
            ans += curr;
            return;
        }
 
        // Recursively calling subsetSum
        subsetSum(i + 1, curr + c[i]);
        subsetSum(i + 1, curr);
    }
 
    // Function to generate the subsets
    static void subsetGen(int[] arr, int i, int n)
    {
 
        // Base-case
        if (i == n)
        {
 
            // Finding the sum of all the subsets
            // of the generated subset
            subsetSum(0, 0);
            return;
        }
 
        // Recursively accepting and rejecting
        // the current number
        subsetGen(arr, i + 1, n);
        c.Add(arr[i]);
        subsetGen(arr, i + 1, n);
        c.RemoveAt(c.Count - 1);
    }
 
    // Driver Code
    public static void Main(String[] args)
    {
        int[] arr = { 1, 1 };
        int n = arr.Length;
 
        subsetGen(arr, 0, n);
        Console.WriteLine(ans);
    }
}
 
// This code is contributed by Rajput-Ji
Javascript



<script>
 
// Javascript implementation of the approach
 
var ans = 0;
 
var c = [];
 
// Function to sum of all subsets of a
// given array
function subsetSum(i, curr)
{
    // Base case
    if (i == c.length) {
        ans += curr;
        return;
    }
 
    // Recursively calling subsetSum
    subsetSum( i + 1, curr + c[i]);
    subsetSum(i + 1, curr);
}
 
// Function to generate the subsets
function subsetGen(arr, i, n, ans)
{
    // Base-case
    if (i == n) {
 
        // Finding the sum of all the subsets
        // of the generated subset
        subsetSum(0, ans, 0);
        return;
    }
 
    // Recursively accepting and rejecting
    // the current number
    subsetGen(arr, i + 1, n, ans);
    c.push(arr[i]);
    subsetGen(arr, i + 1, n, ans);
    c.pop();
}
 
// Driver code
var arr = [1, 1 ];
var n = arr.length;
// To store the final ans
var ans = 0;
var c = [];
subsetGen(arr, 0, n, ans);
document.write( ans);
 
</script>
Output: 
6
 



My Personal Notes
arrow_drop_up
Previous
Minimize insertions in an array to obtain all sums upto N
Next

Sum of subsets of all the subsets of an array | O(2^N)
Recommended Articles
Page :
Sum of subsets of all the subsets of an array | O(2^N)
31, Oct 19
Sum of subsets of all the subsets of an array | O(N)
31, Oct 19
Divide array in two Subsets such that sum of square of sum of both subsets is maximum
07, Feb 20
Split array into minimum number of subsets such that elements of all pairs are present in different subsets at least once
04, Jan 21
Maximum number of subsets an array can be split into such that product of their minimums with size of subsets is at least K
21, Apr 21
Partition an array of non-negative integers into two subsets such that average of both the subsets is equal
11, Jul 19
Sum of all subsets whose sum is a Perfect Number from a given array
25, Feb 21
Rearrange an Array such that Sum of same-indexed subsets differ from their Sum in the original Array
31, Jul 20
Perfect Sum Problem (Print all subsets with given sum)
15, Apr 17
Sum of sum of all subsets of a set formed by first N natural numbers
22, Aug 18
Subset array sum by generating all the subsets
24, Oct 18
Sum of (maximum element - minimum element) for all the subsets of an array.
07, Mar 19
Sum of squares of all Subsets of given Array
23, Sep 19
Sum of values of all possible non-empty subsets of the given array
11, Oct 19
Sum of cubes of all Subsets of given Array
24, Mar 20
Sum of products of all possible K size subsets of the given array
26, Nov 19
Sum of length of two smallest subsets possible from a given array with sum at least K
10, Mar 21
Count of subsets with sum one less than the sum of Array
11, Nov 21
Split an Array A[] into Subsets having equal Sum and sizes equal to elements of Array B[]
21, Aug 20
Sum of maximum elements of all subsets
06, Dec 16
Sum of average of all subsets
14, Dec 16
Sum of the products of all possible Subsets
18, Feb 17
Sum of XOR of all possible subsets
02, Mar 17
Sum of all subsets of a set formed by first n natural numbers
07, Oct 17
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
DivyanshuShekhar1
@DivyanshuShekhar1
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!