Leetcode Backtracking Python

Backtracking 的基本套路是for循环加一个dfs. 

 

77. Combinations

Given two integers n and k, return all possible combinations of k numbers out of 1 ... n.

Input: n = 4, k = 2
Output:
[
  [2,4],
  [3,4],
  [2,3],
  [1,2],
  [1,3],
  [1,4],
]

Answer:

class Solution:
    def combine(self, n: int, k: int) -> List[List[int]]:
        res=[]
        self.dfs(range(1,n+1),k,[],res)
        return res
    def dfs(self,nums,k,path,res):
        if k > len(nums):
            return
        if k == 0:
            res.append(path)
        for i in range(len(nums)):
            self.dfs(nums[i+1:],k-1,path+[nums[i]],res)

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

class Solution:
    def permute(self, nums: List[int]) -> List[List[int]]:
        res=[]
        self.dfs(nums,[],res)
        return res
    def dfs(self,nums,path,res):
        if not nums:
            res.append(path)
        for i in range(len(nums)):
            self.dfs(nums[:i]+nums[i+1:],path+[nums[i]],res)

47. Permutations II

Given a collection of numbers that might contain duplicates, return all possible unique permutations.

Example:

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

class Solution:
    def permuteUnique(self, nums: List[int]) -> List[List[int]]:
        res=[]
        self.seen=[]
        self.dfs(nums,[],res)
        return res
    def dfs(self,nums,path,res):
        if not nums and path not in self.seen:
            res.append(path)
            self.seen.append(path)
        for i in range(len(nums)):
            self.dfs(nums[:i]+nums[i+1:],path+[nums[i]],res)

 

39. Combination Sum

Given a set of candidate numbers (candidates) (without duplicates) and a target number (target), find all unique combinations in candidates where the candidate numbers sums to target.

The same repeated number may be chosen from candidates unlimited number of times.

Note:

• All numbers (including target) will be positive integers.
• The solution set must not contain duplicate combinations.

Example 1:

Input: candidates = [2,3,6,7], target = 7

,
A solution set is:
[
  [7],
  [2,2,3]
]

Example 2:

 

Input: candidates = [2,3,5], target = 8,
A solution set is:
[
  [2,2,2,2],
  [2,3,3],
  [3,5]
]

 

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        candidates.sort()
        res=[]
        self.dfs(candidates,target,0,[],res)
        return res
    def dfs(self,nums,target,index,path,res):
        if target < 0:
            return
        if target == 0:
            res.append(path)
            return
        for i in range(index,len(nums)):
            self.dfs(nums,target-nums[i],i,path+[nums[i]],res)