使用回溯生成数组的所有不同子序列

给定一个由N个正整数组成的数组arr [] ，任务是生成该数组的所有不同子序列。

例子：

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}

方法：请按照以下步骤解决问题：

1. 对给定的数组进行排序。
2. 初始化向量的向量以存储所有不同的子序列。
3. 遍历数组，并为每个数组元素考虑两个选择，以将其包含在子序列中或不包含它。
4. 如果找到重复项，则忽略它们并检查其余元素。否则，将当前数组元素添加到当前子序列，然后遍历其余元素以生成子序列。
5. 生成子序列后，删除当前数组元素。

下面是上述方法的实现：

C++14

// C++ program to implement
// the above approach
 
#include 
using namespace std;
 
// Function to generate all distinct
// subsequences of the array using backtracking
void 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 Backtracking
vector > 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 subsequences
void 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 Code
int 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 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 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 Backtracking
public 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 Code
public 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 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#

// 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 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 Backtracking
public 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 Code
public 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

输出

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

时间复杂度： O(2 ^N )
辅助空间： O(N)