代码随想录｜回溯算法（终回）

 * 491.递增子序列

* 46.全排列

* 47.全排列 II

332.重新安排行程 

51. N皇后

37. 解数独 

总结 

---

491.递增子序列

注意使用set来判断这一层是否有用过相同的数字，因为这题的数不是order的，所以不能和前者相对比

在python中的set使用add来增加

class Solution:
    def findSubsequences(self, nums: List[int]) -> List[List[int]]:
        result = []
        ans_now = []
        self.combination(nums, result, ans_now, 0)
        return result
    
    def combination(self, nums, result, ans_now, index):
        if (len(ans_now) >= 2):
            result.append(ans_now[:])
        used = set()
        for i in range(index, len(nums)):
            if(index > 0 and nums[index-1] > nums[i]):
                continue
            if(nums[i] in used):
                continue
            used.add(nums[i])
            ans_now.append(nums[i])
            self.combination(nums, result, ans_now, i+1)
            ans_now.pop()
        return 

---

46.全排列

class Solution:
    # def backtrack(self, use_list, num_left, now_list):
    #     if num_left == 0:
    #         self.answer.append(now_list)
    #         return 
    #     for i in range(self.n):
    #         if use_list[i]:
    #             use_list[i] = False
    #             now_list.append(self.nums[i])
    #             self.backtrack(use_list, num_left-1, now_list[:])
    #             now_list.pop()
    #             use_list[i] = True
            
    
    # def permute(self, nums: List[int]) -> List[List[int]]:
    #     self.nums = nums
    #     self.answer = []
    #     self.n = len(nums)
    #     use = [True for _ in range(self.n)]
    #     self.backtrack(use, self.n, [])
    #     return self.answer


    def permute(self, nums: List[int]) -> List[List[int]]:
        result = []
        now_ans = []
        use = [True for _ in range(len(nums))]
        self.backtrack(use, result, now_ans, nums)
        return result
    
    def backtrack(self, use, result, now_ans, nums):
        if len(now_ans) == len(nums):
            result.append(now_ans[:])
            return 
        for i in range(len(nums)):
            if (use[i]):
                now_ans.append(nums[i])
                use[i] = False
                self.backtrack(use, result, now_ans, nums)
                use[i] = True
                now_ans.pop()
        return

---

47.全排列 II

遇到重复问题

从树的每一层解决源头性问题

使用used的表格

class Solution:
    def permuteUnique(self, nums: List[int]) -> List[List[int]]:
        ans = []
        result = []
        use = [False for _ in nums]
        self.backtracking(nums, ans, result, use)
        return result

    def backtracking(self, nums, ans, result, use):
        if len(ans) == len(nums):
            result.append(ans[:])
            return 
        
        used = set()
        for i in range(len(nums)):
            if ((nums[i] in used) or use[i] ):
                continue
            used.add(nums[i])

            use[i] = True
            ans.append(nums[i])
            self.backtracking(nums, ans, result, use)
            use[i] = False
            ans.pop()

            

 

---

332.重新安排行程

依旧采用树的思想

想明白什么时候应该回溯

什么时候应该直接通过

可以考虑说返回bool类型进行判断

注意可以直接用sort进行排序

class Solution:
    def findItinerary(self, tickets: List[List[str]]) -> List[str]:
        tickets.sort()
        used = [True for _ in range(len(tickets))]
        result = ['JFK']

        self.backtracking(tickets, used, result, 'JFK',0)
        return result

    
    def backtracking(self, tickets, used, result, now, num):
        if(num == len(tickets)):
            return True

        for i in range(len(tickets)):
            temp = tickets[i]

            if used[i] and temp[0] == now:

                used[i] = False
                result.append(temp[1])
                if(self.backtracking(tickets, used, result, temp[1], num+1)):
                     return True
                result.pop()
                used[i] = True
        
        return False
        
                
                

from collections import defaultdict

class Solution:
    def findItinerary(self, tickets):
        targets = defaultdict(list)  # 创建默认字典，用于存储机场映射关系
        for ticket in tickets:
            targets[ticket[0]].append(ticket[1])  # 将机票输入到字典中
        
        for key in targets:
            targets[key].sort(reverse=True)  # 对到达机场列表进行字母逆序排序
        
        result = []
        self.backtracking("JFK", targets, result)  # 调用回溯函数开始搜索路径
        return result[::-1]  # 返回逆序的行程路径
    
    def backtracking(self, airport, targets, result):
        while targets[airport]:  # 当机场还有可到达的机场时
            next_airport = targets[airport].pop()  # 弹出下一个机场
            self.backtracking(next_airport, targets, result)  # 递归调用回溯函数进行深度优先搜索
        result.append(airport)  # 将当前机场添加到行程路径中

