回溯算法

39. 组合总和

难度中等558收藏分享切换为英文关注反馈

给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的数字可以无限制重复被选取。

说明：

• 所有数字（包括 target）都是正整数。
• 解集不能包含重复的组合。 

示例 1:

输入: candidates = [2,3,6,7], target = 7,
所求解集为:
[
  [7],
  [2,2,3]
]

示例 2:

输入: candidates = [2,3,5], target = 8,
所求解集为:
[
  [2,2,2,2],
  [2,3,3],
  [3,5]
]

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        res = list()
        candidates.sort()
        size = len(candidates)
        self.__dfs(candidates, size, target, list(), res)
        new_res = self.__duplicate_removal(res)
        return new_res
        
    def __dfs(self, candidates: List[int], size:int, residue: int,  path: list, res: list):
        if residue == 0:
            res.append(path[:])
            return
        for index in range(size):
            if candidates[index] > residue:
                break
            path.append(candidates[index])
            self.__dfs(candidates, size, residue-candidates[index], path, res)
            path.pop()
            
    def __duplicate_removal(self, res: list):
        new_res = list()
        for each_element in res:
            each_element.sort()
            if each_element not in new_res:
                new_res.append(each_element)
        return new_res

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        candidates.sort()
        size = len(candidates)
        res = self.__dfs(candidates, size, target, list())
        new_res = self.__duplicate_removal(res)

        return new_res
        
        
    def __dfs(self, candidates: List[int], size:int, residue: int,  path: list)-> List[List[int]]:
        if residue == 0:
            return [path]
            
        if residue < 0:
            return list()

        res = list()    
        for index in range(size):
            if candidates[index] > residue:
                break
            temp_res = self.__dfs(candidates, size, residue-candidates[index], path+[candidates[index]])
            res += temp_res
        
        return res


    def __duplicate_removal(self, res: list) -> List[List[int]]:
        new_res = list()
        for each_element in res:
            each_element.sort()
            if each_element not in new_res:
                new_res.append(each_element)

        return new_res

40. 组合总和 II

难度中等217收藏分享切换为英文关注反馈

给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的每个数字在每个组合中只能使用一次。

说明：

• 所有数字（包括目标数）都是正整数。
• 解集不能包含重复的组合。 

示例 1:

输入: candidates = [10,1,2,7,6,1,5], target = 8,
所求解集为:
[
  [1, 7],
  [1, 2, 5],
  [2, 6],
  [1, 1, 6]
]

示例 2:

输入: candidates = [2,5,2,1,2], target = 5,
所求解集为:
[
  [1,2,2],
  [5]
]

class Solution:
    def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
        candidates.sort()
        res = list()
        self.__dfs(candidates, target, 0, len(candidates), list(), res)
        return res
        
        
    def __dfs(self, candidates: List[int], residue: int, start:int, size:int, path:list, res: list):
        if residue == 0:
            res.append(path[:])
            return 
        
        for index in range(start, size):
            if candidates[index] > residue:
                break
            
            if index > start and candidates[index-1] == candidates[index]:
                continue

            self.__dfs(candidates, residue - candidates[index], index + 1, size, path+[candidates[index]], res)
          

class Solution:
    def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
        candidates.sort()
        res = self.__dfs(candidates, target, 0, len(candidates), list())

        return res
        
        
    def __dfs(self, candidates: List[int], residue: int, start:int, size:int, path:list):
        if residue == 0:

            return [path]

        if residue < 0:

            return list()

        res = list()
        for index in range(start, size):
            if candidates[index] > residue:
                break
            if index > start and candidates[index-1] == candidates[index]:
                continue
            
            temp_res = self.__dfs(candidates, residue-candidates[index], index+1, size, path + [candidates[index]])
            res += temp_res

        return res

46. 全排列

难度中等565收藏分享切换为英文关注反馈

给定一个没有重复数字的序列，返回其所有可能的全排列。

示例:

输入: [1,2,3]
输出:
[
  [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]]:
        nums.sort() 
        res = self.__dfs(nums, len(nums), list())
        
        return res
        
        
    def __dfs(self, nums: List[int], size:int, path:list) -> List[List[int]]:
        if size == 0:
            return [path]
        
        res = list()
        for index in range(size):
            temp_res = self.__dfs(nums[0:index]+nums[index+1:], size-1, path+[nums[index]])
            res += temp_res

        return res

47. 全排列 II

难度中等243收藏分享切换为英文关注反馈

给定一个可包含重复数字的序列，返回所有不重复的全排列。

示例:

输入: [1,1,2]
输出:
[
  [1,1,2],
  [1,2,1],
  [2,1,1]
]

