leetcode 回溯（一）

已于 2022-12-13 01:33:18 修改
阅读量369 收藏
点赞数
分类专栏： leetcode 题 文章标签： leetcode
于 2020-05-23 01:25:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_xuanshuang/article/details/106294314
版权

排列是整个数组遍历，组合是从该下标开始遍历后续数据，去重：先排序，然后有相同元素，若前面的元素未使用则给元素也不用，否则会产生重复解，可以借助used数组记录该下标对应的元素是否使用过了

目录

306. 累加数

17. 电话号码的字母组合

22. 括号生成

93. 复原IP地址

131. 分割回文串

46. 全排列

47. 全排列 II

77. 组合

39. 组合总和

40. 组合总和 II

306. 累加数

力扣

累加数是一个字符串，组成它的数字可以形成累加序列。

一个有效的累加序列必须至少包含 3 个数。除了最开始的两个数以外，字符串中的其他数都等于它之前两个数相加的和。

给定一个只包含数字 '0'-'9' 的字符串，编写一个算法来判断给定输入是否是累加数。

说明: 累加序列里的数不会以 0 开头，所以不会出现 1, 2, 03 或者 1, 02, 3 的情况。

示例 1:输入: "112358"，输出: true 
解释: 累加序列为: 1, 1, 2, 3, 5, 8 。1 + 1 = 2, 1 + 2 = 3, 2 + 3 = 5, 3 + 5 = 8
示例 2:输入: "199100199"，输出: true 
解释: 累加序列为: 1, 99, 100, 199。1 + 99 = 100, 99 + 100 = 199
进阶:你如何处理一个溢出的过大的整数输入?

题解

方法一：直接遍历，斐波那契数列有一个特点，就是只要确定前两个数，则后面的数均可以确定，最外层的for循环确定第一个数，中间层的for循环确定第二个数，while循环找余下的数，若下一个斐波那契数不在字符串中，则不满足条件退出while循环，若查看了所有的字符且都符合条件，则满足要求，若值大于等于3，则直接返回True，否则继续找。

class Solution(object):
    def isAdditiveNumber(self, num):
        """
        :type num: str
        :rtype: bool
        """
        n = len(num)
        if n <= 2:
            return False 
        
        #[0: i], (i: j] - 1, - 2
        
        for i in range(n):
            if i != 0 and num[0] == '0':
                return False
            for j in range(i + 1, n):
                if j != i + 1 and num[i + 1] == '0':
                    break 
                a = int(num[:i + 1])
                b = int(num[i + 1: j + 1])
                k = j + 1
                count = 2
                while True:
                    c = str(a + b)
                    if k == n:
                        if count >= 3:
                            return True 
                    if len(c) + k > n or c != num[k: len(c) + k]:
                        break
                    count += 1
                    k = k + len(c)
                    a = b
                    b = int(c)               
        return False

17. 电话号码的字母组合

力扣

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

