# Solving Leetcode Interviews in Seconds with AI: Permutations II


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "47" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> Given a collection of numbers, nums, that might contain duplicates, return all possible unique permutations in any order.   Example 1:  Input: nums = [1,1,2] Output: [[1,1,2],  [1,2,1],  [2,1,1]]  Example 2:  Input: nums = [1,2,3] Output: [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]    Constraints:  1 <= nums.length <= 8 -10 <= nums[i] <= 10  

	# Explanation
	*   **Backtracking with Pruning:** The solution utilizes a backtracking algorithm to explore all possible permutations. To avoid generating duplicate permutations, it employs a pruning technique based on sorting the input and skipping identical numbers during the permutation construction process.
*   **Frequency Counting:** The solution creates a frequency count dictionary to efficiently manage the number of times each number appears in the initial array.
*   **Recursive Helper:** A recursive helper function constructs permutations by making choices at each step. The function only considers unique numbers to add to the current permutation.

*   **Time Complexity: O(n!):** where n is the number of elements in the input array nums. In the worst case, the algorithm needs to explore all possible n! permutations.
    **Space Complexity: O(n):** where n is the number of elements in the input array nums. This space is used for the recursion stack and the storage of the generated permutations and the frequency count dictionary.

	
	# Code
	```python
	def permuteUnique(nums):
    """
    Generates all unique permutations of a list of numbers that may contain duplicates.

    Args:
        nums: A list of integers.

    Returns:
        A list of lists, where each inner list is a unique permutation of nums.
    """

    def backtrack(combination, remaining, permutations):
        if not remaining:
            permutations.append(combination.copy())
            return

        for num in remaining:
            new_remaining = remaining.copy()
            new_remaining.remove(num)
            backtrack(combination + [num], new_remaining, permutations)


    nums.sort()
    permutations = []

    def backtrack_optimized(combination, remaining_counts, permutations):
        if len(combination) == len(nums):
            permutations.append(combination.copy())
            return

        for num in remaining_counts:
            if remaining_counts[num] > 0:
                combination.append(num)
                remaining_counts[num] -= 1
                backtrack_optimized(combination, remaining_counts, permutations)
                remaining_counts[num] += 1
                combination.pop()


    remaining_counts = {}
    for num in nums:
        remaining_counts[num] = remaining_counts.get(num, 0) + 1

    permutations = []
    backtrack_optimized([], remaining_counts, permutations)
    return permutations
	```