leetcode2021年度刷题分类型总结（三）回溯法 （python）

主要参考：代码随想录

分为三个部分对回溯法进行总结

1.组合

例一：77. 组合

组合问题关键在于[1,4]和[4,1]算作重复答案，也即取数时往前推进，取到4时不能回头取1，所以每次都要记录取到的位置indx，并在下一循环中以这个位置作为循环的开始for i in range(indx,n):。还有就是剪枝时：
假设已经选择的元素个数：len(path)、那么还需要的元素个数为: k - len(path)。则在集合n中至多要从该起始位置 : n - (k - len(path)) + 1开始遍历，从大于n - (k - len(path)) + 1开始遍历会出现元素个数不足，没有必要遍历

例二：216. 组合总和 III

和例一同理，因为[1,3,5]和[5,3,1]的加和是一样的。只不过规定了取数的范围1-9，同样取数时往前推进，剪枝：

    if sum(tmp)>n: #剪枝操作，元素总和如果已经大于n了，那么往后遍历就没有意义了
        return 

例三：17. 电话号码的字母组合

这题首先要进行一个数字到字母的映射，比较简单。重要的是它代表了不同集合之间的组合，而例一 例二都代表的是同一集合之间的组合。此时不用再记录在当前集合中的位置，而只用记录取到了第几个集合。

例四：39. 组合总和

同样还是组合问题，需要记录循环的起始位置for i in range(indx,len(candidates))，因为[2,2,3]和[3,2,2]被看作是重复的结果。
但是问题在于candidates 中的 同一个 数字可以 无限制重复被选取。 backtracking(candidates,target,i)，把i传给下一次遍历而不是i+1，保证当前数可以被重复选取

规律

对于组合问题，什么时候需要startIndex来记录for循环的起始位置呢？(代码中用了indx)
如果是一个集合来求组合的话，就需要startIndex，例如：77.组合 (opens new window)，216.组合总和III (opens new window)，39. 组合总和
如果是多个集合取组合，各个集合之间相互不影响，那么就不用startIndex，例如：17.电话号码的字母组合

2.子集

3.全排列

回溯算法的执行顺序 ：当“衍生”的函数执行完后（可以是return，也可以是函数执行到了最后一句），回到之前函数的下一句，继续运行

组合

例一：77. 组合

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

你可以按 任何顺序 返回答案。
输入：n = 4, k = 2
输出：
[
[2,4],
[3,4],
[2,3],
[1,2],
[1,3],
[1,4],
]

这题主要在于理解回溯算法的基本使用。以给出的n=4,k=2为例

（上图来源：代码随想录）

由上图可知，代码的逻辑就是在递归中插入for循环遍历，一个递归循环的退出条件就是当path长度达到k。但是编码过程中容易出现一些小错误，比如我第一版的代码：

错误版本

class Solution(object):
    def combine(self, n, k):
        """
        :type n: int
        :type k: int
        :rtype: List[List[int]]
        """
        res=[]
        path=[]
        def dfs(n,k,indx):
            if len(path)==k:
                res.append(path)
                return
            for i in range(indx,n):
                path.append(i)
                dfs(n,k,i+1)
                path.pop()

        dfs(n,k,1)
        return res

问题一出在res.append(path)这种写法是path的浅拷贝，每次path变化时res都会跟着变，所以最后得到的res是一个空数组，正确写法应该是res.append(path[:]);
问题二是for i in range(indx,n):这种写法导致path里面不会包含数字n，正确的写法应该是for i in range(indx,n+1):。之所以写成for i in range(indx,n):，是因为有点疑惑最后for循环里dfs(n,k,n+1)会得到什么，仔细想想若不满足len(path)==k的情况，由于此时indx是n+1也进不去for循环，dfs(n,k,n+1)自然跳过。

正确版本：

class Solution(object):
    def combine(self, n, k):
        """
        :type n: int
        :type k: int
        :rtype: List[List[int]]
        """
        res=[]
        path=[]
        def dfs(n,k,indx):
            if len(path)==k:
                res.append(path[:])
                return
            for i in range(indx,n+1):
                path.append(i)
                dfs(n,k,i+1)
                path.pop()

        dfs(n,k,1)
        return res

