Backtracking to find all subsets

Given a set of positive integers, find all its subsets.
Examples:

Input: array = {1, 2, 3}
Output: // this space denotes null element. 
         1
         1 2
         1 2 3
         1 3
         2
         2 3
         3
Explanation: These are all the subsets that 
can be formed using the array.

Input: 1 2
Output: 
         1 
         2
         1 2
Explanation: These are all the subsets that 
can be formed using the array.

The iterative solution is already discussed here: iterative approach to find all subsets. This article aims to provide a backtracking approach.

Approach: The idea is simple, that if there are n number of elements inside an array, there are two choices for every element. Either include that element in the subset or do not include it.
Using the above idea form a recursive solution to the problem.



Algorithm:

  1. Create a recursive function that takes the following parameters, input array, the current index, the output array or current subset, if all the subsets needs to be stored then a vector of array is needed, if the subsets need to be printed only then this space can be ignored.
  2. if the current index is equal to the size of the array, then print the subset or ouput array or insert the output array into the vector of arrays (or vectors) and return.
  3. There are exactly two choices for very index.
  4. Ignore the current element and call the recursive function with the current subset and next index, i.e i + 1.
  5. Insert the current element in the subset and call the recursive function with the current subset and next index, i.e i + 1.

Implementation:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP program to find all subsets by backtracking.
#include <bits/stdc++.h>
using namespace std;
  
// In the array A at every step we have two
// choices for each element either  we can
// ignore the element or we can include the
// element in our subset
void subsetsUtil(vector<int>& A, vector<vector<int> >& res,
                 vector<int>& subset, int index)
{
    res.push_back(subset);
    for (int i = index; i < A.size(); i++) {
  
        // include the A[i] in subset.
        subset.push_back(A[i]);
  
        // move onto the next element.
        subsetsUtil(A, res, subset, i + 1);
  
        // exclude the A[i] from subset and triggers
        // backtracking.
        subset.pop_back();
    }
  
    return;
}
  
// below function returns the subsets of vector A.
vector<vector<int> > subsets(vector<int>& A)
{
    vector<int> subset;
    vector<vector<int> > res;
  
    // keeps track of current element in vector A;
    int index = 0;
    subsetsUtil(A, res, subset, index);
  
    return res;
}
  
// Driver Code.
int main()
{
    // find the subsets of below vector.
    vector<int> array = { 1, 2, 3 };
  
    // res will store all subsets.
    // O(2 ^ (number of elements inside array))
    // because at every step we have two choices
    // either include or ignore.
    vector<vector<int> > res = subsets(array);
  
    // Print result
    for (int i = 0; i < res.size(); i++) {
        for (int j = 0; j < res[i].size(); j++)
            cout << res[i][j] << " ";
        cout << endl;
    }
  
    return 0;
}

chevron_right






                        filter_none









Python3














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















# Python3 program to find all subsets 


# by backtracking.  


  


# In the array A at every step we have two  


# choices for each element either we can  


# ignore the element or we can include the  


# element in our subset  


def subsetsUtil(A, subset, index): 


    print(*subset) 


    for i in range(index, len(A)):  


          


        # include the A[i] in subset.  


        subset.append(A[i]) 


          


        # move onto the next element.  


        subsetsUtil(A, subset, i + 1)  


          


        # exclude the A[i] from subset and  


        # triggers backtracking. 


        subset.pop(-1)  


    return


  


# below function returns the subsets of vector A.  


def subsets(A): 


    global res 


    subset = [] 


      


    # keeps track of current element in vector A  


    index = 0


    subsetsUtil(A, subset, index)  


      


# Driver Code 


  


# find the subsets of below vector.  


array = [1, 2, 3] 


  


# res will store all subsets.  


# O(2 ^ (number of elements inside array))  


# because at every step we have two choices  


# either include or ignore.  


subsets(array)  


  


# This code is contributed by SHUBHAMSINGH8410 



















                        chevron_right







                        filter_none










Output:



1 
1 2 
1 2 3 
1 3 
2 
2 3 
3 



Complexity Analysis:


    

  • Time Complexity: O(2 ^ n).
    
For every index i two recursive case originates, So Time Complexity is O(2^n).
    • 

  • Space Complexity: O(n).
    
The space complexity can be reduced if the output array is not stored and the static and global variable is used to store the output string.
    • 





GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details 





    

        My Personal Notes
        arrow_drop_up
    

    

        
        

            
            
        

    


Recommended Posts:
arshpreet soodan
Check out this Author's contributed articles.
If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please Improve this article if you find anything incorrect by clicking on  the "Improve Article" button below.