回溯算法part04
day28-1 ●491.递增子序列
有哪些误区
不能排序
树形结构
主要砍
- 树层重复的
- 树枝上比收集结果集中最后一个元素还有小的、
代码实现、去重
class Solution {
// hashset实现
List<List<Integer>> result = new ArrayList<>();
List<Integer> path = new ArrayList<>();
public List<List<Integer>> findSubsequences(int[] nums) {
backTracking(nums, 0);
return result;
}
private void backTracking(int[] nums, int startIndex){
// 题目条件
if(path.size() > 1){
result.add(new ArrayList(path));
}
HashSet<Integer> hs = new HashSet<>();// 每次都会进行初始化,只负责本层,主要作用式为了去重
// 横向
for(int i = startIndex; i < nums.length; i++){
// 纵向剪枝(满足递增条件) 横向剪枝(减少重复)
if(!path.isEmpty()&& path.get(path.size() - 1) > nums[i] || hs.contains(nums[i])){
continue;
}
hs.add(nums[i]);
path.add(nums[i]);
// 纵向
backTracking(nums, i + 1);
path.removeLast();// 没有 hs.removeLast(nums[i]);
}
}
}
总结
没有 hs.removeLast(nums[i]);
因为haset主要的作用就是记录当前的层的数值不能起重复
hashset每次递归都会被重新初始化定义
day28-2 ● 46.全排列
什么是排列
与顺序有关系
树形结构
代码实现
class Solution {
List<List<Integer>> result = new ArrayList<>();
List<Integer> path = new ArrayList<>();
boolean[] used;
public List<List<Integer>> permute(int[] nums) {
if(nums.length == 0){
return result;
}
// 初始化used数组
used = new boolean[nums.length];
backTracking(nums);
return result;
}
private void backTracking(int[] nums){
if(path.size() == nums.length){
result.add(new ArrayList(path));
return;
}
// 横向 从0开始的
for(int i = 0; i < nums.length; i++){
if(used[i]){
continue;
}
used[i] = true;
path.add(nums[i]);
// 纵向
backTracking(nums);
path.removeLast();
used[i] = false;
}
}
}
总结
遍历的时候从0开始
day28-3 ●47.全排列 II
关键在去重
对于排列问题,树层上去重和树枝上去重,都是可以的,但是树层上去重效率更高!
- 树层去重
if(i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false){...}
效率更高 - 联想:树枝去重
if(i > 0 && nums[i] == nums[i - 1] && used[i - 1] == true){...}
最后一个树枝才把结果列出来
跳过树枝前面已经取过的元素的代码
if(used[i] == true){ continue; }
树形结构
代码实现
class Solution {
List<List<Integer>> result = new ArrayList<>();// 存放结果
List<Integer> path = new ArrayList<>();// 暂存结果
boolean[] used;
public List<List<Integer>> permuteUnique(int[] nums) {
if(nums.length == 0){
return result;
}
Arrays.sort(nums);
used = new boolean[nums.length];
backTracking(nums);
return result;
}
private void backTracking(int[] nums){
if(path.size() == nums.length){
result.add(new ArrayList<>(path));
return;
}
// 是排列不是组合,所以要从0开始
for(int i = 0; i < nums.length; i++){
// 数层剪枝
if(i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false){
continue;
}
// 树枝前面取过的数直接跳过
if(used[i] == true){
continue;
}
if(used[i] == false){
used[i] = true;
path.add(nums[i]);
backTracking(nums);
path.removeLast();// 回溯
used[i] = false;
}
}
}
}
总结
要记得对nums进行排序
组合问题和排列问题是在树形结构的叶子节点上收集结果,而子集问题就是取树上所有节点的结果。
day28-4 ●322.重新安排行程(可跳过)
day28-5 ●51.N皇后(适当跳过)
class Solution {
// todo
List<List<String>> res = new ArrayList<>();
public List<List<String>> solveNQueens(int n) {
char[][] chessboard = new char[n][n];
for (char[] c : chessboard) {
Arrays.fill(c, '.');
}
backTrack(n, 0, chessboard);
return res;
}
public void backTrack(int n, int row, char[][] chessboard) {
if (row == n) {
res.add(Array2List(chessboard));
return;
}
for (int col = 0;col < n; ++col) {
if (isValid (row, col, n, chessboard)) {
chessboard[row][col] = 'Q';
backTrack(n, row+1, chessboard);
chessboard[row][col] = '.';
}
}
}
//将二维数组转换为列表
public List Array2List(char[][] chessboard) {
List<String> list = new ArrayList<>();
for (char[] c : chessboard) {
list.add(String.copyValueOf(c));
}
return list;
}
public boolean isValid(int row, int col, int n, char[][] chessboard) {
// 检查列
for (int i=0; i<row; ++i) { // 相当于剪枝
if (chessboard[i][col] == 'Q') {
return false;
}
}
// 检查45度对角线
for (int i=row-1, j=col-1; i>=0 && j>=0; i--, j--) {
if (chessboard[i][j] == 'Q') {
return false;
}
}
// 检查135度对角线
for (int i=row-1, j=col+1; i>=0 && j<=n-1; i--, j++) {
if (chessboard[i][j] == 'Q') {
return false;
}
}
return true;
}
}