Backtracking to find all subsets - GeeksforGeeks

10 Feb, 2022
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: the 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 forms a recursive solution to the problem.Algorithm:  
Create a recursive function that takes the following parameters, input array, the current index, the output array, or current subset, if all the subsets need to be stored then a vector of the array is needed if the subsets need to be printed only then this space can be ignored.if the current index is equal to the size of the array, then print the subset or output array or insert the output array into the vector of arrays (or vectors) and return.There are exactly two choices for very index.Ignore the current element and call the recursive function with the current subset and next index, i.e i + 1.Insert the current element in the subset and call the recursive function with the current subset and next index, i.e i + 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 need to be stored then a vector of the array is needed if the subsets need to be printed only then this space can be ignored.
if the current index is equal to the size of the array, then print the subset or output array or insert the output array into the vector of arrays (or vectors) and return.
There are exactly two choices for very index.
Ignore the current element and call the recursive function with the current subset and next index, i.e i + 1.
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++
Java
Python3
C#
Javascript
// 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 subsetvoid 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;}
/*package whatever //do not write package name here */ import java.io.*;import java.util.*;class GFG {    public static void    findSubsets(List<List<Integer>> subset, ArrayList<Integer> nums, ArrayList<Integer> output, int index)    {      // Base Condition        if (index == nums.size()) {            subset.add(output);            return;        }               // Not Including Value which is at Index        findSubsets(subset, nums, new ArrayList<>(output), index + 1);         // Including Value which is at Index        output.add(nums.get(index));        findSubsets(subset, nums, new ArrayList<>(output), index + 1);    }     public static void main(String[] args) {             //Main List for storing all subsets      List<List<Integer>> subset = new ArrayList<>();             // Input ArrayList      ArrayList<Integer> input = new ArrayList<>();      input.add(1);      input.add(2);      input.add(3);             findSubsets(subset, input, new ArrayList<>(), 0);       // Comparator is used so that all subset get      // sorted in ascending order of values        Collections.sort(subset, (o1, o2) -> {            int n = Math.min(o1.size(), o2.size());            for (int i = 0; i < n; i++) {                if (o1.get(i) == o2.get(i)){                    continue;                }else{                    return o1.get(i) - o2.get(i);                }            }            return 1;        });                    // Printing Subset      for(int i = 0; i < subset.size(); i++){          for(int j = 0; j < subset.get(i).size(); j++){              System.out.print(subset.get(i).get(j) + " ");          }          System.out.println();      }           }}
# 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 subsetdef 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
/*package whatever //do not write package name here */using System;using System.Collections.Generic; public class GFG {  public static void    findSubsets(List<List<int>> subset, List<int> nums, List<int> output, int index)  {    // Base Condition    if (index == nums.Count) {      subset.Add(output);      return;    }     // Not Including Value which is at Index    findSubsets(subset, nums, new List<int>(output), index + 1);     // Including Value which is at Index    output.Add(nums[index]);    findSubsets(subset, nums, new List<int>(output), index + 1);  }   public static void Main(String[] args) {     // Main List for storing all subsets    List<List<int>> subset = new List<List<int>>();     // Input List    List<int> input = new List<int>();    input.Add(1);    input.Add(2);    input.Add(3);     findSubsets(subset, input, new List<int>(), 0);     // Comparator is used so that all subset get    // sorted in ascending order of values    subset.Sort((o1, o2) => {      int n = Math.Min(o1.Count, o2.Count);      for (int i = 0; i < n; i++) {        if (o1[i] == o2[i]){          continue;        }else{          return o1[i] - o2[i];        }      }      return 1;    });     // Printing Subset    for(int i = 0; i < subset.Count; i++){      for(int j = 0; j < subset[i].Count; j++){        Console.Write(subset[i][j] + " ");      }      Console.WriteLine();    }   }} // This code is contributed by shikhasingrajput
<script>/*package whatever //do not write package name here */function findSubsets(subset, nums, output, index){     // Base Condition    if (index == nums.length) {        subset.push(output);        return;    }     // Not Including Value which is at Index    findSubsets(subset, nums, [...output], index + 1);     // Including Value which is at Index    output.push(nums[index]);    findSubsets(subset, nums, [...output], index + 1);} // Main List for storing all subsetslet subset = []; // Input ArrayListlet input = [];input.push(1);input.push(2);input.push(3); findSubsets(subset, input, [], 0); // Comparator is used so that all subset get// sorted in ascending order of valuessubset.sort((o1, o2) => {    let n = Math.min(o1.length, o2.length);    for (let i = 0; i < n; i++) {        if (o1[i] == o2[i]) {            continue;        } else {            return o1[i] - o2[i];        }    }    return 1;}); // Printing Subsetfor (let i = 0; i < subset.length; i++) {    for (let j = 0; j < subset[i].length; j++) {        document.write(subset[i][j] + " ");    }    document.write("<br>");} // This code is contributed by saurabh_jaiswal.</script>
1 
1 2 
1 2 3 
1 3 
2 
2 3 
3 
Complexity Analysis:  
Time Complexity: O(n(2 ^ n)). For every index i two recursive cases originate, So Time Complexity is O(2^n). If we include the time taken to copy the subset vector into the res vector the time taken will be equal to the size of the subset vector.
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.
 
AbdulWadood
SHUBHAMSINGH10
andrew1234
Akanksha_Rai
srivastavaharshit333
vaibhavpatel1904
_saurabh_jaiswal
shikhasingrajput
subset
Arrays
Backtracking
Arrays
subset
Backtracking
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Top 50 Array Coding Problems for Interviews
Multidimensional Arrays in Java
Introduction to Arrays
Linear Search
Maximum and minimum of an array using minimum number of comparisons
N Queen Problem | Backtracking-3
Given an array A[] and a number x, check for pair in A[] with sum as x (aka Two Sum)
Rat in a Maze | Backtracking-2
Backtracking | Introduction
Sudoku | Backtracking-7