回溯算法详解(python)

回溯算法详解(python)

从本质上来说,回溯算法就是深度优先搜索(DFS)。而且,回溯算法和动态规划也很像,它们都是“分而治之”的思想,但是动态规划具有重叠子问题的特性,可以通过 dp table
优化,将递归树大幅剪枝。而那些无法大幅剪枝,只能暴力求解的动态规划就是回溯算法了。

对于回溯算法来说,最重要的是“路径”和“选择”,路径就是已经做出来的选择的集合。当回溯算法进行到最后时,如果其满足约束条件,那就把它加入解集,否则,回溯(这也是回溯算法的由来)。

对于回溯算法来说,一般是如下模式:

results = []
def backtrack(路径,选择列表):
if 路径结束,满足约束条件:
results.append(路径)
return
if 路径结束,不满足约束条件:
return
for 选择 in 选择列表:
更新路径和选择列表
backtrack(新的路径,新的选择列表)

return results

下面用三个算法题作为示例

  1. leetcode39 组合总和
    给定一个无重复元素的数组 candidates和一个目标数 target,找出 candidates 中所有可以使数字之和为 target 的组合

说明

所有数字(包括 target)都是正整数
解集不能包含重复的组合
candidates 中的数字可以无限制重复被选取
示例
输入:candidates = [2,3,5].target = 8
输出:[[2,2,2,2],[2,3,3],[3,5]]

def combination(candidate:List[int], target: int)->List[List[int]]:
n = len(candidates)
candidates.sort()
results=[]

# i 和 sum是当前的选择,track 是路径
def backtrack(i,sum,track):
    
    # 路径结束,不满足约束条件
    if sum > target or i == n:
        return 
        
    # 路径结束,满足约束条件
    if sum == target:
        results.append(track)
        return 
    
    # 更新选择列表和路径,递归
    # 在这个问题中,选择只有两种,是否将当前数字纳入路径
    backtrack(i, sum+candidates[i], track+[[candidates[i]])
    backtrack(i+1, sum, track)
    
backtrack(0,0,[])
return results
  1. leetcode46 全排列
    给定一个没有重复数字的序列,返回其所有可能的全排列
    示例:
    输入:[1,2,3]
    输出:[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

def permute(nums:List[int]) -> List[List[int]]:
nums.sort()
results=[]

#nums是选择列表,track 是路径
def backtrack(nums,track):
    
    #路径结束满足约束条件
    if not nums:
        results.append(track)
        return 
    
    #更新选择列表和路径,递归
    #在这个问题中,选择有 n-len(track)这么多种
    for i in range(len(nums)):
        traceback(nums[:i]+nums[i+1:],track+[nums[i]])
        
backtrack(nums,[])
return results
  1. leetcode 51 N 皇后问题
    在 N*N的棋盘上摆上 N个皇后,使其不能互相攻击,即任意两个皇后都不能处于同一行、同一列或同一斜线上,求摆法。
    说明:

给定一个整数 n,返回所有不同的 n 皇后的问题解决方案
每一种解法包含一个明确的 n 皇后问题的棋子放置方案,该方案中’Q’和’.'分别代表了皇后和空位
示例
输入:4
输出:[[".Q…","…Q",“Q…”,"…Q."],["…Q.",“Q…”,"…Q",".Q…"]]
def solveNQueens(n:int)->List[list[str]]:

#首先我们明确一下皇后的位置如何表示,皇后在 track 中的索引代表它所处的列,它的值表示它所在的行
#比如 track[1]=2,表明第二行第一列放置一个皇后
results=[]

#track 表示路径,xy_dif 和 xy_sum 用来计算两个皇后是否在同一斜线上
def backtrack(track,xy_dif,xy_sum):
    p = len(track)
    if p==n:
        results.append(track)
        return 
    
    for q in range(n):  
        
        #1. 两个皇后不能处在同一列,则它们的索引必然不同(显然)
        #2. 两个皇后不能处在同一行,则它们的值必然不同
        #3. 两个皇后不能处在左上-右下这种位置,则它们横纵坐标之差必然不同(举例,如(3,4)和(4,5)
        #4. 两个皇后不能处在右上-左下这种位置,则它们横纵坐标之和必然不同(举例,如(3,4)和(4,3)
        if (q not in track) and (p-q not in xy_dif) and (p+q not in xy_sum):
            backtrack(track+[q],xy_dif+[p-q],xy_sum+[p+q])
        

backtrack([],[],[])
return [['.'*i + 'Q' + '.' *(n-i-1) for i in result] for result in results]

总结
总而言之,碰到回溯算法的题目,首先弄清楚回溯的条件(也就是退出条件,得出一个解或者确定无法得出一个解),其次就是在当前状态,选择列表和路径是什么,以及选择完毕,路径和选择列表如何更新。

你可能感兴趣的:(python,算法)