数据结构算法刷题（28）回溯组合型和全排列

剪枝技巧：

 

 思路：剪枝的特点是找特定长度的子集。首先确定大框架，当path的长度等于k的时候，就要更新答案并且return。然后在进行path的元素选择，这里采用倒叙，从i到d（d=k-len(path)）倒着加入path中。

class Solution:

    def combine(self, n: int, k: int) -> List[List[int]]:

        path = []

        ans = []

        def dfs(i):

            d = k - len(path)

            # if i < d:

            #     return

            if len(path) == k:

                ans.append(path.copy())

                return

            for j in range(i,d-1,-1):

                path.append(j)

                dfs(j-1)

                path.pop()

        dfs(n)

        return ans

 思路：首先在[1,9]中选出不同的k个元素的子集，如果sum(path)==n,就更新答案。其余都是剪枝的套路代码。

class Solution:

    def combinationSum3(self, k: int, n: int) -> List[List[int]]:

        nums = [i for i in range(1,10)]

        ans = []

        path = []

        def dfs(i):

            d = k - len(path)

            if len(path) == k:

                if sum(path) == n:

                    ans.append(path.copy())

                return

            for j in range(i,d-1,-1):

                path.append(j)

                dfs(j-1)

                path.pop()

        dfs(len(nums)) #传入子集的总的区间长度

        return ans

思路：相当于从2n个位置上，选择n个位置放置左括号，但是左右括号是有约束的，左括号不能超过n，右括号不能超过左括号。当把这2n个位置填完，就更新答案。因为左括号的个数也是约束条件，所以和函数一起递归。

 

class Solution:

    def generateParenthesis(self, n: int) -> List[str]:

        #可以看成2n个位置上，选择(填入还是选择)填入

        ans = []

        m = n*2

        path = ['']*m

        def dfs(i,numofleft):

            if i == m:

                ans.append(''.join(path))

                return

            if numofleft < n:#左括号最大是n

                path[i] = '('

                dfs(i+1,numofleft+1)

            if i - numofleft < numofleft: #右括号的个数不能超过左括号

                path[i] = ')'

                dfs(i+1,numofleft)

        dfs(0,0)

        return ans

思路：在每一个位置上，选择一个数填入，但是该数和前面的数不能相同，维护一个s，来存放当前可以选的数字，每次加入path之后，就把该数字减去。

class Solution:

    def permute(self, nums: List[int]) -> List[List[int]]:

        ans = []

        path = []

        n = len(nums)

        def dfs(i,s):

            if i == n:

                ans.append(path.copy())

                return

            for x in s:

                path.append(x)

                dfs(i+1,s-{x})

                path.pop()

        dfs(0,set(nums))

        return ans

 或者维护一个是否在路径中的list，当list中相应的位置是Fasle,就输入path，然后恢复现场。

class Solution:

    def permute(self, nums: List[int]) -> List[List[int]]:

        ans = []

        path = []

        n = len(nums)

        on_path = [False]*n

        def dfs(i):

            if i == n:

                ans.append(path.copy())

                return

            for j in range(n):

                if not on_path[j]:

                    path.append(nums[j])

                    on_path[j] = True

                    dfs(i+1)

                    on_path[j] = False #恢复现场

                    path.pop() #恢复现场

        dfs(0)

        return ans

 

 

 思路：皇后要在每一行都放置一个，那我们来递归行数，正确答案就应该是确定的一个列的顺序。之前的path就相当于cols，用全排列的方式，将行数和可以选择的列传入递归中。有两个点：

第一如何构造答案：在cols之前，有cols个. 在其之后有(n-1-cols)个.中间再拼接上Q。

第二是如何避免对角线打架：因为我们是按照从上到下的行数来放置的，所以只需要考虑左上方和右上方的数据，左上方和皇后位置的行列和一致，右上方和皇后位置的行列差一致。计算当前行列和、行列差，与cols中已经有的行列和、行列差对比。

class Solution:

    def solveNQueens(self, n: int) -> List[List[str]]:

        #每一行都要放置一个皇后，那就在于，这个列的排序

        ans = []

        cols = [0]*n

        def dfs(i,s):#把行数和当前可以选择的列传进去

            if i == n:

                ans.append(['.'*c + 'Q'+'.'*(n-1-c) for c in cols]) #对于每一个结果，拼接ans

                return

            for j in s: #枚举列

                if all( j+i != cols[I] + I  and j-i != cols[I] - I for I in range(i)):#这里要保证不在一个对角线上，cols[I]就是有皇后的位置的列。

                    cols[i] = j

                    dfs(i+1,s-{j})

        dfs(0,set(range(n)))

        return ans

class Solution:

    def removeInvalidParentheses(self, s: str):

        ans = []

        path = []

        n = len(s)

        res_length = -1

        st = []

        def dfs(i):

            nonlocal res_length

            if i == n:

                if st == []: #栈空，有效字符串

                    if res_length == -1: #首次递归到的一定是最大长度的有效子集

                        res_length = len(''.join(path)) #更新最大长度

                    if len(''.join(path)) == res_length: #如果当前的path是最大长度，就加入答案

                        ans.append(''.join(path))

                return

#剪枝，n-i是没有选的长度+len(path)选择的长度 如果小于最大子集，就直接剪枝。

            if n - i + len(path) < res_length:

                return

            if s[i] not in '()': #字母直接加

                path.append(s[i])

                dfs(i+1)

                path.pop()

            else:

                path.append(s[i]) #先记录路径（先选，尽最大可能选）

                if s[i] == '(':

                    st.append(s[i]) #左括号入栈，然后递归

                    dfs(i+1)

                    st.pop() #恢复现场

                if s[i] == ')' and len(st) > 0: #右括号而且栈不是空

                    last = st.pop() #出栈，然后递归

                    dfs(i+1)

                    st.append(last) #恢复现场

                path.pop() #恢复现场

                dfs(i+1) #不选

        dfs(0)

        return list(set(ans))