Leetcode--------回溯法

最新推荐文章于 2023-09-11 00:22:15 发布

我会像蜗牛一样努力

最新推荐文章于 2023-09-11 00:22:15 发布

阅读量226

点赞数

分类专栏： leetcode 文章标签： python

本文链接：https://blog.csdn.net/qq_40128284/article/details/119295054

版权

leetcode 专栏收录该内容

25 篇文章 0 订阅

订阅专栏

回溯法模板：

回溯三部曲：

回溯函数模板返回值以及参数，习惯是函数起名字为backtracking
回溯函数终止条件
if (终止条件) {
    存放结果;
    return;
}
回溯搜索的遍历过程

总结：

void backtracking(参数) {
    if (终止条件) {
        存放结果;
        return;
    }

    for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
        处理节点;
        backtracking(路径，选择列表); // 递归
        回溯，撤销处理结果
    }
}

77. 组合

给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。

你可以按 任何顺序 返回答案。

示例 1：

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

示例 2：

输入：n = 1, k = 1
输出：[[1]]

代码：

class Solution:
    def combine(self, n: int, k: int) -> List[List[int]]:
        
        res_all = []
        res_item = []
        #1.0 函数参数及其返回值
        def backtracking(res_all,res_item,n,k,start):
            #2.0 终止条件
            if len(res_item) == k:
                #说明找到了一个组合
                """
                这里一定要注意，用浅copy,不然已经加入到列表中的元素还是被修改了
                """
                res_all.append(res_item.copy())
                return 
            #3.0 代码逻辑
            for i in range(start,n+1):
                res_item.append(i)
                start += 1
                #开始回溯
                backtracking(res_all,res_item,n,k,start)
                res_item.pop(-1)
                
        backtracking(res_all,res_item,n,k,1)
        return res_all

216. 组合总和 III

找出所有相加之和为 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_all = list()
        res_item = list()
        start = 0
        def backtracking(start: int,k: int, n: int):
            #找到一个列表，里面所有的树的和为n
            if len(res_item) == k and sum(res_item) == n:
                res_all.append(res_item.copy())
                #必须return,表示当前路径停止了，不在往下走了
                return 
            for _ in range(start,9):
                start += 1
                res_item.append(start)
                #回溯
                backtracking(start,k,n)
                res_item.pop(-1)
        backtracking(start,k,n)
        return res_all

39. 组合总和

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

candidates 中的数字可以无限制重复被选取。如果至少一个所选数字数量不同，则两种组合是唯一的。

对于给定的输入，保证和为 target 的唯一组合数少于 150 个。

示例 1：

输入: candidates = [2,3,6,7], 
target = 7

输出: [[7],[2,2,3]]

代码：

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        """
        组合问题使用回溯
        """
        res_all = []
        res_item = []
        def backtracking(start_index:int):
            #停止条件
            if sum(res_item) > target:
                return
            if sum(res_item) == target:
                res_all.append(res_item.copy())
                return 
            for i in range(start_index,len(candidates)):
                #进行剪枝
                if sum(res_item) > target:
                    return
                res_item.append(candidates[i])
                #这里不同start_index+=1,因为可以重复选择
                #i表示还是可以从当前位置进行选择
                backtracking(i)
                res_item.pop(-1)
        backtracking(0)
        return res_all

40. 组合总和 II

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

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

注意：解集不能包含重复的组合。

示例 1:
输入: candidates = [10,1,2,7,6,1,5], target = 8,
输出:
[
[1,1,6],
[1,2,5],
[1,7],
[2,6]
]

代码：

class Solution:
    def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
        """
        组合问题使用回溯
        """
        res_all = []
        res_item = []
        #新建立集合进行去重
        # value_set = {}
        # candidates = list(set(candidates))
        candidates = sorted(candidates)
        print(candidates)
        def backtracking(start_index:int):
            #停止条件
            if sum(res_item) > target:
                return
            if sum(res_item) == target:
                res_all.append(res_item.copy())
                return 
            for i in range(start_index,len(candidates)):
                #去重操作
                if i > start_index and candidates[i] == candidates[i-1]:
                    continue     
                    
                #进行剪枝
                if sum(res_item) > target:
                    return
                res_item.append(candidates[i])
                #这里不同start_index+=1,因为可以重复选择
                #i表示还是可以从当前位置进行选择
                backtracking(i+1)
                res_item.pop(-1)
        backtracking(0)
        return res_all

