Note:五大算法——回溯算法

文章目录

  • Key point
      • 回溯算法框架
  • 全排列问题
    • 代码
  • N皇后问题
    • 代码
        • reference

Key point

解决一个回溯问题,实际上就是一个决策树的遍历过程。

围绕3个问题去展开:

  • 路径:指已经做出的选择
  • 选择列表:当前面临的选择
  • 结束条件:到达决策树底层时,无法再做选择的条件

经典题目
全排列、N皇后问题

回溯算法框架

result = []
def backtrack(路径, 选择列表):
    if 满足结束条件:
        result.add(路径)
        return

    for 选择 in 选择列表:
        做选择
        backtrack(路径, 选择列表)
        撤销选择
'''
核心就是for循环中的递归。
在递归之前“做选择”,在递归之后“撤销选择”
'''

全排列问题

知道n个不重复的数,全排列共有 n! 个

注:为了方便理解,全排列问题先不包含重复的数字

当我们对 [1,2,3] 进行全排列时,首先想到的的是穷举,大致流程图如下:
Note:五大算法——回溯算法_第1张图片
先固定第一位,然后接着选择第二位、第三位。展开后就是一颗决策树。而上面说过,回溯问题就是一个决策树遍历的问题。

如果用上面的框架解释:图中红色2就是【路径】,记录已经做过的选择;[1,3] 就是【选择列表】,表示你当前可以做出的选择;【结束条件】是遍历到树的叶子节点,就是选择列表为空的时候。
Note:五大算法——回溯算法_第2张图片
此处定义的backtrack函数可以看做是指针,在这颗树上游走,同事要正确维护每个节点的属性,每当走到树的底层时,其【路径】就是一个全排列。

  • 决策树上的游走可以采用前序遍历和后序遍历
  • 前序遍历:在进入某一个节点之前的那个时间点执行
  • 后序遍历:在离开某个节点之后的那个时间点执行

【路径】和【选择】作为每个节点的属性,在执行前序后序遍历时,要做出相应的动作—— 做选择撤销选择
Note:五大算法——回溯算法_第3张图片

代码

class Solution:
    def permute(self, nums):
        '''
        路径:存放在track中
        选择列表:nums中不在track的元素
        结束条件:nums中的元素全部在track中出现
        '''
        def backtrack(nums, track):
            # 触发结束条件
            if len(nums) == len(track):
                res.append(track[:])
                return 
                
            for i in range(len(nums)):
                # 排除不合法的选择
                if nums[i] in track:
                    continue
                # 做选择
                track.append(nums[i])
                # 进入下一层决策树
                backtrack(nums, track)
                # 撤销选择
                track.pop()
                        
        res = []
        track=[]
        backtrack(nums, track)
        return res

note: 代码重在理解框架,效率不会很高。但不管怎么优化,都符合回溯框架,而且时间复杂度都不可能低于 O(N!),因为穷举整棵决策树是无法避免的。这也是回溯算法的一个特点,不像动态规划存在重叠子问题可以优化,回溯算法就是纯暴力穷举,复杂度一般都很高。

N皇后问题

题目:给你一个 N×N 的棋盘,让你放置 N 个皇后,使得它们不能互相攻击。(皇后可以攻击同行、同列、同一条斜线)

如图为N=8的放置方法。
Note:五大算法——回溯算法_第4张图片
用回溯框架去看,将棋牌比作一个决策树。

  • 决策树的每一层表示棋牌上的每一行;
  • 每个节点做选择 就是在该行的任意一列放置一个皇后。
  • 当行超过棋盘最后一行就结束

代码

class Solution(object):
    def solveNQueens(self, n):
        '''
        "."表示空,‘Q’表示皇后,初始化空棋盘
        '''
        board = [['.']* n for _ in range(n)]
        res = []

        '''
        路径:board 中小于row的那些行都已经成功放置了皇后
        选择列表:第 row 行的所有列都是放置皇后的选择
        结束条件:row 超过 board 的最后一行
        '''

        def backtrack(board , row):
            # 触发结束条件
            if row == len(board):
                tem_list = []
                for each_row in board:
                    tem = "".join(each_row)
                    tem_list.append(tem)
                res.append(tem_list)
                return 
            
            n = len(board[row])
            for col in range(n):
                # 排除不合法选择
                if not isValid(board,row,col):
                    continue
                # 做选择
                board[row][col] = 'Q'
                # 进入下一行的决策
                backtrack(board,row+1)
                # 撤销选择
                board[row][col] = '.'
                
        def isValid(board,row,col):
            n = len(board)
            # 检查同列中皇后是否冲突
            for i in range(n):
                if board[i][col] == 'Q':
                    return False
            
            # 检查左上的对角线皇后是否冲突
            for i,j in zip(range(row-1,-1,-1),range(col-1,-1,-1)):
                if "Q" in board[i][j]:
                    return False
                    
            # 检查右上的对角线皇后是否冲突
            for i,j in zip(range(row-1,-1,-1),range(col+1,n)):
                if "Q" in board[i][j]:
                    return False
            
            return True


        backtrack(board,0)
        return res

动态规划需要明确知道 【状态】【选择】和【base case】
而回溯算法需要知道【路径】,【当前选择列表】和【结束条件】

一定程度上动态规划的暴力求解阶段就是回溯算法。只是在求解过程中的一些重叠子问题,可以用dp数组去优化,将递归树优化。

reference

labuladong 算法小抄.

你可能感兴趣的:(数据结构,数据结构)