LeetCode Day28|491.递增子序列 46.全排列 47.全排列 II 322.重新安排行程（可跳过）51.N皇后（适当跳过）37.解数独（适当跳过）总结

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;
    }
}

day28-6 ●37.解数独（适当跳过）

day28-7 ●总结