131. 分割回文串

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是 回文串 。返回 s 所有可能的分割方案。

回文串 是正着读和反着读都一样的字符串。

示例 1：

输入：s = "aab"
输出：[["a","a","b"],["aa","b"]]

代码：

class Solution:
    def partition(self, s: str) -> List[List[str]]:
        lens = len(list(s))
        res_all = []
        res_item = []
        def backtracking(s: str,start_index: int):
            #判断停止条件-----在每个字符串后面进行切割
            if start_index >= lens:
                #已经切割到末尾了，说明就是一个回文
                res_all.append(res_item.copy())
                return
            #逻辑处理
            for i in range(start_index,lens):
                #假如start_index = 0那么切割下来的str就是s[0:1]
                sub_str = s[start_index:i+1]
                if sub_str == sub_str[::-1]:
                    res_item.append(sub_str)
                else:
                    #因为后面要回溯，只有将sub_str添加到res_item中
                    #当前字符已经不是回文，没有继续下去的必要
                    continue  
                backtracking(s,i+1) 
                #回溯
                res_item.pop(-1)
        backtracking(s,0)  
        return res_all

93. 复原 IP 地址

给定一个只包含数字的字符串，用以表示一个 IP 地址，返回所有可能从 s 获得的 有效 IP 地址 。你可以按任何顺序返回答案。

有效 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 '.' 分隔。

例如："0.1.2.201" 和 "192.168.1.1" 是有效 IP 地址，但是 "0.011.255.245"、"192.168.1.312" 和 "192.168@1.1" 是无效 IP 地址。

示例 1：

输入：s = "25525511135"
输出：["255.255.11.135","255.255.111.35"]

代码：

class Solution:
    def restoreIpAddresses(self, s: str) -> List[str]:
        """
        和前面字符串切割很类似
        """
        lens = len(list(s))
        res_all = []
        res_item = []
        def backtracking(s: str,start_index: int):
            #终止条件
            if start_index >= lens:
                if len(res_item) == 4 :
                    res_all.append(res_item.copy())
                return
            #若数字的个数等于4，就不往下继续了
            if len(res_item) == 4 :
                return
            #处理逻辑
            for i in range(start_index,lens):
                #start_index=0：s[0:1]
                sub_str = s[start_index:i+1]
                #判断是否有效
                if int(sub_str)> 255 or (sub_str[0] == "0" and len(sub_str) > 1):
                    continue
                res_item.append(sub_str)
                backtracking(s,i+1)
                #回溯
                res_item.pop(-1)
        backtracking(s,0)
        return list(map(lambda x:".".join(x),res_all))

78. 子集

给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。

解集不能包含重复的子集。你可以按 任意顺序 返回解集。

示例 1：

输入：nums = [1,2,3]
输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]

示例 2：

输入：nums = [0]
输出：[[],[0]]

代码：

class Solution:
    def subsets(self, nums: List[int]) -> List[List[int]]:
        lens = len(nums)
        res_item = []
        res_all = []
        sub_nums = nums.copy()
        def backstacking(nums: List[int],start_index: int):
            #停止条件-----剩余列表为空
            res_all.append(res_item.copy())
            if start_index-1 == lens:
                return
            for i in range(start_index,lens):
                res_item.append(nums[i])
                backstacking(nums,i+1)
                #开始回溯
                res_item.pop(-1)
        backstacking(nums,0)
        return res_all

491. 递增子序列

给你一个整数数组 nums ，找出并返回所有该数组中不同的递增子序列，递增子序列中 至少有两个元素 。你可以按 任意顺序 返回答案。

数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。

示例 1：

输入：nums = [4,6,7,7]
输出：[[4,6],[4,6,7],[4,6,7,7],[4,7],[4,7,7],[6,7],[6,7,7],[7,7]]

代码：