上面的代码还有优化的空间，比如对于n=4,k=4这种情况，只有[1,2,3,4]这种情况符合要求，其他以2、3、4为起始位置的其他情况已经不足我们需要的元素个数了，所以就没有必要搜索了。对于这种情况可以用剪枝法来优化。

	假设已经选择的元素个数：len(path)、那么还需要的元素个数为: k - len(path)。则在集合n中至多要从该起始位置 : n - (k - len(path)) + 1开始遍历，从大于n - (k - len(path)) + 1开始遍历会出现元素个数不足，没有必要遍历

（更仔细的说明：代码随想录）

剪枝优化版本：

这里需要注意取到n - (k - len(path)) + 1，所以写成n - (k - len(path)) + 2；
可以发现执行用时大大降低

class Solution(object):
    def combine(self, n, k):
        """
        :type n: int
        :type k: int
        :rtype: List[List[int]]
        """
        res=[]
        path=[]
        def dfs(n,k,indx):
            if len(path)==k:
                res.append(path[:])
                return
            for i in range(indx,n - (k - len(path)) + 2):
                path.append(i)
                dfs(n,k,i+1)
                path.pop()

        dfs(n,k,1)
        return res

例二：216. 组合总和 III

找出所有相加之和为 n 的 k 个数的组合，且满足下列条件：

只使用数字1到9
每个数字 最多使用一次
返回 所有可能的有效组合的列表 。该列表不能包含相同的组合两次，组合可以以任何顺序返回。

输入: k = 3, n = 7
输出: [[1,2,4]]
解释:
1 + 2 + 4 = 7
没有其他符合的组合了。

和77.组合同理

class Solution(object):
    def combinationSum3(self, k, n):
        """
        :type k: int
        :type n: int
        :rtype: List[List[int]]
        """
        ##只使用数字1到9
        # k=2
        # n=18
        tmp=[]
        res=[]
        def backtracking(k,n,indx):
            if sum(tmp)>n: #剪枝操作，元素总和如果已经大于n了，那么往后遍历就没有意义了
                return 
            if k==0:
                if sum(tmp)!=n:
                    return
                else:
                    res.append(tmp[:])
                    return

            if indx>9:
                return

            for i in range(indx,10): # (1,6) 
                tmp.append(i) # 1
                backtracking(k-1,n,i+1) 
                tmp.pop()
                
        backtracking(k,n,1)
        # print(res)
        return res

例三：17. 电话号码的字母组合

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。

给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

输入：digits = “23”
输出：[“ad”,“ae”,“af”,“bd”,“be”,“bf”,“cd”,“ce”,“cf”]

class Solution(object):
    def letterCombinations(self, digits):
        """
        :type digits: str
        :rtype: List[str]
        """
        def mapping(digit):
            if digit=="2":
                return list("abc")
            if digit=="3":
                return list("def")
            if digit=="4":
                return list("ghi")
            if digit=="5":
                return list("jkl")
            if digit=="6":
                return list("mno")
            if digit=="7":
                return list("pqrs")
            if digit=="8":
                return list("tuv")
            if digit=="9":
                return list("wxyz")
        res=[]
        tmp=[]
        def backtracking(digits,n,indx):
            if len(tmp)==n:
                res.append("".join(tmp))
                return
            # if not digits: ##本来不应该运行到这里
            #     return
            ##原来版本：在回溯算法还有深度优先搜索算法中，谨慎用.pop()，因为函数出栈恢复环境的时候可不会把pop()掉的数重新补回来，这个时候还回到原来的地方pop()就会报错说不能对空list执行pop()
            # digit=digits.pop()
            digit=digits[indx]
            opt=mapping(digit)
            # print(opt)
            for i in opt: ##
                tmp.append(i) #d
                backtracking(digits,n,indx+1) # "3" 2
                tmp.pop()
                           
        digits=list(digits)
        n=len(digits)
        if n==0:
            return []
        backtracking(digits,n,0)
        return res

回溯算法的执行顺序 ：当“衍生”的函数执行完后（可以是return，也可以是函数执行到了最后一句），回到之前函数的下一句，继续运行

例四：39. 组合总和

给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。

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

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

