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++ program to implement // the above approach #include <bits/stdc++.h> using namespace std;
// Function to generate all distinct // subsequences of the array using backtracking 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 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 Backtracking vector<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 subsequences 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 << "} " ;
}
} // Driver Code int 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 approach import java.io.*;
import java.util.*;
class GFG{
// Function to generate all distinct // subsequences of the array using backtracking 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 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 Backtracking public 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 Code public 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 approach result = []
# Function to generate all distinct # subsequences of the array # using backtracking def 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 Backtracking def 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 subsequences 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 = '')
# Driver Code if __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 approach using System;
using System.Collections.Generic;
class GFG{
// Function to generate all distinct // subsequences of the array using // backtracking 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 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 Backtracking public 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 Code public 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)