class Solution:
    def findSubsequences(self, nums: List[int]) -> List[List[int]]:
        lens = len(nums)
        res_item = []
        res_all = []
        def backstacking(nums: List[int],start_index: int):
            #停止条件-----剩余列表为空
            if len(res_item) >= 2:
                res_all.append(res_item.copy())
            if start_index-1 == lens:
                return
            #使用set对本层元素进行去重
            unordered_set = set()
            for i in range(start_index,lens):   
                #去重操作
                if nums[i] in unordered_set:
                    continue
                if len(res_item) > 0 and nums[i] < res_item[-1]:
                    continue
                res_item.append(nums[i])    
                unordered_set.add(nums[i])      
                backstacking(nums,i+1)
                #开始回溯
                res_item.pop(-1)
        backstacking(nums,0)
        return res_all

46. 全排列

给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。

示例 1：
输入：nums = [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]]:
        """
        回溯
        """
        lens = len(nums)
        res_item = []
        res_all = []
        #记录已经使用过的数字
        used = []
        def backtracking(nums: List[int]):
            #停止条件
            if len(res_item) == len(nums):
                res_all.append(res_item.copy())
                return
            #业务逻辑
            for i in range(0,lens):
                #看当前元素是否已经使用过
                if nums[i] in used:
                    continue
                res_item.append(nums[i])
                used.append(nums[i])
                backtracking(nums)
                #回溯
                res_item.pop(-1)
                used.pop(-1)
        backtracking(nums)
        return res_all

47. 全排列 II

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

示例 1：

输入：nums = [1,1,2]
输出：
[[1,1,2],
 [1,2,1],
 [2,1,1]]

示例 2：

输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

代码：

class Solution:
    def permuteUnique(self, nums: List[int]) -> List[List[int]]:
        nums = sorted(nums)
        """
        回溯
        """
        lens = len(nums)
        res_item = []
        res_all = []
        #记录已经使用过的数字
        used = [0] * len(nums)
        def backtracking(nums: List[int]):
            #停止条件
            if len(res_item) == len(nums):
                res_all.append(res_item.copy())
                return
            #业务逻辑
            for i in range(0,lens):
                #首先当前元素没有被选中过
                if not used[i]:
                    #看当前元素是否已经使用过
                    if i > 0 and (not used[i-1]) and nums[i] == nums[i-1]:
                        continue
                    used[i] = 1
                    res_item.append(nums[i])
                    backtracking(nums)
                    #回溯
                    res_item.pop(-1)
                    used[i] = 0
        backtracking(nums)
        return res_all

332. 重新安排行程

给你一份航线列表 tickets ，其中 tickets[i] = [fromi, toi] 表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。

所有这些机票都属于一个从 JFK（肯尼迪国际机场）出发的先生，所以该行程必须从 JFK 开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。

例如，行程 ["JFK", "LGA"] 与 ["JFK", "LGB"] 相比就更小，排序更靠前。

假定所有机票至少存在一种合理的行程。且所有的机票必须都用一次且只能用一次。

示例 1：
输入：tickets = [["MUC","LHR"],["JFK","MUC"],["SFO","SJC"],["LHR","SFO"]]
输出：["JFK","MUC","LHR","SFO","SJC"]

代码：

class Solution:
    def findItinerary(self, tickets: List[List[str]]) -> List[str]:
        map_tickets = defaultdict(list)
        for item in tickets:
            map_tickets[item[0]].append(item[1])
        """
        采用递归的方法来求解
        """
        paths = []
        from_loc = "JFK"
        paths.append(from_loc)
        def backtracking(from_loc):
            #截止条件------说明找到了一条路径
            if len(paths) == len(tickets)+1:
                #这里只要找到一条路径就行
                return True
            #对目的地进行排序，保证找到的是最小行程组合
            map_tickets[from_loc].sort()
            for _ in map_tickets[from_loc]:
                #删除这个目的地，防止出现死循环
                dis_loc = map_tickets[from_loc].pop(0)
                #从当前出发,选择一个目的地
                paths.append(dis_loc)
                #直接找到一个就可以返回
                if backtracking(dis_loc):
                    return True
                path.pop()
                map_tickets[from_loc].append(dis_loc)
        backtracking("JFK") 
        return paths

我会像蜗牛一样努力

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Leetcode--------回溯法

回溯法模板：回溯三部曲：回溯函数模板返回值以及参数，习惯是函数起名字为backtracking 回溯函数终止条件if (终止条件) { 存放结果; return;}回溯搜索的遍历过程总结：void backtracking(参数) { if (终止条件) { 存放结果; return; } for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) { 处理节点;
复制链接

扫一扫