Generate all distinct subsequences of array using backtracking - GeeksforGeeks

06 Oct, 2021
Given an array arr[] consisting of N positive integers, the task is to generate all distinct subsequences of the array.
Examples:
Input: arr[] = {1, 2, 2}Output: {} {1} {1, 2} {1, 2, 2} {2} {2, 2}Explanation:The total subsequences of the given array are {}, {1}, {2}, {2}, {1, 2}, {1, 2}, {2, 2}, {1, 2, 2}.Since {2} and {1, 2} are repeated twice, print all the remaining subsequences of the array.
Input: arr[] = {1, 2, 3, 3}Output: {} {1} {1, 2} {1, 2, 3} {1, 2, 3, 3} {1, 3} {1, 3, 3} {2} {2, 3} {2, 3, 3} {3} {3, 3}
Approach: Follow the steps below to solve the problem:
Sort the given array.Initialize a vector of vectors to store all distinct subsequences.Traverse the array and considering two choices for each array element, to include it in a subsequence or not to include it.If duplicates are found, ignore them and check for the remaining elements. Otherwise, add the current array element to the current subsequence and traverse the remaining elements to generate subsequences.After generating the subsequences, remove the current array element.
Sort the given array.
Initialize a vector of vectors to store all distinct subsequences.
Traverse the array and considering two choices for each array element, to include it in a subsequence or not to include it.
If duplicates are found, ignore them and check for the remaining elements. Otherwise, add the current array element to the current subsequence and traverse the remaining elements to generate subsequences.
After generating the subsequences, remove the current array element.
Below is the implementation of the above approach:
C++
Java
Python3
C#
Javascript
// C++ program to implement// the above approach #include <bits/stdc++.h>using namespace std; // Function to generate all distinct// subsequences of the array using backtrackingvoid backtrack(vector<int>& nums, int start,               vector<vector<int> >& resultset,               vector<int> curr_set){    resultset.push_back(curr_set);     for (int i = start; i < nums.size(); i++) {         // If the current element is repeating        if (i > start            && nums[i] == nums[i - 1]) {            continue;        }         // Include current element        // into the subsequence        curr_set.push_back(nums[i]);         // Proceed to the remaining array        // to generate subsequences        // including current array element        backtrack(nums, i + 1, resultset,                  curr_set);         // Remove current element        // from the subsequence        curr_set.pop_back();    }} // Function to sort the array and generate// subsequences using Backtrackingvector<vector<int> > AllSubsets(    vector<int> nums){    // Stores the subsequences    vector<vector<int> > resultset;     // Stores the current    // subsequence    vector<int> curr_set;     // Sort the vector    sort(nums.begin(), nums.end());     // Backtrack function to    // generate subsequences    backtrack(nums, 0, resultset,              curr_set);     // Return the result    return resultset;} // Function to print all subsequencesvoid print(vector<vector<int> > result){    for (int i = 0; i < result.size();         i++) {         cout << "{";        for (int j = 0; j < result[i].size();             j++) {             cout << result[i][j];            if (j < result[i].size() - 1) {                 cout << ", ";            }        }        cout << "} ";    }} // Driver Codeint main(){    vector<int> v{ 1, 2, 2 };     // Function call    vector<vector<int> > result        = AllSubsets(v);     // Print function    print(result);     return 0;}
// Java program to implement// the above approachimport java.io.*;import java.util.*; class GFG{     // Function to generate all distinct// subsequences of the array using backtrackingpublic static void backtrack(ArrayList<Integer> nums,                             int start,                             ArrayList<Integer> curr_set){    System.out.print(curr_set + " ");     for(int i = start; i < nums.size(); i++)    {                 // If the current element is repeating        if (i > start &&            nums.get(i) == nums.get(i - 1))        {            continue;        }         // Include current element        // into the subsequence        curr_set.add(nums.get(i));         // Proceed to the remaining array        // to generate subsequences        // including current array element        backtrack(nums, i + 1, curr_set);         // Remove current element        // from the subsequence        curr_set.remove(curr_set.size() - 1);    }} // Function to sort the array and generate// subsequences using Backtrackingpublic static void AllSubsets(ArrayList<Integer> nums){     // Stores the current    // subsequence    ArrayList<Integer> curr_set = new ArrayList<>();     // Sort the vector    Collections.sort(nums);     // Backtrack function to    // generate subsequences    backtrack(nums, 0, curr_set);} // Driver Codepublic static void main(String[] args){    ArrayList<Integer> v = new ArrayList<>();    v.add(1);    v.add(2);    v.add(2);         // Function call    AllSubsets(v);}} // This code is contributed by hemanthswarna1506
# Python3 program to implement# the above approachresult = []  # Function to generate all distinct# subsequences of the array# using backtrackingdef backtrack(nums, start, curr_set):         # Global result    result.append(list(curr_set))         for i in range(start, len(nums)):                 # If the current element is repeating        if (i > start and nums[i] == nums[i - 1]):            continue                 # Include current element        # into the subsequence        curr_set.append(nums[i])          # Proceed to the remaining array        # to generate subsequences        # including current array element        backtrack(nums, i + 1, curr_set)          # Remove current element        # from the subsequence        curr_set.pop()     # Function to sort the array and generate# subsequences using Backtrackingdef AllSubsets(nums):     # Stores the current    # subsequence    curr_set = []         # Sort the vector    nums.sort()         # Backtrack function to    # generate subsequences    backtrack(nums, 0, curr_set)     # Function to prints all subsequencesdef prints():         global result     for i in range(len(result)):        print('{', end = '')                 for j in range(len(result[i])):            print(result[i][j], end = '')             if (j < len(result[i]) - 1):                print(',', end = ' ')                         print('} ', end = '')         # Driver Codeif __name__=='__main__':         v = [ 1, 2, 2 ]          # Function call    AllSubsets(v)      # Print function    prints() # This code is contributed by rutvik_56
// C# program to implement// the above approachusing System;using System.Collections.Generic;class GFG{     // Function to generate all distinct// subsequences of the array using// backtrackingpublic static void backtrack(List<int> nums,                             int start,                             List<int> curr_set){  Console.Write(" {");     foreach(int i in curr_set)  {    Console.Write(i);    Console.Write(", ");  }   Console.Write("}");     for(int i = start;          i < nums.Count; i++)  {    // If the current element    // is repeating    if (i > start &&        nums[i] == nums[i - 1])    {      continue;    }     // Include current element    // into the subsequence    curr_set.Add(nums[i]);     // Proceed to the remaining array    // to generate subsequences    // including current array element    backtrack(nums, i + 1, curr_set);     // Remove current element    // from the subsequence    curr_set.Remove(curr_set.Count - 1);  }} // Function to sort the array and generate// subsequences using Backtrackingpublic static void AllSubsets(List<int> nums){  // Stores the current  // subsequence  List<int> curr_set = new List<int>();   // Sort the vector  nums.Sort();   // Backtrack function to  // generate subsequences  backtrack(nums, 0, curr_set);} // Driver Codepublic static void Main(String[] args){  List<int> v = new List<int>();  v.Add(1);  v.Add(2);  v.Add(2);   // Function call  AllSubsets(v);}} // This code is contributed by 29AjayKumar
<script>    // Javascript program to implement the above approach         // Function to generate all distinct    // subsequences of the array using    // backtracking    function backtrack(nums, start, curr_set)    {      document.write(" {");       for(let i = 0; i < curr_set.length - 1; i++)      {        document.write(curr_set[i]);        document.write(", ");      }             if(curr_set.length >= 1)      {          document.write(curr_set[curr_set.length - 1]);          document.write("}");      }      else      {          document.write("}");      }              for(let i = start; i < nums.length; i++)      {        // If the current element        // is repeating        if (i > start && nums[i] == nums[i - 1])        {          continue;        }         // Include current element        // into the subsequence        curr_set.push(nums[i]);         // Proceed to the remaining array        // to generate subsequences        // including current array element        backtrack(nums, i + 1, curr_set);         // Remove current element        // from the subsequence        curr_set.pop();      }    }     // Function to sort the array and generate    // subsequences using Backtracking    function AllSubsets(nums)    {      // Stores the current      // subsequence      let curr_set = [];       // Sort the vector      nums.sort();       // Backtrack function to      // generate subsequences      backtrack(nums, 0, curr_set);    }         let v = [];    v.push(1);    v.push(2);    v.push(2);     // Function call    AllSubsets(v); // This code is contributed by mukesh07.</script>
{} {1} {1, 2} {1, 2, 2} {2} {2, 2}
Time Complexity: O(2N)Auxiliary Space: O(N)
hemanthswarna1506
29AjayKumar
rutvik_56
mukesh07
subsequence
Arrays
Backtracking
Combinatorial
Recursion
Sorting
Arrays
Recursion
Sorting
Combinatorial
Backtracking
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Maximum and minimum of an array using minimum number of comparisons
Top 50 Array Coding Problems for Interviews
Stack Data Structure (Introduction and Program)
Introduction to Arrays
Multidimensional Arrays in Java
N Queen Problem | Backtracking-3
Write a program to print all permutations of a given string
Backtracking | Introduction
Rat in a Maze | Backtracking-2
The Knight's tour problem | Backtracking-1