leetcode刷题记录：算法（七）回溯法

回溯法（Back Tracking Method）：

• 回溯法（探索与回溯法）是一种选优搜索法，又称为试探法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点”。

当问题是要求满足某种性质（约束条件）的所有解或最优解时，往往使用回溯法。

运用回溯法解决问题有以下三个要点：

1. 针对给定的问题，定义问题的解空间；
2. 确定易于搜索的解空间结构（图或者树）；
3. 以深度优先方式搜索解空间，并且在搜索过程中用剪枝函数避免无效搜索。

其实回溯法就是加了条件的DFS。
DFS一次性会将所有内容遍历一遍，但是在实际操作中，这样可能浪费资源，剪枝函数就是干这个的。
所以我个人理解：回溯法=DFS+剪枝函数

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

输入：n = 3
输出：[
“((()))”,
“(()())”,
“(())()”,
“()(())”,
“()()()”
]
这道题我写的好复杂……
我感觉我是用暴力解出来的，而不是回溯，回溯条件做的不太行，容我思考一下

class Solution:
    def generateParenthesis(self, n: int) -> List[str]:
        res = []
        cur=''
        self.backtracking(n, cur, res)
        return res
    # 回溯函数
    def backtracking(self, n, cur, res):
        cout_left = cur.count('(')
        cout_right = cur.count(')')
        if cout_left > n or cout_right > n:
            return
        if len(cur) == 2 * n:
            if self.detect(cur):
                res.append(cur)
            else:
                return
        cur += '('
        count += 1
        self.backtracking(n, cur, res)
        cur = cur[:-1]
        count -= 1
        cur += ')'
        self.backtracking(n, cur, res)
    # 检测函数，检测s是否符合要求
    def detect(self, s):
        left = 0
        for i in range(len(s)):
            if s[i] == '(':
                left += 1
            elif s[i] == ')':
                left -= 1
            if left < 0:
                return False
        return True

我写的代码问题主要有为：没有裁剪多余的分枝。
在回溯的过程中是有一些限制条件的，我没有提炼出来，只用了cur.count进行筛选，这其中浪费了大量的资源。
仔细分析题目，可以得出限制条件：

1. left<n的情况下，才可以添加（
2. right<left的情况下，才可以添加 ）

只要满足这两个条件，那么最后得到的字符串，一定符合要求，所以也不需要detect函数。
精简后的代码：

class Solution:
    def generateParenthesis(self, n: int) -> List[str]:
        res = []
        cur=''
        self.backtracking(n, 0, 0, cur, res)
        return res
    # 回溯函数
    def backtracking(self, n, left, right, cur, res):
    '''
    n:括号对数
    left：当前字符串左括号的个数
    right:当前字符串右括号的个数
    cur：当前字符串
    res：结果保存的列表
    '''
        if len(cur) == 2 * n:
                res.append(cur)
        if left < n:
            cur += '('
            # 这里有一个挺重要的思想，就是传入left+1，而不是将left+=1后在传入
            # 因为如果回溯不成功，相当于这步操作要取消的，如果先进行了+=，后面还要取消，增加了代码的复杂情况
            self.backtracking(n, left+1, right, cur, res)
            cur = cur[:-1]
        if right < left:
            cur += ')'
            self.backtracking(n, left, right+1, cur, res)

执行用时：44 ms, 在所有 Python3 提交中击败了60.58%的用户
内存消耗：13.5 MB, 在所有 Python3 提交中击败了57.92%的用户

查看官方给出的答案，代码差不多了，但是时间还有差距，是否是定义位置的问题？
将回溯函数定义到内部，果然，时间快了一些，变成了40ms，击败80.78%的用户：

class Solution:
    def generateParenthesis(self, n: int) -> List[str]:
        res = []
        cur=''
    	# 回溯函数
        def backtracking(left, right, cur):
            if len(cur) == 2 * n:
                    res.append(cur)
            if left < n:
                cur += '('
                backtracking(left+1, right, cur)
                cur = cur[:-1]
            if right < left:
                cur += ')'
                backtracking(left, right+1, cur)
        backtracking(0, 0, cur)
        return res

78.子集
给定一组不含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。

说明：解集不能包含重复的子集。

示例:

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

这道题由于我看视频的时候饲养员up讲过，所以写起来很顺手了，随手就是击败99%

class Solution:
    def subsets(self, nums: List[int]) -> List[List[int]]:
        # sublist=[[]]
        # for num in nums:
        #     sublist+= [sub+[num] for sub in sublist]
        # return sublist
        res = []
        cur = []
        def backtracking(length, index, cur):
            if len(cur) == length:
                res.append(cur[:])
                return
            for i in range(index, len(nums)):
                cur.append(nums[i])
                backtracking(length, i+1, cur)  
                cur.pop()         
        for length in range(len(nums)+1):
            backtracking(length, 0, cur)
        return res

77.组合
这道题和子集几乎是一样的，稍作修改就可以了，不多分析了。

class Solution:
    def combine(self, n: int, k: int) -> List[List[int]]:
        res = []
        cur = []
        def backtracking(length, index, cur):
            if len(cur) == length:
                res.append(cur[:])
                return
            for i in range(index, n+1):
                cur.append(i)
                backtracking(length, i+1, cur)  
                cur.pop()         
        backtracking(k, 1, cur)
        return res

46.全排列
这道题是思路也很简单，就是高中排列组合里的排列。
当长度为n时，代码思路就是：

1. 取数组中第i=1个数，放进列表
2. 在第1~n中（不含i）取第k个数，放进列表，
3. 在第1~n中（不含i和k），取……
4. 排列完成以后，i+1，从第一步开始继续，直至遍历结束。

容易理解，我们需要维护一个当前已经排列完毕的数的下标组成的数组。

class Solution:
    def permute(self, nums: List[int]) -> List[List[int]]:
        length = len(nums)
        res = []
        def backtracking(index, cur):
        	# 经典判别条件，当排列完成后，cur长度为length
            if len(cur) == length:
                res.append(cur[:])
                return
            for i in range(length):
                if i not in cur_index :
                    cur.append(nums[i])
                    cur_index.append(i)
                    backtracking(i, cur)  
                    cur.pop()  
                    cur_index.pop()
        for i in range(length):
        	# 每次开始回溯，cur置空，一共进行length次回溯
            cur = []
            # 当前已经排列好的数的下标，存在这个列表里
            cur_index = []
            # 将第一个数填进去
            cur.append(nums[i])
            # 下标随之更新
            cur_index.append(i)
            backtracking(i, cur)
        return res

OK，搞定。
感觉回溯法套路还是很固定的，至少我做的这四道题里，有如下特点：

1. 需要额外写一个回溯函数

2. 回溯函数的第一部分为判别条件（以这几道题为例，条件都是数组的长度）

3.  cur_index.append(i)
    backtracking(i, cur)  
    cur.pop()  
   

   这三句几乎必有，就是改变一下当前处理的对象——进行回溯——将回溯对象复位

4. 必然存在cur：当前正在处理的对象；res：保存结果的列表