输入：candidates = [2,3,6,7], target = 7
输出：[[2,2,3],[7]]
解释：
2 和 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。
7 也是一个候选， 7 = 7 。
仅有这两种组合。

class Solution(object):
    def combinationSum(self, candidates, target):
        """
        :type candidates: List[int]
        :type target: int
        :rtype: List[List[int]]
        """
        ##重点之一：去重
        ## 刚开始循环写的是for candidate in candidates,没有记录for循环的起始位置
        ##这样会导致出现[2,2,3] [3,2,2]这类重复的答案

class Solution(object):
    def combinationSum(self, candidates, target):
        """
        :type candidates: List[int]
        :type target: int
        :rtype: List[List[int]]
        """
        ##重点之一：去重
        ## 刚开始循环写的是for candidate in candidates,没有记录for循环的起始位置
        ##这样会导致出现[2,2,3] [3,2,2]这类重复的答案

        ##原始版：每次backtracking都要求sum函数，sum函数时间复杂度O(n)
        res=[]
        tmp=[]
        def backtracking(candidates,target,indx):
            if sum(tmp)==target:
                res.append(tmp[:])
                return
            if sum(tmp)>target:
                return
            for i in range(indx,len(candidates)):
                tmp.append(candidates[i])
                backtracking(candidates,target,i)##需要注意，还是要记录位置
                tmp.pop()
        
        backtracking(candidates,target,0)
        return res

        ##优化版：sum函数用一个局部变量sum_代替，相比原始版时间近乎减半
        res=[]
        tmp=[]

        def backtracking(candidates,target,indx,sum_):
            if sum_==target:
                res.append(tmp[:])
                return
            if sum_>target:
                return

            for i in range(indx,len(candidates)):
                sum_+=candidates[i]
                tmp.append(candidates[i])
                backtracking(candidates,target,i,sum_)##需要注意，还是要记录位置
                tmp.pop()
                sum_-=candidates[i]
        
        backtracking(candidates,target,0,0)
        return res

        ##剪枝优化版：排序+剪枝
        res=[]
        tmp=[]
        # sum_=0
        def backtracking(candidates,target,indx,sum_):
            if sum_==target:
                res.append(tmp[:])
                return
            if sum_>target:
                return
            # 如果本层 sum + condidates[i] > target，就提前结束遍历，剪枝
            for i in range(indx,len(candidates)):
                if sum_ + candidates[i] > target: 
                    return 
                sum_+=candidates[i]
                tmp.append(candidates[i])
                backtracking(candidates,target,i,sum_)##需要注意，还是要记录位置
                tmp.pop()
                sum_-=candidates[i]
        
        # 为了剪枝需要提前进行排序
        candidates.sort()
        backtracking(candidates,target,0,0)
        return res

剪枝优化版对比优化版来说加了排序+剪枝
对比优化版，对于sum已经大于target的情况，其实是依然进入了下一层递归，只是下一层递归结束判断的时候，会判断sum > target的话就返回。

其实如果已经知道下一层的sum会大于target，就没有必要进入下一层递归了。

那么可以在for循环的搜索范围上做做文章了。

对总集合排序之后，如果下一层的sum（就是本层的 sum + candidates[i]）已经大于target，就可以结束本轮for循环的遍历。

但是要注意的是，这种剪枝不一定更高效，因为sort()函数也要耗费时间

优化版示意图

剪枝优化版示意图

例五：40. 组合总和 II

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

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

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

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

class Solution(object):
    def combinationSum2(self, candidates, target):
        """
        :type candidates: List[int]
        :type target: int
        :rtype: List[List[int]]
        """
        #剪枝优化留着
        #还是重复问题:之前的重复问题是startindx写错，导致有了[2,2,3]还会出现[3,2,2]
        #现在的重复问题是数组本身有重复数据，需要排除重复数据影响
        res=[]
        tmp=[]
        def backtracking(candidates,target,indx,sum_):
            if sum_==target:
                res.append(tmp[:])
                return
            if sum_>target:
                return

            for i in range(indx,len(candidates)):
                if i!=indx:  ##去除重复的组合
                    if candidates[i]==candidates[i-1]:
                        continue
                # 剪枝，同39.组合总和
                if sum_ + candidates[i] > target:
                    return
                sum_+=candidates[i]
                tmp.append(candidates[i])
                backtracking(candidates,target,i+1,sum_)
                sum_-=candidates[i]
                tmp.pop()

        candidates.sort()# 必须提前进行数组排序，避免重复
        backtracking(candidates,target,0,0)
        return res