示例:输入："23"，输出：["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].
说明:尽管上面的答案是按字典序排列的，但是你可以任意选择答案输出的顺序。

题解

一：搜索问题一般的套路是：先画出递归树，然后思考如何编写代码在这棵递归树上搜索所有可行解。第一层是按顺序遍历digits中的每一个字符，所以也就没必要搞一个for循环，for循环的是每一个字符代表的字符，这一层有点类似排列，所以从0开始的for循环。

class Solution(object):
    def letterCombinations(self, digits):
        """
        :type digits: str
        :rtype: List[str]
        """
        def dfs(x, tmp, ans, digits, n, rec):
            if x == n:
                ans.append(tmp)
                return 
            for c in rec[digits[x]]:
                dfs(x + 1, tmp + c, ans, digits, n, rec)
        
        rec = {'2': 'abc', '3': 'def', '4': 'ghi', '5': 'jkl',
               '6': 'mno', '7': 'pqrs', '8': 'tuv', '9': 'wxyz'}
        ans = [] 
        if not digits:
            return ans 
        n = len(digits)
        dfs(0, "", ans, digits, n, rec)
        return ans

22. 括号生成

力扣

数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。

示例：

输入：n = 3
输出：[
       "((()))",
       "(()())",
       "(())()",
       "()(())",
       "()()()"
     ]

题解

一：其中，cnt表示两两抵消后的左括号"("数，n表示剩下的括号数。这一段，是保证括号的合法性，即左右括号数亩必须相等，当然还要配合下面的if以保证左括号一定在右括号的前面。

if cnt == 0:
    self.res.append(tmp_res)

这一段是进行一些剪枝，提升运行效率，其中if后面的cnt<=0，这一块也是合法性的保证，保证左括号一定在右括号的前面，避免出现这种")("。

if cnt <= 0:
    self.DFS(cnt + 1, tmp_res + "(", n - 1)
elif cnt > n:
    self.DFS(cnt - 1, tmp_res + ")", n - 1)
class Solution(object):
    def __init__(self):
        self.res = []

    def generateParenthesis(self, n):
        """
        :type n: int
        :rtype: List[str]
        """
        if n <= 0:
            return []
        self.DFS(0, "", 2 * n)
        return self.res
        
    def DFS(self, cnt, tmp_res, n):
        if n == 0:
            if cnt == 0:
                self.res.append(tmp_res)
            return 

        if cnt <= 0:
            self.DFS(cnt + 1, tmp_res + "(", n - 1)
        elif cnt > n:
            self.DFS(cnt - 1, tmp_res + ")", n - 1)
        else:
            self.DFS(cnt - 1, tmp_res + ")", n - 1)
            self.DFS(cnt + 1, tmp_res + "(", n - 1)

93. 复原IP地址

力扣

给定一个只包含数字的字符串，复原它并返回所有可能的 IP 地址格式。有效的 IP 地址正好由四个整数（每个整数位于 0 到 255 之间组成），整数之间用 '.' 分隔。

示例:输入: "25525511135"，输出: ["255.255.11.135", "255.255.111.35"]

题解

一：其实这边主要是看三个'.'插在何处，并且还要符合条件。其中before表示的是该段起始的字符下标，idx表示的是目前正在考虑的字符下标，cnt记录目前为止的'.'的个数。

终止条件

  • 到达最后一个字符串
    • 如果符合条件，前面已将添加过3个'.'，且最后一段也符合IP地址的格式，在[0,255]范围，且第一个字符为0只能是最后一段为0，且只有一个字符，添加进res
    • 如果不符合条件，直接返回
  • 不符合条件，已经添加了不止3个'.'，范围不再[0,255]，或者第一个字符为'0'，但是这一段却不为0，或者这一段为0，字符数却不止一个。
class Solution(object):
    def __init__(self):
        self.res = []

    def restoreIpAddresses(self, s):
        """
        :type s: str
        :rtype: List[str]
        """
        if not s or len(s) > 12:
            return self.res

        self.helper(0, 0, 0, "", s)
        return self.res

    # before - 分隔符起始位置
    def helper(self, before, idx, cnt, tmp_res, s):
        if cnt > 3:
            return 
        if idx == len(s) - 1:
            num = int(s[before:]) 
            if ((0 < num <= 255 and s[before] != '0') or (num == 0 and before == idx)) and cnt == 3:
                self.res.append(tmp_res + s[-1])
            return 
        num = int(s[before: idx + 1]) 
        if (before - idx + 1 > 3 or not (0 <= num <= 255) 
            or (num ==0 and before != idx) or (num != 0 and s[before] == '0')):
            return
        self.helper(before, idx + 1, cnt, tmp_res + s[idx], s)
        self.helper(idx + 1, idx + 1, cnt + 1, tmp_res + s[idx] +'.', s)

131. 分割回文串

力扣

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

示例:

输入: "aab"
输出:
[["aa","b"],
  ["a","a","b"]]

题解

一：与上一题思路近乎一样，上题考虑的是在哪放置3个'.'，该题考虑的是在哪进行分隔，该题也要验证是否符合回文串的要求。其中before表示的是该段起始的字符下标，idx表示的是目前正在考虑的字符下标。

class Solution(object):
    def __init__(self):
        self.res = []

    def partition(self, s):
        """
        :type s: str
        :rtype: List[List[str]]
        """
        if not s:
            return self.res
        self.helper(0, 0, [], s)
        return self.res

    def helper(self, before, idx, tmp_res, s):
        if idx >= len(s):
            return 
        if idx == len(s) - 1:
            if self.isValid(s[before:]):
                tmp_res.append(s[before:])
                self.res.append(tmp_res[:])
                tmp_res.pop()
                return 
    
        if self.isValid(s[before: idx + 1]):
            tmp_res.append(s[before: idx + 1])
            self.helper(idx + 1, idx + 1, tmp_res, s)
            tmp_res.pop()
        self.helper(before, idx + 1, tmp_res, s)
            

    def isValid(self, s):
        l, r = 0, len(s) - 1
        while l < r:
            if s[l] != s[r]:
                return False
            l += 1
            r -= 1
        return True

二：这边对时间进行优化，用空间换时间。法一，每次都要使用对撞指针来判断是否是回文串，这边借助动态规划事先存储每组下标起始结束的是否回文串的标记。

class Solution(object):
    def __init__(self):
        self.res = []
        self.dp = []

    def partition(self, s):
        if not s:
            return self.res
        self.dp = [[False] * len(s) for _ in range(len(s))]
        for right in xrange(len(s)):
            for left in xrange(right + 1):
                if (s[left] == s[right] and (right - left <= 2 or self.dp[left + 1][right - 1])):
                    self.dp[left][right] = True

        self.helper(0, 0, [], s)
        return self.res

    def helper(self, before, idx, tmp_res, s):
        if idx >= len(s):
            return 
        if idx == len(s) - 1:
            if self.dp[before][idx]:
                tmp_res.append(s[before:])
                self.res.append(tmp_res[:])
                tmp_res.pop()
                return 

        if self.dp[before][idx]:
            tmp_res.append(s[before: idx + 1])
            self.helper(idx + 1, idx + 1, tmp_res, s)
            tmp_res.pop()
        self.helper(before, idx + 1, tmp_res, s)

46. 全排列

力扣

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

示例:

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

题解

一：经典排列题。其中，used数组记录访问过哪些数组。这是经典排列题，故有一层for循环，从0开始循环，将值填入tmp_res，不能重复取某个下标值，故多一个used数组，记录哪些已经被填入。回溯，保留现场，当退回去时，我们要将这个下标的数值退出数组，并恢复used数组，即置False，表示该下标未使用。

class Solution(object):
 
    def permute(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        def helper(tmp_res, used, nums):
            if len(tmp_res) == len(nums):
                ans.append(tmp_res[:])
                return 
            for i in range(len(nums)):
                if not used[i]:
                    tmp_res.append(nums[i])
                    used[i] = True
                    helper(tmp_res, used, nums)
                    tmp_res.pop()
                    used[i] = False
        ans = []
        if not nums:
            return ans
        used = [False] * len(nums)
        helper([], used, nums)
        return ans

47. 全排列 II

力扣

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

示例:

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

题解

一：其实和上题思路完全一样，不过这题包含重复数字，我们得返回不重复的排列，举个例子，例如[1,1,2]，用上题方法，会出现两个[1,1,2]，分别是下标(0,1,2)和下标(1,0,2)，还有其他的也会重复。这也是经典题，应对着这种情况，我们可以将nums数组排序，然后只要遍历的数值与前面一个数值相同，但若前面的未访问过跳过就好，其余情况依旧将该值填入tmp_res。

class Solution(object):
    def __init__(self):
        self.res = []
        
    def permuteUnique(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        if not nums:
            return self.res
        nums = sorted(nums)
        used = [False] * len(nums)
        self.helper([], used, nums)
        return self.res
    
    def helper(self, tmp_res, used, nums):
        if len(tmp_res) == len(nums):
            self.res.append(tmp_res[:])
            return 
        
        for i in range(len(nums)):
            if i != 0 and nums[i] == nums[i - 1] and not used[i - 1]:
                continue
            if not used[i]:
                tmp_res.append(nums[i])
                used[i] = True
                self.helper(tmp_res, used, nums)
                tmp_res.pop()
                used[i] = False

77. 组合

力扣

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

题解

一：经典的组合题，从该下标开始遍历后续数据，由于已经遍历过的不取，所以每次都要对start+1，同时由于都是从该下标开始遍历后续，不会遍历到之前遍历过的数据，无需向排列一样搞个used。

class Solution(object):
    def __init__(self):
        self.res = []

    def combine(self, n, k):
        """
        :type n: int
        :type k: int
        :rtype: List[List[int]]
        """
        if n <= 0 or k > n:
            return self.res
        self.DFS([], 0, n, k)
        return self.res

    def DFS(self, tmp_res, start, n, k):
        if len(tmp_res) == k:
            self.res.append(tmp_res[:])
            return 
        start += 1
        if start > n:
            return 

        for i in xrange(start, n + 1):
            tmp_res.append(i)
            self.DFS(tmp_res, i, n, k)
            tmp_res.pop()

39. 组合总和

力扣

给定一个无重复元素的数组 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]]

题解

一：这亦是一道经典的组合题，故从当前下标向后遍历，与77不同的是，本题可以重复取值，所以此处的start不用加1，因为次下标亦可取。

class Solution(object):
    def combinationSum(self, candidates, target):
        """
        :type candidates: List[int]
        :type target: int
        :rtype: List[List[int]]
        """
        def DFS(start, tmp_res, target):
            if target < 0:
                return 
            if target == 0:
                res.append(tmp_res[:])
                return 
            for i in xrange(start, len(candidates)):
                residue = target - candidates[i]
                if residue < 0:
                    continue
                tmp_res.append(candidates[i])
                DFS(i, tmp_res, residue)
                tmp_res.pop()
            
        if not candidates or target <= 0:
            return self.res
        res = []
        DFS(0, [], target)
        return res

40. 组合总和 II

力扣

给定一个数组 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]]

