Tags

  • AWS (7)
  • Apigee (3)
  • ArchLinux (5)
  • Array (6)
  • Backtracking (6)
  • BinarySearch (6)
  • C++ (19)
  • CI&CD (3)
  • Calculus (2)
  • DesignPattern (43)
  • DisasterRecovery (1)
  • Docker (8)
  • DynamicProgramming (20)
  • FileSystem (11)
  • Frontend (2)
  • FunctionalProgramming (1)
  • GCP (1)
  • Gentoo (6)
  • Git (15)
  • Golang (1)
  • Graph (10)
  • GraphQL (1)
  • Hardware (1)
  • Hash (1)
  • Kafka (1)
  • LinkedList (13)
  • Linux (27)
  • Lodash (2)
  • MacOS (3)
  • Makefile (1)
  • Map (5)
  • MathHistory (1)
  • MySQL (21)
  • Neovim (10)
  • Network (66)
  • Nginx (6)
  • Node.js (33)
  • OpenGL (6)
  • PriorityQueue (1)
  • ProgrammingLanguage (9)
  • Python (10)
  • RealAnalysis (20)
  • Recursion (3)
  • Redis (1)
  • RegularExpression (1)
  • Ruby (19)
  • SQLite (1)
  • Sentry (3)
  • Set (4)
  • Shell (3)
  • SoftwareEngineering (12)
  • Sorting (2)
  • Stack (4)
  • String (2)
  • SystemDesign (13)
  • Terraform (2)
  • Tree (24)
  • Trie (2)
  • TwoPointers (16)
  • TypeScript (3)
  • Ubuntu (4)
  • Home

    [LeetCode 90] Subsets II

    Published Jun 13, 2022 [  Backtracking  ]

    Problem

    Given an integer array nums that may contain duplicates, return all possible subsets (the power set).

    The solution set must not contain duplicate subsets. Return the solution in any order.

    Example 1:

    Input: nums = [1,2,2]
    Output: [[],[1],[1,2],[1,2,2],[2],[2,2]]
    

    Example 2:

    Input: nums = [0]
    Output: [[],[0]]
    

    Constraints:

    • 1 <= nums.length <= 10
    • -10 <= nums[i] <= 10

    Thoughts

    • In the decision tree, we ignore the values that can cause duplicated results, sort nums first, and do some consecutive check with while loop
    • Pointer location for end/success condition

    TypeScript

    function subsetsWithDup(nums: number[]): number[][] {
        const res: number[][] = []
        const LEN: number =nums.length
        nums.sort((a, b) => a - b)
        
        const exec = (i: number, subset: number[]) => {
            if(i === LEN) {
                res.push([...subset])
                return
            }
            
            subset.push(nums[i])
            exec(i + 1, subset)
            subset.pop()
            
            while(i + 1 < LEN && nums[i] === nums[i + 1]) i++;
            exec(i + 1, subset)
        }
        
        exec(0, [])
        
        return res;
    };
    

    Reference