46全排列
回溯算法框架
result = []
def backtrack(路径, 选择列表):
if 满足结束条件:
result.add(路径)
return
for 选择 in 选择列表:
做选择
backtrack(路径, 选择列表)
撤销选择
我们在高中的时候就做过排列组合的数学题，我们也知道 n 个不重复的数，全排列共有 n! 个。
PS：为了简单清晰起见，我们这次讨论的全排列问题不包含重复的数字。
那么我们当时是怎么穷举全排列的呢？比方说给三个数 [1,2,3]，你肯定不会无规律地乱穷举，一般是这样：
先固定第一位为 1，然后第二位可以是 2，那么第三位只能是 3；然后可以把第二位变成 3，第三位就只能是 2 了；然后就只能变化第一位，变成 2，然后再穷举后两位……
其实这就是回溯算法，我们高中无师自通就会用，或者有的同学直接画出如下这棵回溯树：
只要从根遍历这棵树，记录路径上的数字，其实就是所有的全排列。我们不妨把这棵树称为回溯算法的「决策树」。
为啥说这是决策树呢，因为你在每个节点上其实都在做决策。比如说你站在下图的红色节点上：
你现在就在做决策，可以选择 1 那条树枝，也可以选择 3 那条树枝。为啥只能在 1 和 3 之中选择呢？因为 2 这个树枝在你身后，这个选择你之前做过了，而全排列是不允许重复使用数字的。
现在可以解答开头的几个名词：[2] 就是「路径」，记录你已经做过的选择；[1,3] 就是「选择列表」，表示你当前可以做出的选择；「结束条件」就是遍历到树的底层，在这里就是选择列表为空的时候。
如果明白了这几个名词，可以把「路径」和「选择」列表作为决策树上每个节点的属性，比如下图列出了几个节点的属性：
for 选择 in 选择列表:
# 做选择
将该选择从选择列表移除
路径.add(选择)
backtrack(路径, 选择列表)
# 撤销选择
路径.remove(选择)
将该选择再加入选择列表
List<List<Integer>> res = new LinkedList<>();
/* 主函数，输入一组不重复的数字，返回它们的全排列 */
List<List<Integer>> permute(int[] nums) {
// 记录「路径」
LinkedList<Integer> track = new LinkedList<>();
backtrack(nums, track);
return res;
}
// 路径：记录在 track 中
// 选择列表：nums 中不存在于 track 的那些元素
// 结束条件：nums 中的元素全都在 track 中出现
void backtrack(int[] nums, LinkedList<Integer> track) {
// 触发结束条件
if (track.size() == nums.length) {
res.add(new LinkedList(track));
return;
}
for (int i = 0; i < nums.length; i++) {
// 排除不合法的选择
if (track.contains(nums[i]))
continue;
// 做选择
track.add(nums[i]);
// 进入下一层决策树
backtrack(nums, track);
// 取消选择
track.removeLast();
}
}
47全排列II
题目描述
思路
产生重复结点的地方，正是图中标注了“剪刀”，且被绿色框框住的地方。
大家也可以把第 2 个 1 加上 ’ ，即 [1, 1’, 2] 去想象这个搜索的过程。只要遇到起点一样，就有可能产生重复。这里还有一个很细节的地方：
1、在图中 ② 处，搜索的数也和上一次一样，但是上一次的 1 还在使用中；
2、在图中 ① 处，搜索的数也和上一次一样，但是上一次的 1 刚刚被撤销，正是因为刚被撤销，下面的搜索中还会使用到，因此会产生重复，剪掉的就应该是这样的分支。
if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]) {
continue;
}
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Deque;
import java.util.List;
public class Solution {
public List<List<Integer>> permuteUnique(int[] nums) {
int len = nums.length;
List<List<Integer>> res = new ArrayList<>();
if (len == 0) {
return res;
}
// 排序（升序或者降序都可以），排序是剪枝的前提
Arrays.sort(nums);
boolean[] used = new boolean[len];
// 使用 Deque 是 Java 官方 Stack 类的建议
Deque<Integer> path = new ArrayDeque<>(len);
dfs(nums, len, 0, used, path, res);
return res;
}
private void dfs(int[] nums, int len, int depth, boolean[] used, Deque<Integer> path, List<List<Integer>> res) {
if (depth == len) {
res.add(new ArrayList<>(path));
return;
}
for (int i = 0; i < len; ++i) {
if (used[i]) {//该节点已经在使用
continue;
}
// 剪枝条件：i > 0 是为了保证 nums[i - 1] 有意义
// 写 !used[i - 1] 是因为 nums[i - 1] 在深度优先遍历的过程中刚刚被撤销选择
if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]) {
continue;
}
path.addLast(nums[i]);
used[i] = true;
dfs(nums, len, depth + 1, used, path, res);
// 回溯部分的代码，和 dfs 之前的代码是对称的
used[i] = false;
path.removeLast();
}
}
public static void main(String[] args) {
Solution solution = new Solution();
int[] nums = {1, 1, 2};
List<List<Integer>> res = solution.permuteUnique(nums);
System.out.println(res);
}
}
51 N皇后问题
思路
有了上面回溯算法的模板及全排列问题的理解，我们可以更加熟悉这个问题，这个问题本质上跟全排列问题差不多，决策树的每一层表示棋盘上的每一行；每个节点可以做出的选择是，在该行的任意一列放置一个皇后。
框架就是：
void backtrack(棋盘board,当前行row,n){
if(终止条件){
保存当前序列;
return;
}
for(int i=0;i<n;i++){
if(board[row][i]可以填写){
当前格子board[row][i]='Q';
填写下一行backtrack(board,row+1,n);
擦除填写，验证下一个序列board[row][i]='.';
}
}
}
class Solution {
List<List<String>> res=new LinkedList<>();
public List<List<String>> solveNQueens(int n) {
//回溯法
int [][]board=new int [n][n] ;//二维数组模拟棋盘
backtrack(board,0,n);
return res;
}
//将int类型的数组转化为String类型
private List<String> track(int[][] board, int n) {
List<String> list=new ArrayList<>();
for (int i = 0; i < n; i++) {
StringBuilder temp=new StringBuilder();
for (int j = 0; j < n; j++) {
if (board[i][j]=='Q')temp.append('Q');
else temp.append('.');
}
list.add(temp.toString());
}
return list;
}
public void backtrack(int [][] board,int row,int a){
//触发终止递归的条件
if(row==a){//row=0代表层数1，这里超过最大层（就是输入的n）的时候
res.add(track(board,a));//加入最终结果集
return;
}
int n=board[row].length;//一行的列数
for(int col=0;col<n;col++){
if(!isValid(board,row,col)){//判断该位置是否可以防皇后，不可以跳出本次循环，执行下一次
continue;
}
//做选择
board[row][col]='Q';
//进入下一层
backtrack(board,row+1,a);
//撤销选择
board[row][col]='.';
}
}
public boolean isValid(int[][] board,int row,int col){
int n=board.length;
//判断该列是否有皇后
for (int i = 0; i < n; i++) {//固定列数，遍历每一行
if (board[i][col] == 'Q'){
return false;
}
}
//判断**右上角**是否有皇后
for(int i=row-1,j=col+1; i>=0&&j<n; i--,j++){
if(board[i][j]=='Q'){
return false;
}
}
//判断**左上角**是否有皇后
for(int i=row-1,j=col-1;i>=0&&j>=0;i--,j--){
if(board[i][j]=='Q'){
return false;
}
}
return true;
}
}
52 N皇后
题目描述
这里主要在51题的基础上，对回溯部分函数进行修改即可
public void backtrack(int [][] board,int row,int a){
//触发终止递归的条件
if(row==a){
res.add(track(board,a));
count++;
return;
}
int n=board[row].length;//一行的列数
for(int col=0;col<n;col++){
if(!isValid(board,row,col)){
continue;
}
//做选择
board[row][col]='Q';
//进入下一层
backtrack(board,row+1,a);
//撤销选择
board[row][col]='.';
}
}
1283
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
