回溯题型13道

Author: linwt

leetcode_Java/DoneTitle.txt

@@ -8,16 +8,26 @@
 17. 电话号码的字母组合
 20. 有效的括号
 21. 合并两个有序链表
+37. 解数独
+39. 组合总和
+40. 组合总和 II
 46. 全排列
+47. 全排列 II
+51. N 皇后
 53. 最大子数组和
 70. 爬楼梯
+77. 组合
+78. 子集
+90. 子集 II
+93. 复原 IP 地址
 94. 二叉树的中序遍历
 101. 对称二叉树
 102. 二叉树的层序遍历
 104. 二叉树的最大深度
 105. 从前序与中序遍历序列构造二叉树
 114. 二叉树展开为链表
 121. 买卖股票的最佳时机
+131. 分割回文串
 136. 只出现一次的数字
 141. 环形链表
 144. 二叉树的前序遍历
@@ -27,6 +37,7 @@
 169. 多数元素
 200. 岛屿数量
 206. 反转链表
+216. 组合总和 III
 226. 翻转二叉树
 234. 回文链表
 236. 二叉树的最近公共祖先
@@ -39,6 +50,8 @@
 437. 路径总和
 448. 找到所有数组中消失的数字
 461. 汉明距离
+491. 递增子序列
+494. 目标和
 538. 把二叉搜索树转换为累加树
 543. 二叉树的直径
 560. 和为 K 的子数组

leetcode_Java/Solution0017.java

