[LC] 46. Permutations

Given a collection of distinct integers, return all possible permutations.

Example:

Input: [1,2,3]
Output:
[
  [1,2,3],
  [1,3,2],
  [2,1,3],
  [2,3,1],
  [3,1,2],
  [3,2,1]
]

Time: O(N!)
Space: O(N)

class Solution:
    def permute(self, nums: List[int]) -> List[List[int]]:
        res = []
        if nums is None or len(nums) == 0:
            return res
        my_set = set()
        cur_list = []
        self.dfs(0, my_set, nums, cur_list, res)
        return res

    def dfs(self, level, my_set, nums, cur_list, res):
        if level == len(nums):
            res.append(list(cur_list))
            return

        for i in range(len(nums)):
            if nums[i] in my_set:
                continue
            my_set.add(nums[i])
            cur_list.append(nums[i])
            self.dfs(level + 1, my_set, nums, cur_list, res)
            my_set.remove(nums[i])
            cur_list.pop()

 class Solution {
     public List<List<Integer>> permute(int[] nums) {
         List<List<Integer>> res = new ArrayList<>();
         if (nums == null || nums.length == 0) {
             return res;
         }
         helper(res, new ArrayList<>(), nums);
         return res;
     }

     private void helper(List<List<Integer>> res, List<Integer> list, int[] nums) {
         if (list.size() == nums.length) {
             res.add(new ArrayList<>(list));
             return;
         }
         for (int num: nums) {
             if (list.contains(num)) {
                 continue;
             }
             list.add(num);
             helper(res, list, nums);
             list.remove(list.size() - 1);
         }
     }
 }

Solution 2:

class Solution(object):
    def permute(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        res = []
        if nums is None or len(nums) == 0:
            return res
        self.dfs(nums, 0, res)
        return res

    def dfs(self, array, level, res):
        if level == len(array):
            res.append(list(array))
            return res

        for i in range(level, len(array)):
            array[level], array[i] = array[i], array[level]
            self.dfs(array, level + 1, res)
            array[i], array[level] = array[level], array[i]