【算法】回溯算法

回溯算法

什么是回溯

人生无时不在选择。在选择的路口，你该如何抉择 .....

回溯：是一种选优搜索法，又称为试探法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点”。

回溯，计算机算法，回溯法也称试探法，它的基本思想是：从问题的某一种状态（初始状态）出发，搜索从这种状态出发所能达到的所有“状态”，当一条路走到“尽头”的时候（不能再前进），再后退一步或若干步，从另一种可能“状态”出发，继续搜索，直到所有的“路径”（状态）都试探过。这种不断“前进”、不断“回溯”寻找解的方法，就称作“回溯法”。--百度百科

一个例子看回溯

给下图的图顶点进行三种颜色着色（红、黄、蓝)

要求:

每个顶点的颜色只能从红、黄、蓝中选一个种。

相邻的两种颜色不能为同一种颜色。

思考方式

暴力推测，查找各种可能...

树型策略

暴力查找结果(从上向下[第n=1行开始]，从左边开始):

n=1,先取红，n=2取红

[红、红、红], [红,红,黄],[红，红,蓝]; [红,黄, 红],[红，黄，黄]，[红，黄，蓝]；[红，蓝，红],[红，蓝，黄]，[红，蓝，蓝]
n=1, n=2取黄
n=2, n=3,取蓝色

回溯到根节点，走n=1，取黄色

回溯的一般规律

我们可以针对以上的找色问题，给出以下的一般的解决方案。

初始化：初始化变量
找一个合法值，通过遍历(+1/-1)选取所有的可能[可以认为是树的深度]
栈记录
递归调用
回溯已经使用的值

经典题目

全排列

题目

[力扣46] 46. 全排列 - 力扣（LeetCode）

题目描述

给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。

示例 1：

输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

示例 2：

输入：nums = [0,1]
输出：[[0,1],[1,0]]

示例 3：

输入：nums = [1]
输出：[[1]]

解决方案

提交模版

public List<List<Integer>> permute(int[] nums) {  }

参考实现

class Solution {
private List<List<Integer>> list = new ArrayList<>();private Stack<Integer> stack = new Stack<>();
public List<List<Integer>> permute(int[] nums) {boolean[] isUsed = new boolean[nums.length];dfs(nums, 0, isUsed);return list;}
private void dfs(int[] nums, int depth, boolean[] isUsed) {if (depth == nums.length) {list.add(new ArrayList<>(stack));return;}
for (int i = 0; i < nums.length; i++) {if (isUsed[i]) {continue;}stack.push(nums[i]);isUsed[i] = true;dfs(nums, depth + 1, isUsed);stack.pop();isUsed[i] = false;}}
}

全排列II

题目

[力扣47] 47. 全排列 II - 力扣（LeetCode）

题目描述

给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。

示例 1：

输入：nums = {1,1,2}
输出：
{{1,1,2},{1,2,1},{2,1,1}
}

示例 2：

输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

解题思路

提交模版

public List<List<Integer>> permuteUnique(int[] nums) {   }

参考实现

class Solution {private final List<List<Integer>> list = new ArrayList<>();private final Stack<Integer> stack = new Stack<>();private final Set<List<Integer>> sets = new HashSet<>();

public List<List<Integer>> permuteUnique(int[] nums) {boolean[] isUsed = new boolean[nums.length];dfs(nums, 0, isUsed);list.addAll(sets);return list;}
/*** @param nums* @param depth  递归的深度，从底层开始到最后一层* @param isUsed 判断当前数据是否使用过*/private void dfs(int[] nums, int depth, boolean[] isUsed) {if (depth == nums.length) {sets.add(new ArrayList<>(stack));return;}
Set<Integer> set = new HashSet<>();//记录重复数据for (int i = 0; i < nums.length; i++) { //遍历数组//数据重复或者使用过则跳过当前数据if (isUsed[i] ) continue;// set.add(nums[i]); //记录选择的数据//  System.out.println("set-->" + set);stack.push(nums[i]);isUsed[i] = true;dfs(nums, depth + 1, isUsed);stack.pop();isUsed[i] = false;}}
}

子集问题

题目

[力扣78] 78. 子集 - 力扣（LeetCode）

题目描述

给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。

解集不能包含重复的子集。你可以按 任意顺序 返回解集。

示例 1：

输入：nums = [1,2,3]
输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]

示例 2：

输入：nums = [0]
输出：[[],[0]]

解题思路

创建策略树

我们会发现出现大量的无效操作数据。对策略树进行"剪枝"处理。

剪枝- 我们“剪掉”了不满足约束条件的搜索分支，避免许多无意义的尝试，从而提高了搜索效率。

提交模版

 public List<List<Integer>> subsets(int[] nums) { }

参考实现

class Solution {List<List<Integer>> list = new ArrayList<>();Stack<Integer> stack = new Stack<>();
public List<List<Integer>> subsets(int[] nums) {dfs(nums, 0);return list;}
private void dfs(int[] nums, int startIndex) {
list.add(new ArrayList<>(stack));if (startIndex >= nums.length) {return;}
for (int i = startIndex; i < nums.length; i++) {stack.push(nums[i]);dfs(nums, i + 1);stack.pop();
}}
}

剪枝优化

class Solution {private final List<List<Integer>> list = new ArrayList<>();private final List<Integer> stack = new ArrayList<>();
public List<List<Integer>> subsets(int[] nums) {boolean[] isUsed = new boolean[nums.length];dfs(nums, 0, isUsed);return list;}
private void dfs(int[] nums, int startIndex, boolean[] isUsed) {
list.add(new ArrayList<>(stack)); //记录扫描的所有节点for (int i = startIndex; i < nums.length; i++) {if (isUsed[i])continue;stack.add(nums[i]);isUsed[i] = true;dfs(nums, i + 1,isUsed);stack.remove(stack.size()-1);isUsed[i] = false;
}}
}