leetcode 46 Permutations Python 实现（回溯算法）

 

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]
]

回溯算法自己的一个思路如下：需要保留数字使用情况，my_nums增加和删除元素等操作

 1 class Solution:
 2     def permute(self, nums: List[int]) -> List[List[int]]:
 3         results = []
 4         use_dict = dict.fromkeys(nums, False) #初始化一个字典，保存数字是否使用过
 5         def backtrack(results, my_nums, use_dict):
 6             if len(my_nums) == len(nums):
 7                 tmp_nums = copy.deepcopy(my_nums)
 8                 results.append(tmp_nums)
 9                 return
10             
11             for x in nums:
12                 if not use_dict[x]:
13                     use_dict[x] = True
14                     my_nums.append(x)  
15                     backtrack(results, my_nums, use_dict)
16                     my_nums.remove(x)  #remove操作耗费时间
17                     use_dict[x] = False
18         backtrack(results, [], use_dict)
19         return results

整体程序花费时间较多，remove处消耗太多时间， 超过24%左右

 改良版：

 1 class Solution:
 2     def permute(self, nums: List[int]) -> List[List[int]]:
 3         results = []
 4         len_n = len(nums)
 5         def backtrack(my_nums, use_nums):
 6             if len(my_nums) == len_n:
 7                 results.append(my_nums)
 8                 return
 9             for i in range(len(use_nums)):
10                 x = my_nums.copy()
11                 x.append(use_nums[i])
12                 backtrack(x, use_nums[:i]+use_nums[i+1:])
13         backtrack([], nums)
14         return results

这个每次递归会缩小剩下可用数字范围，不需要维护数字使用dict

my_nums每次都copy一份，这样就不需要remove操作了，运行时间缩短。 

超过98%以上Python速度

 

 

---最近转战英文leetcode站了，所以题目变成了英文描述

转载于:https://www.cnblogs.com/watch-fly/p/leetcode_46_watchfly.html