Generate all distinct subsequences of array using backtracking
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:
- 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++
// 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>
Output{} {1} {1, 2} {1, 2, 2} {2} {2, 2}
Time Complexity: O(2N)
Auxiliary Space: O(N)
Similar Reads
Find all distinct subset (or subsequence) sums of an array Given an array arr[] of size n, the task is to find a distinct sum that can be generated from the subsets of the given sets and return them in increasing order. It is given that the sum of array elements is small.Examples: Input: arr[] = [1, 2]Output: [0, 1, 2, 3]Explanation: Four distinct sums can
15+ min read
Find all distinct subset (or subsequence) sums of an array | Set-2 Given an array of N positive integers write an efficient function to find the sum of all those integers which can be expressed as the sum of at least one subset of the given array i.e. calculate total sum of each subset whose sum is distinct using only O(sum) extra space. Examples: Input: arr[] = {1
9 min read
Count of Subsequences with distinct elements Given an array arr[] (1<=a[i]<=1e9) containing N (1<=N<=1e5) elements, the task is to find the total number of subsequences such that all elements in that subsequences are distinct. Since the answer can be very large print and modulo 1e9+7. Examples: Input: arr[] = [1, 1, 2, 2]Output: 8E
5 min read
Count of subsequence of an Array having all unique digits Given an array A containing N positive integers, the task is to find the number of subsequences of this array such that in each subsequence , no digit is repeated twice, i.e. all the digits of the subsequences must be unique.Examples: Input: A = [1, 12, 23, 34] Output: 7 The subsequences are: {1}, {
15+ min read
Count Subsequences with ordered integers in Array Given an array nums[] of N positive integers, the task is to find the number of subsequences that can be created from the array where each subsequence contains all integers from 1 to its size in any order. If two subsequences have different chosen indices, then they are considered different. Example
7 min read