回溯-组合问题/组合/组合总和一二三/电话号码字母组合

最新推荐文章于 2024-06-20 21:03:07 发布

sueong

最新推荐文章于 2024-06-20 21:03:07 发布

阅读量103

点赞数

分类专栏：算法复习文章标签： leetcode python 算法

本文链接：https://blog.csdn.net/sueong/article/details/124705603

版权

算法复习专栏收录该内容

28 篇文章 2 订阅

订阅专栏

回溯基础

基础、组合、组合综合问题的题解参考
参考https://editor.csdn.net/md/?articleId=121913091

77. 组合

在这里插入图片描述

class Solution:
    def combine(self, n: int, k: int) -> List[List[int]]:
        path = []
        res = []
        def backtracking(n, k, startindex):
            # 说明收集个数达到了
            if k == len(path):
                #加入结果
                res.append(path[:])
                return
            # 
            for i in range(startindex,n - (k - len(path)) + 2): #优化的地方 剪枝
                path.append(i) #处理节点
                backtracking(n, k, i + 1)#递归 下一个开始地方从i的后一位开始
                path.pop()# 回溯 撤销处理的节点
        
        backtracking(n, k, 1)
        return res

216.组合总和III

在这里插入图片描述

class Solution:
    def combinationSum3(self, k: int, n: int) -> List[List[int]]:
        path = []
        res = []
        def backtracking(k, targetsum, sum, startindex):
            # 如果sum已经超过tarfetsum 就不用往下找了
            if sum > targetsum:
                return
            if k == len(path):
                #加入结果
                if sum == targetsum:
                    res.append(path[:])
                # 如果path长度==k 但sum != targetSum 直接返回
                return

            for i in range(startindex,9 - (k - len(path)) + 2): #优化的地方 剪枝
                sum += i #处理节点
                path.append(i) #处理节点
                backtracking(k, n, sum, i + 1)# 递归, i+1调整startIndex 因为每个数用一次
                sum -= i# 回溯
                path.pop()# 回溯 撤销处理的节点
        
        backtracking(k, n, 0, 1)
        return res

17. 电话号码的字母组合

在这里插入图片描述
思路：
参考https://www.programmercarl.com/0017.%E7%94%B5%E8%AF%9D%E5%8F%B7%E7%A0%81%E7%9A%84%E5%AD%97%E6%AF%8D%E7%BB%84%E5%90%88.html#%E5%9B%9E%E6%BA%AF%E6%B3%95%E6%9D%A5%E8%A7%A3%E5%86%B3n%E4%B8%AAfor%E5%BE%AA%E7%8E%AF%E7%9A%84%E9%97%AE%E9%A2%98
数字和字母如何映射？map映射
两个字母就两个for循环，三个字符我就三个for循环，以此类推，然后发现代码根本写不出来？回溯
输入1 * #按键等等异常情况？map对应
在这里插入图片描述
回溯三部曲：

确定回溯函数参数
这个index是记录遍历第几个数字了，就是用来遍历digits的（题目中给出数字字符串），同时index也表示树的深度。

 vector<string> result;
string s;
void backtracking(const string& digits, int index)

确定终止条件
例如输入用例"23"，两个数字，那么根节点往下递归两层就可以了，叶子节点就是要收集的结果集。

那么终止条件就是如果index 等于输入的数字个数（digits.size）了（本来index就是用来遍历digits的）。

然后收集结果，结束本层递归。

if (index == digits.size()) {
    result.push_back(s);
    return;
}

确定单层遍历逻辑

首先要取index指向的数字，并找到对应的字符集（手机键盘的字符集）。

 int digit = digits[index] - '0';        // 将index指向的数字转为int
string letters = letterMap[digit];      // 取数字对应的字符集
for (int i = 0; i < letters.size(); i++) {
    s.push_back(letters[i]);            // 处理
    backtracking(digits, index + 1);    // 递归，注意index+1，一下层要处理下一个数字了
    s.pop_back();                       // 回溯
}

class Solution:
    def letterCombinations(self, digits: str) -> List[str]:
        # map来用数字和字母映射 
        map ={
            '2': 'abc',
            '3': 'def',
            '4': 'ghi',
            '5': 'jkl',
            '6': 'mno',
            '7': 'pqrs',
            '8': 'tuv',
            '9': 'wxyz'
        }
        res = []
        path = ''
        # 这个index是记录遍历digits第几个数字了，就是用来遍历digits的（题目中给出数字字符串），同时index也表示树的深度,第几层

        def backtracking(digits,index):
            # 在嵌套函数中用nonlocal 使用外部变量
            nonlocal path
            # 当遍历的深度index等于digits长度 
            if index == len(digits):
                res.append(path)
                return
            
            # 判断是哪一层的字母 比如'23'种的 digits[0]为'2' 再到map中找 
            letters = map[digits[index]]
            for le in letters:
                path += le # 处理
                backtracking(digits,index + 1)# index+1 处理下一层递归 处理digits的下一个数
                path = path[:-1] #回溯 把最后一个字母去掉 因为-1达不到
        
        if digits =='':
            return []
        backtracking(digits,0)
        return res

39. 组合总和

在这里插入图片描述

思路:
本题还需要startIndex来控制for循环的起始位置，对于组合问题，什么时候需要startIndex呢？

如果是一个集合来求组合的话，就需要startIndex，例如：77.组合 (opens new window)，216.组合总和III (opens new window)。