说明：

这题最难的地方在于去重，我使用的去重逻辑是
candidates.sort()# 必须提前进行数组排序，避免重复
还有在循环时
if i!=indx: ##去除重复的组合
if candidates[i]==candidates[i-1]:
continue
原理是对同一树层使用过的元素进行跳过。if i!=indx用来确定是同一树层，否则后续candidates[i-1]可能跳回到上一树层；if candidates[i]==candidates[i-1]用来判断是同一树层的相同数，continue跳过

更详细的说明：代码随想录

子集

例六.131. 分割回文串

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

回文串 是正着读和反着读都一样的字符串。
输入：s = “aab”
输出：[[“a”,“a”,“b”],[“aa”,“b”]]

class Solution(object):
    def partition(self, s):
        """
        :type s: str
        :rtype: List[List[str]]
        """
        ##回溯+函数判断回文串
        res=[]
        tmp=[]
        # s=list(s)
        
        def isreverse(ss):
            left,right=0,len(ss)-1
            while left<right:
                if ss[left]==ss[right]:
                    left+=1
                    right-=1
                else:
                    return False
            return True

        def backtracking(s,indx,n):
            if indx>=n:
                res.append(tmp[:])
                return
            for i in range(indx,n):
                if isreverse(s[indx:i+1]):
                    tmp.append(s[indx:i+1])
                    backtracking(s,i+1,n)
                    tmp.pop()

        backtracking(s,0,len(s))
        return res
        
        ##回溯+正反序判断回文串
        res=[]
        tmp=[]
        
        def backtracking(s,indx,n):
            if indx>=n:
                res.append(tmp[:])
                return
            for i in range(indx,n):
                ss=s[indx:i+1]
                if ss==ss[::-1]:
                    tmp.append(s[indx:i+1])
                    backtracking(s,i+1,n)
                    tmp.pop()

        backtracking(s,0,len(s))
        return res

例七.93. 复原 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 地址。
给定一个只包含数字的字符串 s ，用以表示一个 IP 地址，返回所有可能的有效 IP 地址，这些地址可以通过在 s 中插入 ‘.’ 来形成。你 不能 重新排序或删除 s 中的任何数字。你可以按 任何 顺序返回答案。
输入：s = “25525511135”
输出：[“255.255.11.135”,“255.255.111.35”]

class Solution(object):
    def restoreIpAddresses(self, s):
        """
        :type s: str
        :rtype: List[str]
        """
        ##探讨下0的情况
        res=[]
        tmp=[]
        n=len(s)
        if n>12: ##字符多于12个时不会有解
            return []
        def backtracking(s,indx): 
            if len(tmp)==4 and indx>=n:
                res.append(".".join(tmp[:]))
                return
            if len(tmp)>4: #
                return
            for i in range(indx,n):
                string=s[indx:i+1]
                if  string != "0" and string.lstrip('0') != string: #Python lstrip() 方法用于截掉字符串左边的空格或指定字符。
                    continue
                #这个部分说明string != "0"且左边存在'0'，比如“01”这种含有前导 0的例子，此时continue代表跳过
                if int(string)>=0 and int(string)<=255:
                    tmp.append(s[indx:i+1])
                    backtracking(s,i+1)
                    tmp.pop()

        backtracking(s,0)
        return res

例八:78. 子集

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

解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。
输入：nums = [1,2,3]
输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]