题解

一：这边感觉还是和上题一样的思路，借助排序来剪枝（去掉重复解，用used数组标记该下标的数值是否被使用过，若与前面的数值相同，而前面的未被使用过，该下标也不被使用），只能用一次，就需要start+1。

class Solution(object):
    def combinationSum2(self, candidates, target):
        """
        :type candidates: List[int]
        :type target: int
        :rtype: List[List[int]]
        """
        def DFS(start, tmp_res, target):
            if target < 0:
                return 
            if target == 0:
                res.append(tmp_res[:])
                return 
            for i in xrange(start + 1, len(candidates)):
                residue = target - candidates[i]
                if residue < 0:
                    break
                if i >= 1 and candidates[i] == candidates[i - 1] and not used[i - 1]:
                    continue
                tmp_res.append(candidates[i])
                used[i] = True 
                DFS(i, tmp_res, residue)
                tmp_res.pop()
                used[i] = False 

        candidates = sorted(candidates)
        used = [False] * len(candidates)
        res = []
        DFS(-1, [], target)
        return res

一杯敬朝阳一杯敬月光
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
图解 LeetCode 算法汇总——回溯
qq_42700121的博客
09-11 783
回溯算法尝试在问题的解空间中搜索可能的解，并在搜索过程中进行选择、撤销选择和终止搜索，直到找到解或确定无解为止。通常通过递归函数来实现回溯算法。在每一步，需要做出选择（选择一个分支）然后递归地探索该选择的结果。在递归返回后，需要撤销之前的选择，以便继续探索其他分支。使用条件语句或循环来控制选择的范围和条件。
Leetcode学习之回溯算法
frighting_ing的博客
11-14 4471
1. 回溯算法理论基础 什么是回溯法 回溯法也可以叫做回溯搜索法，它是一种搜索的方式。 在二叉树系列中，我们已经不止一次，提到了回溯，例如二叉树：以为使用了递归，其实还隐藏着回溯。 回溯是递归的副产品，只要有递归就会有回溯。 所以回溯函数也就是递归函数，指的都是一个函数。 回溯法的效率 回溯法的性能如何呢，必须强调的是，虽然回溯法很难，很不好理解，但是回溯法并不是什么高效的算法。 **因为回溯的本质是穷举，穷举所有可能，然后选出我们想要的答案，**如果想让回溯法高效一些，可以加一些剪枝的操作，但也改不了回
LeetCode——回溯
weixin_47156261的博客
03-17 658
组合三部曲 确定函数参数和递归终止条件 for循环遍历树的深度和宽度 回溯记得pop_back. 1. 组合 为了简单将两个vector设为全局变量 startindex要传入，不然递归时无法往下更新 递归过程中伴随回溯，path.pop_back就是在回溯过程中使用的， class Solution { public: vector<vector<int>>res; vector<int>path; void backtracking(int n,int
leetcode-回溯算法总结
许诗宇的博客
11-22 966
leetcode-17-电话号码的字母组合(letter combination of a phone number)-java 在类中建立一个数字对应字母的map，和对应的结果list 方法1： 进入combine("",digits) 第一个字符串为当前字符串，后面的为还能加上的数字字符串 每次从数组字符串中取最前一位，得到对应的char数组，将nowStr+对应的数组（用for循环，分别...
leetcode_回溯专题篇
qq_40088655的博客
03-01 186
leetcode_回溯专题篇
leetcode思维导图-回溯
08-13
leetcode思维导图-回溯
LeetCode 78题：子集 回溯法
01-21
回溯法本质是尝试所有的可能性，并把符合条件的可能记录下来，不符合的情况及时退出的一种方法。下面我们通过两个具体的题目来深刻理解回溯法的思想。 第一题：子集 题目分析：数组长度为n的数组的所有子集，其长度...
LeetCode Solutions
最新发布
06-13
《LeetCode Solutions》是针对LeetCode在线编程挑战平台的一份C++解题指南，主要针对想要提升算法技能、准备技术面试或对编程感兴趣的人群。LeetCode提供了丰富的算法题目，覆盖了从基础到高级的各种数据结构和算法...
LeetCode
02-13
LeetCode 是一个在线平台，专为程序员提供一系列的编程挑战，旨在提升算法和数据结构技能。这个平台涵盖了多种编程语言，包括Java。在LeetCode上，你可以找到各种难度级别的问题，从入门到专家级别，帮助你准备面试...
leetcode-editor
05-09
在编程领域，LeetCode 是一个广受欢迎的在线平台，它提供了丰富的算法题目，帮助开发者提升编程技能、准备面试，甚至纯粹享受解决问题的乐趣。而“leetcode-editor”则是一款针对 LeetCode 平台定制的编辑器，旨在为...
计算数字排列组合，任意数字的组合。
06-21
计算数字排列组合，可以组合出任意数字的组合
Leetcode--------回溯法
qq_40128284的博客
08-05 253
回溯法模板： 回溯三部曲： 回溯函数模板返回值以及参数，习惯是函数起名字为backtracking 回溯函数终止条件 if (终止条件) { 存放结果; return; } 回溯搜索的遍历过程 总结： void backtracking(参数) { if (终止条件) { 存放结果; return; } for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) { 处理节点;
Leetcode回溯法
baidu_41553551的博客
04-03 745
回溯法是复杂度很高的暴力搜索算法，实现简单且有固定模板，常被用于搜索排列组合问题的所有可行解。不同于普通的暴力搜索，回溯法会在每一步判断状态是否合法，而不是等到状态全部生成后再进行确认。当某一步状态非法时，它将回退到上一步中正确的位置，然后继续搜索。前进和后退是回溯法关键的动作。 回溯的本质就是暴力枚举所有可能。要注意的是，由于回溯通常结果集都记录在回溯树的路径上，因此如果不进行撤销操作， 则可能在回溯后状态不正确导致结果有差异， 因此需要在递归到底部往上冒泡的时候进行撤销状态。 如果你每次递归的过
给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。 给出数字到字母的映射如下（与电话按键相同）。。。。
LPL0129的博客
07-16 6632
给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。 给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。 示例: 输入："23" 输出：["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"]. 说明: 尽管上面的答案是按字典序排列的，但是你可以任意选择答案输出的顺序。 来源：力扣（LeetCode） ...
练习题：给定一个仅包含数字 2-9 的字符串， 返回所有它能表示的字母组合。
qq_36275923的博客
01-04 1789
文章目录题目： 题目： 题目要求： 代码： 运行结果：
leetcode题解汇总
热门推荐
Just Do IT
08-27 1万+
2016.06-10leetcode题目汇总
给定一个仅包含数字2-9的字符串，返回所有它能表示的字母组合
weixin_21583810的博客
03-07 2910
给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。 给出数字到字母的映射如下： （与电话按键相同）。注意 1 不对应任何字母 输入：”23” 输出：[“ad”, “ae”, “af”, “bd”, “be”, “bf”, “cd”, “ce”, “cf”]. 说明：尽管上面的答案是按字典序排列的，但是你可以任意选择答案输出的顺序 def phpneLetter(digits): ...
letter-combinations-of-a-phone-number
llwjason5555的博客
09-08 289
题目：Given a digit string, return all possible letter combinations that the number could represent. A mapping of digit to letters (just like on the telephone buttons) is given below. Input:Digit string
给定一个数字字符串，输出对应的所有组合
每日提升一点点
11-30 706
#include<iostream> #include<vector> #include<map> #include<string> using namespace std; map<int, string> numtostr{ {2,"abc"}, {3,"def"}, {4,"hij"}, {5,"k...
leetcode 回溯
08-22
回溯算法是一种通过不断尝试所有可能的解来求解问题的算法。它通常用于解决一些组合、排列、搜索等问题。在LeetCode上，有许多使用回溯算法的题目。 回溯算法的基本思想是通过深度优先搜索，不断地尝试下一个可能的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值