Generate all distinct subsequences of array using backtracking
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.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
void 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 (i > start
&& nums[i] == nums[i - 1]) {
continue ;
}
curr_set.push_back(nums[i]);
backtrack(nums, i + 1, resultset,
curr_set);
curr_set.pop_back();
}
}
vector<vector< int > > AllSubsets(
vector< int > nums)
{
vector<vector< int > > resultset;
vector< int > curr_set;
sort(nums.begin(), nums.end());
backtrack(nums, 0, resultset,
curr_set);
return resultset;
}
void 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 << "} " ;
}
}
int main()
{
vector< int > v{ 1, 2, 2 };
vector<vector< int > > result
= AllSubsets(v);
print(result);
return 0;
}
|
Java
import java.io.*;
import java.util.*;
class GFG{
public 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 (i > start &&
nums.get(i) == nums.get(i - 1 ))
{
continue ;
}
curr_set.add(nums.get(i));
backtrack(nums, i + 1 , curr_set);
curr_set.remove(curr_set.size() - 1 );
}
}
public static void AllSubsets(ArrayList<Integer> nums)
{
ArrayList<Integer> curr_set = new ArrayList<>();
Collections.sort(nums);
backtrack(nums, 0 , curr_set);
}
public static void main(String[] args)
{
ArrayList<Integer> v = new ArrayList<>();
v.add( 1 );
v.add( 2 );
v.add( 2 );
AllSubsets(v);
}
}
|
Python3
result = []
def backtrack(nums, start, curr_set):
result.append( list (curr_set))
for i in range (start, len (nums)):
if (i > start and nums[i] = = nums[i - 1 ]):
continue
curr_set.append(nums[i])
backtrack(nums, i + 1 , curr_set)
curr_set.pop()
def AllSubsets(nums):
curr_set = []
nums.sort()
backtrack(nums, 0 , curr_set)
def 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 = '')
if __name__ = = '__main__' :
v = [ 1 , 2 , 2 ]
AllSubsets(v)
prints()
|
C#
using System;
using System.Collections.Generic;
class GFG{
public 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 (i > start &&
nums[i] == nums[i - 1])
{
continue ;
}
curr_set.Add(nums[i]);
backtrack(nums, i + 1, curr_set);
curr_set.Remove(curr_set.Count - 1);
}
}
public static void AllSubsets(List< int > nums)
{
List< int > curr_set = new List< int >();
nums.Sort();
backtrack(nums, 0, curr_set);
}
public static void Main(String[] args)
{
List< int > v = new List< int >();
v.Add(1);
v.Add(2);
v.Add(2);
AllSubsets(v);
}
}
|
Javascript
<script>
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 (i > start && nums[i] == nums[i - 1])
{
continue ;
}
curr_set.push(nums[i]);
backtrack(nums, i + 1, curr_set);
curr_set.pop();
}
}
function AllSubsets(nums)
{
let curr_set = [];
nums.sort();
backtrack(nums, 0, curr_set);
}
let v = [];
v.push(1);
v.push(2);
v.push(2);
AllSubsets(v);
</script>
|
Output
{} {1} {1, 2} {1, 2, 2} {2} {2, 2}
Time Complexity: O(2N)
Auxiliary Space: O(N)
Last Updated :
06 Oct, 2021
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...