class Solution(object):
    def subsets(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        #去重
        res=[]
        tmp=[]
        n=len(nums)
        res.append([])

        def backtracking(indx,n):
            if indx>=n:
                # res.append(tmp[:])
                return
            for i in range(indx,n):
                tmp.append(nums[i])
                res.append(tmp[:])
                backtracking(i+1,n)
                tmp.pop()

        backtracking(0,n)
        return res

说明：

一样的框架和步骤，只不过换成把中间的过程值当成结果存起来

例九：90. 子集 II

给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。

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

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

class Solution(object):
    def subsetsWithDup(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        #跟子集问题比较起来，需要去下重
        res=[]
        tmp=[]
        n=len(nums)
        nums.sort()

        res.append([])

        def backtracking(indx,n):
            if indx>=n:
                return
            for i in range(indx,n):
                if i!=indx:
                    if nums[i]==nums[i-1]:
                        continue
                tmp.append(nums[i])
                res.append(tmp[:])
                backtracking(i+1,n)
                tmp.pop()

        backtracking(0,n)
        return res

说明

跟78.子集问题比较，多了一个去重的步骤，这个去重的步骤和40.组合总和问题的去重方法一致，对同一树层使用过的元素进行跳过

             if i!=indx:  ##去除重复的组合
                if candidates[i]==candidates[i-1]:
                    continue

原理是对同一树层使用过的元素进行跳过。if i!=indx用来确定是同一树层，否则后续candidates[i-1]可能跳回到上一树层；if candidates[i]==candidates[i-1]用来判断是同一树层的相同数，continue跳过

例十：491. 递增子序列

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

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

输入：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(object):
    def findSubsequences(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        ##本题首先不能排序，因为要求不同的递增子序列
        ##同时要关注重复元素的去重，难点在怎么去除
        ##此时可以引入额外的数组来记录
        ## 同一父节点下的同层上使用过的元素就不能在使用了
        res=[]
        tmp=[]
        n=len(nums)

        def backtracking(indx,n):
            if indx>=n:
                return

            store=[]
            for i in range(indx,n):
                if nums[i] not in store:
                    store.append(nums[i])
                else:
                    continue
                if tmp:
                    if nums[i]>=tmp[-1]:
                        tmp.append(nums[i])
                    else:
                        continue
                else:
                    tmp.append(nums[i])
                if len(tmp)>=2:
                    res.append(tmp[:])
                backtracking(i+1,n)
                tmp.pop()

        backtracking(0,n)
        return res

说明

    ##本题首先不能排序，因为要求不同的递增子序列
    ##同时要关注重复元素的去重，同一父节点下的同层上使用过的元素就不能在使用了，难点在怎么去除
    ##此时可以引入额外的数组来记录
    ## # 深度遍历中每一层都会有一个全新的store数组用于记录本层元素是否重复使用

全排列

例十一：46. 全排列

给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。
输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

class Solution(object):
    def permute(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        res=[]
        tmp=[]
        n=len(nums)

        def backtracking(n):
            if len(tmp)==n:
                res.append(tmp[:])
                return

            for i in range(n):
                if nums[i] in tmp:
                    continue
                tmp.append(nums[i])
                backtracking(n)
                tmp.pop()

        backtracking(n)
        return res

说明：

此时由于是求全排列，不用再记录在集合当中的位置。以nums = [1,2,3]为例，

            for i in range(n):
                tmp.append(nums[i])
                backtracking(n)
                tmp.pop()

可以得到有重复元素的全排列

[[1,1,1],[1,1,2],[1,1,3],[1,2,1],[1,2,2],[1,2,3],[1,3,1],[1,3,2],[1,3,3],[2,1,1],[2,1,2],[2,1,3],[2,2,1],[2,2,2],[2,2,3],[2,3,1],[2,3,2],[2,3,3],[3,1,1],[3,1,2],[3,1,3],[3,2,1],[3,2,2],[3,2,3],[3,3,1],[3,3,2],[3,3,3]]

按照题目要求，需要去掉[[1,1,1],[1,1,2],[1,1,3]等有重复元素的答案，所以添加条件

                if nums[i] in tmp:
                    continue

例十二：47. 全排列 II

给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。
输入：nums = [1,1,2]
输出：
[[1,1,2],
[1,2,1],
[2,1,1]]

class Solution(object):
    def permuteUnique(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        ## 有逻辑错误的版本
        res=[]
        tmp=[]
        n=len(nums)
        used=[]

        def backtracking(n):
            if len(tmp)==n:
                res.append(tmp[:])
                return
            store=[]#去除同层同元素的重复
            for i in range(n):
                if i in used: #在一种可能的组合中，用过的元素在下一次列举中不能再用
                    continue
                if i in store: 
                    continue
                tmp.append(nums[i])
                used.append(i)
                store.append(i)
                backtracking(n)
                tmp.pop()
                used.pop()

        backtracking(n)
        return res
        
        ## 正确的版本
        res=[]
        tmp=[]
        n=len(nums)
        used=[]

        def backtracking(n):
            if len(tmp)==n:
                res.append(tmp[:])
                return
            store=[]#去除同层同元素的重复
            for i in range(n):
                if i in used: #在一种可能的组合中，用过的元素zia不能再用
                    continue
                if nums[i] not in store:
                    store.append(nums[i])
                else:
                    continue
                tmp.append(nums[i])
                used.append(i)
                backtracking(n)
                tmp.pop()
                used.pop()

        backtracking(n)
        return res        

说明：

这题的难点同样在于去重，而且分为两类去重，一类是#去除同层同值元素的重复，一类是#在一种可能的组合中，用过的元素在下一次列举中不能再用。分别用store和used数组记录同层同值元素 和用过的元素位置（防止在下一次列举中再次用到此元素）。store存的是元素值，used存的是元素位置。

以[1,1,2]为例加以说明，used数组是为了防止出现[1,1,1]之类答案，即多次使用同一元素；store数组是为了防止出现[1,1,2] [1,1,2]之类因为数组中下标0，1位置是相同元素而出现的重复答案

例二：306. 累加数

306. 累加数
这题和上一题是同样的逻辑，但是相比上一题更绕脑子。
首先分个三步走：

一、需要确定的变量。

num一定需要；用于指向当前所在数字的索引index;
数当前是第几个可行数的count(只有count>2,才符合累加数的条件)；
还有就是指向前前个数的prevprev和前个数的prev，还有当前正在确定的数current

二、单层逻辑

先假设当前数current是0，i从指向当前所在数字的索引index取到len(num)，把num[i]转成int，尝试附在current后，current=current*10+int(num[i])。在有效数大于等于两个时，即count>=2时，如果当前current<(prevprev+prev)，说明当前取的数还不够大，有可能是需要取到下一个数，所以继续循环；如果current>(prevprev+prev)，说明当前数不合格，直接return False。
而在count<2或者current==(prevprev+prev)的情况，则需要判断if dfs(num,i+1,count+1,prev,current)
以“199100”为例，如果count<2，先把初始数“1”当作独立的一个数，然后再把之后的“9”当作独立的一个数，prevprev=1,prev=9,current=9,此时current>(prevprev+prev)，所以return False，即dfs(num,2,2,9,9)为False，for循环继续，current变成99，继续往下
current==(prevprev+prev)的情况，继续往下搜

三、退出递归的条件

当index>=len(num)且count>2，说明得以正常退出，return True
如果到了index>=len(num)，还不满足有效数大于2，return False(比如"19910")

class Solution(object):
    def isAdditiveNumber(self, num):
        """
        :type num: str
        :rtype: bool
        """

        n=len(num)
        # if n<3:
        #     return False

        def dfs(num,index,count,prevprev,prev):
            if index>=len(num):
                if count>2:
                    return True
                else:
                    return False
                # return count>2

            current=0
            for i in range(index,len(num)):
                c=num[i]
                if num[index]=='0' and i>index:
                    return False

                current=current*10+int(c)

                if count>=2:
                    if current>(prevprev+prev):
                        return False
                    if current<(prevprev+prev):
                        continue

                if dfs(num,i+1,count+1,prev,current):
                    return True
               
            return False

        return dfs(num,0,0,0,0)

例三：1980. 找出不同的二进制字符串

1980. 找出不同的二进制字符串
这题之前做的时候是直接暴力解决的，也能过，就是时间消耗大。
首先，如果n==2**length，说明表中互不相同 的二进制字符串齐全了，返回None
否则，首先生成n位二进制的全排列，如果全排列中的数在num中不存在，就可以作为答案

方法一：暴力解法

def findNearstZero(temp,n,perm):
	for i in range(n-2,-1,-1):
		if temp[i]=='0':
			temp[i]='1'
			for j in range(i + 1, n):
				temp[j]='0'
			perm.append(''.join(temp))
			break
            
class Solution(object):
    def findDifferentBinaryString(self, nums):
        """
        :type nums: List[str]
        :rtype: str
        """
        n=len(nums)
        length=len(nums[0])

        if n==2**length:
            return None

        #生成n位二进制的全排列

        perm=[]
        temp=""
        for i in range(length):
            temp=temp+"0"
        perm.append(temp) #初始化temp\perm为length长个0

        temp = list(temp)
        # # #生成具有n长，所有元素的哈希表
        for i in range(2**length):
            if temp[length-1]=='0':
                temp[length-1]='1'
                perm.append(''.join(temp))  #首先把最末尾的数字变1，放到perm中去

            else:
                findNearstZero(temp,length,perm) #如果最末尾已经是1了，在往前找最靠近末尾的0，把它翻成1，并把结果放在perm中


        for j in perm: #如果全排列中的数在num中不存在，就可以作为答案
            if j not in nums:
                return j

当然，上面的代码可以进一步优化，比如不用perm把每一次排列的结果存起来，而是每次得到一个可行的排列数，就判断它是否在nums中。但是由于重点是回溯法，就不改了

方法二：回溯法

这题和例一非常相似，只改了for循环的次数和退出条件。
for循环：由于横向遍历每次都只用在0，1中选一个数，所以写成for i in range(2)；
退出条件：depth作为深度搜索的输入变量，刚开始depth=0，之后每取一个数depth+1，depth用于判断一个字段是否足够长度，或者当path的长度达到length也可以判断一个字段是否足够长度，所以depth==length and len(path)==length可以只选用一个作为判断条件，因为两者同时达到要求。tmp用来记录生成的每个字段，比如如果nums=[“00”,“01”]，tmp会依次变成“00”、“01”、“10”，到“10”时，由于tmp not in nums，所以return tmp
！！！这里要注意，return tmp不是return 到dfs(0)，而是return 到dfs(2)，所以需要用returnnum接住dfs(2)的返回值，再返回到dfs(0)

class Solution(object):
    def findDifferentBinaryString(self, nums):
        """
        :type nums: List[str]
        :rtype: str
        """
        n=len(nums)
        length=len(nums[0])

        if n==(1<<length):
            return None
        
        path=[]
        # nums_compet=[]  #生成n位二进制的全排列
        def dfs(depth):
            if depth==length and len(path)==length:
                # print(path)
                tmp=""
                for k in path:
                    tmp+="".join(str(k))
                
                # print(tmp)
                if tmp not in nums:
                    return tmp
                # nums_compet.append(path[:])
                return
            for i in range(2):
                path.append(i)
                returnnum=dfs(depth+1)
                if returnnum!=None:
                    return returnnum
                path.pop()

        return dfs(0)

例四：2151. 基于陈述统计最多好人数

2151. 基于陈述统计最多好人数

方法一：二进制枚举

二进制遍历各种好人和坏人的可能性，然后提取出预设正确的中，好人数最多的预设

i代表对好人和坏人的一种预设，假设1代表好人，0代表坏人，从000……0到111……1 （长度为len(statements)），一共有2**len(statements)种可能。
只要存在二进制预设的真实值和提供的statements不符和，则预设错误 （any函数）；否则预设正确，好人数加一；
返回正确预设中的最大好人数。

class Solution(object):
    def maximumGood(self, statements):
        """
        :type statements: List[List[int]]
        :rtype: int
        """
        def check(i):
            cnt=0

            for j,row in enumerate(statements):
                if (i>>j)&1:
                    if any((st<2 and st!=(i>>k)&1) for k,st in enumerate(row)):
                        return 0 #只要存在二进制预设的真实值和提供的statements不符和，则预设错误 （any函数）
                    cnt+=1 #否则预设正确，好人数加一
            return cnt #返回最大好人数


        return max(check(i) for i in range(1,1<<len(statements)))#返回正确的二进制预设中，好人数最多的预设

代码参考自力扣题解
需要注意的地方有 1<<len(statements) ，等价于2**len(statements)，但效率更高；
还有 (i>>j)&1 ，i>>j表示i（二进制表示）右移j位，左边空出的位补0；(i>>j)&1表示取出 i 二进制中第 j 位的值。也即表示取出第j个人是好人还是坏人的标志

方法二：回溯法

待补充

参考

【1】力扣
【2】代码随想录