如果是多个集合取组合，各个集合之间相互不影响，那么就不用startIndex，例如：17.电话号码的字母组合
在这里插入图片描述

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        path = []
        res = []
        def backtracking(candidates, target, sum, startindex):
            # 剪枝部分
            if sum > target:
                return
            
            if sum == target:
                res.append(path[:])
                return
            
            for i in range(startindex, len(candidates)):
                sum += candidates[i]
                path.append(candidates[i])
                backtracking(candidates, target, sum, i)# 这里下一次开始的地方还可以是i 因为可以重复使用
                sum -= candidates[i]
                path.pop()

        backtracking(candidates,target, 0, 0)   

        return res

在这里插入图片描述
for循环内剪枝，提前排序

 class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        path = []
        res = []
        # 剪枝需要提前排序
        candidates.sort()
        def backtracking(candidates, target, sum, startindex):
            
            
            if sum == target:
                res.append(path[:])# 浅拷贝所以不能直接添path
                return
            
            for i in range(startindex, len(candidates)):
                # 如果本层 sum + condidates[i] > target，就提前结束遍历，没必要进行下一层的回溯，剪枝
                if sum + candidates[i] > target:
                    return
                sum += candidates[i]
                path.append(candidates[i])
                backtracking(candidates, target, sum, i)# 这里下一次开始的地方还可以是i 因为可以重复使用
                sum -= candidates[i]
                path.pop()

        backtracking(candidates,target, 0, 0)   

        return res

40.组合总和II

在这里插入图片描述

如果按照39的组合和来做，求出所有组合再去重，则会超时，所以要在搜索的过程中就去掉重复组合

class Solution:
    def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
        path = []
        res = []
        # 剪枝需要提前排序
        candidates.sort()
        def backtracking(candidates, target, sum, startindex):
             
            
            if sum == target:
                res.append(path[:])
                return
            
            for i in range(startindex, len(candidates)):
                # 如果本层 sum + condidates[i] > target，就提前结束遍历，没必要进行下一层的回溯，剪枝
                if sum + candidates[i] > target:
                    return
                sum += candidates[i]
                path.append(candidates[i])
                backtracking(candidates, target, sum, i + 1)# 这里下一次开始的地方还可以是i+1 因为不可以重复使用
                sum -= candidates[i]
                path.pop()

        backtracking(candidates,target, 0, 0)  
        # [[1,1,6],[1,2,5],[1,7],[1,2,5],[1,7],[2,6]]
        # 去重
        s = set()
        ans = []
        for item in res:
            if item not in ans:
                ans.append(item)
            

        return ans

本题candidates 中的每个数字在每个组合中只能使用一次。
本题数组candidates的元素是有重复的，而39.组合总和 (opens new window)是无重复元素的数组candidates
树层去重的话，需要对数组排序！

元素在同一个组合内是可以重复的，我们要去重的是同一树层上的“使用过”，同一树枝上的都是一个组合里的元素，不用去重!

简单来说：保证本层不重复但不同层可以重复

//candidates[i]==candidates[i-1]可以参考三数之和 如果当前元素和前一个元素相同 跳过
//同时要确保i-1不会越界 因为i从startindex开始 所以i-1>=startindex有i>=startindex 即i>startindex
if(i>startindex&&candidates[i]==candidates[i-1])
            {
                continue;
            }

首先我们要知道candidates这个数组是固定的，其次candidates[i]==candidate[i-1]这个条件控制的是仅仅是前后元素是否相等，但是单纯用这一条件的话会导致同一跟树枝（纵向）出现相同元素也会被剪掉，就是连[1, 1, 6]这种答案都不可以出现。但是一旦加了 i > startIndex 这个条件就不一样了，因为如果在同一根树枝上进行迭代你会发现 i一直是等于 startIndex 的，只有横向的时候才会出现 i > startIndex的情况，所以 i > startIndex && candidates[i]==candidate[i-1]可以进行树层去重。

class Solution:
    def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
        path = []
        res = []
        # 剪枝需要提前排序
        candidates.sort()
        def backtracking(candidates, target, sum, startindex):
            if sum == target:
                res.append(path[:])
                return
            
            for i in range(startindex, len(candidates)):
                # 如果本层 sum + condidates[i] > target，就提前结束遍历，没必要进行下一层的回溯，剪枝
                if sum + candidates[i] > target:
                    return
                # 参考三数之和 去重 同时保证i-1 不越界 i-1>=startindex
                if i > startindex and candidates[i] == candidates[i - 1]:
                    continue
                sum += candidates[i]
                path.append(candidates[i])
                backtracking(candidates, target, sum, i + 1)# 这里下一次开始的地方是i+1 因为不可以重复使用
                sum -= candidates[i]
                path.pop()

        backtracking(candidates,target, 0, 0)  
        return res

sueong

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
回溯-组合问题/组合/组合总和一二三/电话号码字母组合

回溯基础回溯法解决的问题?组合问题：N个数里面按一定规则找出k个数的集合切割问题：一个字符串按一定规则有几种切割方式子集问题：一个N个数的集合里有多少符合条件的子集排列问题：N个数按一定规则全排列，有几种排列方式棋盘问题：N皇后，解数独等等组合是不强调元素顺序的，排列是强调元素顺序组合无序，排列有序8回溯法一般是在集合中递归搜索，集合的大小构成了树的宽度，递归的深度构成的树的深度`。回溯搜索的遍历过程void backtracking(参数) { if (终止条件) {
复制链接

扫一扫