Generate all distinct subsequences of array using backtracking

• Difficulty Level : Hard
• Last Updated : 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:

1. Sort the given array.
2. Initialize a vector of vectors to store all distinct subsequences.
3. Traverse the array and considering two choices for each array element, to include it in a subsequence or not to include it.
4. 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.
5. After generating the subsequences, remove the current array element.

Below is the implementation of the above approach:

C++

 // C++ program to implement// the above approach #include using namespace std; // Function to generate all distinct// subsequences of the array using backtrackingvoid backtrack(vector& nums, int start,               vector >& resultset,               vector 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 > AllSubsets(    vector nums){    // Stores the subsequences    vector > resultset;     // Stores the current    // subsequence    vector 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 > 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 v{ 1, 2, 2 };     // Function call    vector > result        = AllSubsets(v);     // Print function    print(result);     return 0;}

Java

 // 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 nums,                             int start,                             ArrayList 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 nums){     // Stores the current    // subsequence    ArrayList 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 v = new ArrayList<>();    v.add(1);    v.add(2);    v.add(2);         // Function call    AllSubsets(v);}} // This code is contributed by hemanthswarna1506

Python3

 # 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#

 // 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 nums,                             int start,                             List 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 nums){  // Stores the current  // subsequence  List curr_set = new List();   // Sort the vector  nums.Sort();   // Backtrack function to  // generate subsequences  backtrack(nums, 0, curr_set);} // Driver Codepublic static void Main(String[] args){  List v = new List();  v.Add(1);  v.Add(2);  v.Add(2);   // Function call  AllSubsets(v);}} // This code is contributed by 29AjayKumar

Javascript


Output
{} {1} {1, 2} {1, 2, 2} {2} {2, 2}

Time Complexity: O(2N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up