可以使用字典的倒叙进行解决这题， 并且可以使用pop和append进行机票是否使用的

---

51. N皇后

典中典的题目 哈哈哈

一次过

class Solution:
    # def checking(self, now, ans):
    #     n = len(ans)
    #     if n == 0:
    #         return True
    #     if now in ans:
    #         return False
    #     for i in range(n):
    #         if ans[i] == (now-n+i) or ans[i] == (now+n-i):
    #             return False
    #     return True

    # def backtracking(self, ans, used):
    #     #print(ans)
    #     if len(ans) == self.n:
    #         self.solution.append(ans)
    #         return 
    #     for i in range(self.n):
    #         if self.checking(i, ans):
    #             used[i] = True
    #             ans.append(i)
    #             self.backtracking(ans[:], used[:])
    #             used[i] = False
    #             ans.pop()
        
    # def solveNQueens(self, n: int) -> List[List[str]]:
    #     self.solution = []
    #     self.n = n
    #     used = [False for _ in range(n)]
    #     self.backtracking([], used)
    #     answer = []
    #     for i in self.solution:
    #         single_ans = []
    #         for j in i:
    #             line = "."*(j) + 'Q' + '.'*(n-j-1)
    #             single_ans.append(line)
    #         answer.append(single_ans)
    #     return answer

    def solveNQueens(self, n: int) -> List[List[str]]:
        result = []
        ans = []
        self.backtracking(result, ans, n)
        results = []
        for i in range(len(result)):
            temp = []
            for j in result[i]:
                s = "."*(j)+'Q'+'.'*(n-1-j)
                temp.append(s)
            results.append(temp[:])

        return results
    
    def backtracking(self, result, ans, n):
        if len(ans) == n:
            result.append(ans[:])
            return 
        for i in range(n):
            if self.checking(ans, i, n):
                ans.append(i)
                self.backtracking(result, ans, n)
                ans.pop()
        return 
    
    def checking(self, ans, k, n):
        if k in ans:
            return False
        l = len(ans)
        for i in range(l):
            left = k-i-1
            if left >= 0 and ans[l-i-1] == left:
                return False
            right = k+i+1
            if right < n and ans[l-i-1] == right:
                return False
        return True

 

---

37. 解数独

class Solution:
    def solveSudoku(self, board: List[List[str]]) -> None:
        """
        Do not return anything, modify board in-place instead.
        """
        self.backtracking(0,0,board)
    
    def isValid(self, row, col, ch, board):
        row, col = int(row), int(col)
        for i in range(9):

            if board[i][col] == ch:
                return False

            if board[row][i] == ch:
                return False

            if board[3*(row//3)+i//3][3*(col//3)+i%3] == ch:
                return False

        return True

    def backtracking(self, row, col, board):
        if row == 9:
            return True

        if col == 9:
            return self.backtracking(row+1, 0, board)

        if board[row][col] == '.':

            for i in range(1, 10):
                if self.isValid(row, col, str(i), board):
                    board[row][col] = str(i)

                    if self.backtracking(row, col+1, board):
                        return True
                        
                    board[row][col] = '.'
            return False
        else:
            return self.backtracking(row, col+1, board)
                
    

 

 

 

 

---

总结

子集问题分析：一定要排序后去重

• 时间复杂度：$O(n × 2^n)$，因为每一个元素的状态无外乎取与不取，所以时间复杂度为$O(2^n)$，构造每一组子集都需要填进数组，又有需要$O(n)$，最终时间复杂度：$O(n × 2^n)$。
• 空间复杂度：$O(n)$，递归深度为n，所以系统栈所用空间为$O(n)$，每一层递归所用的空间都是常数级别，注意代码里的result和path都是全局变量，就算是放在参数里，传的也是引用，并不会新申请内存空间，最终空间复杂度为$O(n)$。

排列问题分析：

• 时间复杂度：$O(n!)$，这个可以从排列的树形图中很明显发现，每一层节点为n，第二层每一个分支都延伸了n-1个分支，再往下又是n-2个分支，所以一直到叶子节点一共就是 n * n-1 * n-2 * ..... 1 = n!。每个叶子节点都会有一个构造全排列填进数组的操作（对应的代码：result.push_back(path)），该操作的复杂度为$O(n)$。所以，最终时间复杂度为：n * n!，简化为$O(n!)$。
• 空间复杂度：$O(n)$，和子集问题同理。

组合问题分析：

• 时间复杂度：$O(n × 2^n)$，组合问题其实就是一种子集的问题，所以组合问题最坏的情况，也不会超过子集问题的时间复杂度。
• 空间复杂度：$O(n)$，和子集问题同理。