class Solution:
    def permuteUnique(self, nums: List[int]) -> List[List[int]]:
        nums.sort()
        res = self.__dfs(nums, len(nums), list())
        
        return res
        

    def __dfs(self, nums: List[int], size:int, path:list) -> List[List[int]]:
        if size == 0:
            return [path]
        
        res = list()
        for index in range(size):
            if index > 0 and nums[index-1] == nums[index]:
                continue
            temp_res = self.__dfs(nums[0:index]+nums[index+1:], size-1, path+[nums[index]])
            res += temp_res
        
        return res

77. 组合

难度中等232收藏分享切换为英文关注反馈

给定两个整数 n 和 k，返回 1 ... n 中所有可能的 k 个数的组合。

示例:

输入: n = 4, k = 2
输出:
[
  [2,4],
  [3,4],
  [2,3],
  [1,2],
  [1,3],
  [1,4],
]

class Solution:
           
    def combine(self, n: int, k: int) -> List[List[int]]:
        if n <= 0 or k <= 0 or k > n:
            return []
        result_list = list()
        self.combine_pre(0, n, k, list(), result_list) 
        return result_list 

    def combine_pre(self, begin:int, n: int, k:int, inter_list:list, result_list:list) :
        if k == 0:
            result_list.append(inter_list[:])
            return        
        for index in range(begin, n):
            self.combine_pre(index+1, n, k-1, inter_list+[index+1], result_list)

class Solution:
           
    def combine(self, n: int, k: int) -> List[List[int]]:
        if n <= 0 or k <= 0 or k > n:
            return []

        result_list = self.combine_pre(0, n, k, list()) 

        return result_list 


    def combine_pre(self, begin:int, n: int, k:int, inter_list:list) :
        if k == 0:
            return [inter_list] 

        result_list = list()
        for index in range(begin, n):
            temp_res = self.combine_pre(index+1, n, k-1, inter_list+[index+1])
            result_list += temp_res
        
        return result_list

216. 组合总和 III

难度中等89收藏分享切换为英文关注反馈

找出所有相加之和为 n 的 k 个数的组合。组合中只允许含有 1 - 9 的正整数，并且每种组合中不存在重复的数字。

说明：

• 所有数字都是正整数。
• 解集不能包含重复的组合。 

示例 1:

输入: k = 3, n = 7
输出: [[1,2,4]]

示例 2:

输入: k = 3, n = 9
输出: [[1,2,6], [1,3,5], [2,3,4]]

class Solution:
    def combinationSum3(self, k: int, n: int) -> List[List[int]]:
        res = list()
        self.__dfs(k, n, 0, list(), res)

        return res
    
    
    def __dfs(self, k: int, residue: int, start:int, path:list, res: list): 
        
        if k == 0:
            if residue ==0:
                res.append(path[:]) 
            return 
        
        for index in range(start, 9):
            if index + 1 > residue:
                break
            self.__dfs(k-1, residue-index-1, index+1, path+[index+1], res)

    def __dfs(self, k: int, residue: int, start:int, path:list) -> List[List[int]]: 
        
        if k == 0 and residue ==0:
            return [path]

        if k < 0 or residue < 0:
            return list()
        
        res = list()
        for index in range(start, 9):
            if index + 1 > residue:
                break
            temp_res = self.__dfs(k-1, residue-index-1, index+1, path+[index+1])
            res += temp_res

        return res


    def combinationSum3(self, k: int, n: int) -> List[List[int]]:
        res = self.__dfs(k, n, 0, list())

        return res

93. 复原IP地址

难度中等217收藏分享切换为英文关注反馈

给定一个只包含数字的字符串，复原它并返回所有可能的 IP 地址格式。

示例:

输入: "25525511135"
输出: ["255.255.11.135", "255.255.111.35"]

from typing import List

class Solution:
    def restoreIpAddresses(self, s: str) -> List[str]:
        s_len = len(s)
        if s_len < 4 and s_len > 12:
            return list()

        res = list()
        self.dfs(s, s_len, 0, 0, list(), res)

        return [".".join(res_item) for res_item in res]


    def dfs(self, s, size, split_times, begin, path, res):
        if begin == size:
            if split_times == 4:
                res.append(path[:])
                return 

        if size - begin < (4 - split_times) or size - begin > 3*(4 - split_times):
            return 

        for index in range(3):
            if begin + index >= size:
                return 

            ip_segment = self.judge_if_ip_segment(s, begin, begin + index)

            if ip_segment != -1:
                self.dfs(s, size, split_times+1, begin+index+1, path+[str(ip_segment)], res)


    def judge_if_ip_segment(self, s, left, right):
        size = right - left + 1
        if size > 1 and s[left] == '0':
            return -1
        
        res = 0
        for i in range(left, right + 1):
            res = 10*res + (ord(s[i])-ord('0'))
        if res > 255:
            return -1

        return res