@@ -1,7 +1,13 @@
 // 电话号码的字母组合
 
 /*
-回溯
+回溯：
+1、使用HashMap定义数字和字符串的对应关系。每个数字代表不同的集合，即求不同集合的子集
+2、定义全局变量res存放所有子结果，sb存放临时子结果
+3、调用递归函数，处理得到所有子结果，返回结果
+4、定义递归函数：
+   1）终止条件，存储子结果
+   2）for循环遍历数字对应的字符串，选择 → 递归 → 撤销，回溯
  */
 class Solution {
     private Map<Character, String> map = new HashMap<Character, String>(){{

leetcode_Java/Solution0037.java

@@ -0,0 +1,67 @@
+// 解数独
+
+
+/*
+回溯：
+1、本题中棋盘的每一个位置都要放一个数字，并检查数字是否合法，解数独的树形结构要比N皇后更宽更深。
+2、为什么递归函数的返回值需要是bool类型？
+  因为解数独找到一个符合的条件（就在树的叶子节点上）立刻就返回，相当于找从根节点到叶子节点一条唯一路径，所以需要使用bool返回值
+3、本题在原二维数组上操作，因此不需要增加额外的数据结构
+4、本题递归不用终止条件，解数独是要遍历整个树形结构寻找可能的叶子节点就立刻返回
+5、本题需要 二维递归，也就是两个for循环嵌套着递归
+  一个for循环遍历棋盘的行，一个for循环遍历棋盘的列，一行一列确定下来之后，递归遍历这个位置放9个数字的可能性！
+ */
+class Solution {
+    public void solveSudoku(char[][] board) {
+        backtrack(board);
+    }
+
+    private boolean backtrack(char[][] board) {
+        for (int row = 0; row < 9; row++) {
+            for (int col = 0; col < 9; col++) {
+                if (board[row][col] != '.') {
+                    continue;
+                }
+                for (char val = '1'; val <= '9'; val++) {
+                    if (isValid(row, col, val, board)) {
+                        board[row][col] = val;
+                        if (backtrack(board)) {
+                            return true;
+                        }
+                        board[row][col] = '.';
+                    }
+                }
+                // 9个数都试完了，都不行，那么就返回false
+                return false;
+            }
+        }
+        // 遍历完没有返回false，说明找到了合适棋盘位置
+        return true;
+    }
+
+    private boolean isValid(int row, int col, char val, char[][] board) {
+        // 判断同一行是否有重复的数
+        for (int i = 0; i < 9; i++) {
+            if (board[row][i] == val) {
+                return false;
+            }
+        }
+        // 判断同一列是否有重复的数
+        for (int j = 0; j < 9; j++) {
+            if (board[j][col] == val) {
+                return false;
+            }
+        }
+        // 判断九宫格是否有重复的数
+        int startRow = (row / 3) * 3;
+        int startCol = (col / 3) * 3;
+        for (int i = startRow; i < startRow + 3; i++) {
+            for (int j = startCol; j < startCol + 3; j++) {
+                if (board[i][j] == val) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+}

leetcode_Java/Solution0039.java

@@ -0,0 +1,38 @@
+// 组合总和
+
+
+/*
+回溯：
+1、定义全局变量res存放回溯过程得到的所有子结果
+2、定义全局变量track存放回溯过程的临时子结果
+3、调用递归函数，处理得到所有子结果，返回结果
+4、定义递归函数
+    1）终止条件，总和等于目标值，存储子结果
+    2）剪枝条件，总和大于目标值，结束
+    3）for循环遍历数组，做选择 → 递归 → 撤销选择，回溯
+ */
+class Solution {
+    private List<List<Integer>> res = new ArrayList<>();
+    private Deque<Integer> track = new LinkedList<>();
+
+    public List<List<Integer>> combinationSum(int[] candidates, int target) {
+        backtrack(candidates, 0, target);
+        return res;
+    }
+
+    private void backtrack(int[] candidates, int index, int target) {
+        int sum = track.stream().mapToInt(x -> x).sum();
+        if (sum == target) {
+            res.add(new ArrayList<>(track));
+            return;
+        }
+        if (sum > target) {
+            return;
+        }
+        for (int i = index; i < candidates.length; i++) {
+            track.addLast(candidates[i]);
+            backtrack(candidates, i, target);
+            track.removeLast();
+        }
+    }
+}

leetcode_Java/Solution0040.java

@@ -0,0 +1,38 @@
+// 组合总和 II
+
+
+/*
+回溯：
+1、思路与'39.组合总和'相同
+2、不同点：有重复元素，解集不能包含重复的组合，因此要过滤重复的选择
+3、增加剪枝条件：先数组排序，同一层元素做选择时，如果该元素前面出现过，则跳过，因为前面的选择已经包含当前情况了
+ */
+class Solution {
+    private List<List<Integer>> res = new ArrayList<>();
+    private Deque<Integer> track = new LinkedList<>();
+
+    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
+        Arrays.sort(candidates);
+        backtrack(candidates, 0, target);
+        return res;
+    }
+
+    private void backtrack(int[] candidates, int startIndex, int target) {
+        int sum = track.stream().mapToInt(x -> x).sum();
+        if (sum == target) {
+            res.add(new ArrayList<>(track));
+            return;
+        }
+        if (sum > target) {
+            return;
+        }
+        for (int i = startIndex; i < candidates.length; i++) {
+            if (i > startIndex && candidates[i] == candidates[i - 1]) {
+                continue;
+            }
+            track.addLast(candidates[i]);
+            backtrack(candidates, i + 1, target);
+            track.removeLast();
+        }
+    }
+}

leetcode_Java/Solution0046.java

@@ -4,11 +4,42 @@
 /*
 回溯：
 1、定义全局变量res存放回溯过程得到的所有子结果
-2、定义局部变量track存放回溯过程的临时子结果
+2、定义全局变量track存放回溯过程的临时子结果
 3、调用递归函数，处理得到所有子结果，返回结果
 4、定义递归函数
     1）终止条件，存储子结果
-    2）for循环：剪枝条件 → 做选择 → 递归 → 撤销选择 → 回溯
+    2）for循环：剪枝条件 → 做选择 → 递归 → 撤销选择，回溯
+5、由于存储子结果的变量在遍历过程中作为临时存储，当需要添加子结果时拷贝一份即可，因此可以重复使用
+ */
+class Solution {
+    private List<List<Integer>> res = new ArrayList<>();
+    private LinkedList<Integer> track = new LinkedList<>();
+
+    public List<List<Integer>> permute(int[] nums) {
+        backtrack(nums);
+        return res;
+    }
+
+    private void backtrack(int[] nums) {
+        if (track.size() == nums.length) {
+            res.add(new ArrayList(track));
+            return;
+        }
+        for (int i = 0; i < nums.length; i++) {
+            if (track.contains(nums[i])) {
+                continue;
+            }
+            track.addLast(nums[i]);
+            backtrack(nums);
+            track.removeLast();
+        }
+    }
+}
+
+
+
+/*
+逻辑同上
  */
 class Solution {
     private List<List<Integer>> res = new ArrayList<>();

leetcode_Java/Solution0047.java

@@ -0,0 +1,45 @@
+// 全排列 II
+
+
+/*
+回溯：
+1、定义全局变量res存放回溯过程得到的所有子结果，定义全局变量track存放回溯过程的临时子结果，定义全局便变量used存放数组元素使用过情况
+2、包含重复的元素，因此做选择时，树层要去重，树枝不用去重。去重必须先数组排序
+3、调用递归函数，处理得到所有子结果，返回结果
+4、定义递归函数
+    1）终止条件，子结果大小满足条件，存储子结果
+    2）for循环遍历数组：剪枝条件 → 做选择 → 递归 → 撤销选择，回溯
+       ① 剪枝条件：当前元素使用过则跳过；或者当前元素未使用过，但同一层前面有同样的元素未使用过，该元素在本层可以使用，则需要跳过重复选择
+       ② 做选择：元素只加入子结果，标记当前元素已使用
+       ③ 递归：进入下一层，同样遍历整个数组，通过used标记判断元素是否有效可用
+       ④ 回溯：撤销选择，移除子结果最后一个元素，标记当前元素未使用
+ */
+class Solution {
+    private List<List<Integer>> res = new ArrayList<>();
+    private Deque<Integer> track = new LinkedList<>();
+    private boolean[] used;
+
+    public List<List<Integer>> permuteUnique(int[] nums) {
+        used = new boolean[nums.length];
+        Arrays.sort(nums);
+        backtrack(nums);
+        return res;
+    }
+
+    private void backtrack(int[] nums) {
+        if (track.size() == nums.length) {
+            res.add(new ArrayList<>(track));
+            return;
+        }
+        for (int i = 0; i < nums.length; i++) {
+            if (used[i] || (i > 0 && nums[i] == nums[i - 1] && !used[i - 1])) {
+                continue;
+            }
+            track.addLast(nums[i]);
+            used[i] = true;
+            backtrack(nums);
+            track.removeLast();
+            used[i] = false;
+        }
+    }
+}