6.6 搜索树+回溯

src/main/java/backtrack/CombinationSum.java

@@ -28,8 +28,8 @@ public class CombinationSum {
         if(cur==target) {
             res.add(new ArrayList<>(path));
         }
-        else if(cur>target)
+        else if(cur>target) {
-            return;
+        }
         else {
             for (int i = start; i < candidates.length; i++) {
                 path.add(candidates[i]);

src/main/java/backtrack/CombinationSum3.java

@@ -0,0 +1,45 @@
+package backtrack;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 题目：216. 组合总和 III (combinationSum3)
+ * 描述：找出所有相加之和为 n 的 k 个数的组合，且满足下列条件：
+ * 只使用数字1到9
+ * 每个数字 最多使用一次
+ * 返回 所有可能的有效组合的列表 。该列表不能包含相同的组合两次，组合可以以任何顺序返回。
+ *
+ * 示例 1：
+ 输入: k = 3, n = 7
+ 输出: [[1,2,4]]
+ 解释:
+ 1 + 2 + 4 = 7
+ 没有其他符合的组合了。
+
+ * 链接：https://leetcode.cn/problems/combination-sum-iii/
+ */
+public class CombinationSum3 {
+    void dfs(int n,int k,int used,List<List<Integer>>res,List<Integer>path,int cursum,int begin){
+        if(used==k){
+            if(n==cursum)
+                res.add(new ArrayList<>(path));
+        }else{
+            for (int i = begin; i <= 9; i++) {
+                path.add(i);
+                used++;
+                cursum+=i;
+                dfs(n,k,used,res,path,cursum,i+1);
+                cursum-=i;
+                used--;
+                path.remove(path.size()-1);
+            }
+        }
+    }
+    public List<List<Integer>> combinationSum3(int k, int n) {
+        List<List<Integer>>res=new ArrayList<>();
+        List<Integer>path=new ArrayList<>();
+        dfs(n,k,0,res,path,0,1);
+        return res;
+    }
+}

src/main/java/backtrack/RestoreIpAddresses.java

@@ -0,0 +1,39 @@
+package backtrack;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 题目：93. 复原 IP 地址 (restoreIpAddresses)
+ * 描述：有效 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 '.' 分隔。
+ *
+ * 例如："0.1.2.201" 和 "192.168.1.1" 是 有效 IP 地址，但是 "0.011.255.245"、"192.168.1.312" 和 "192.168@1.1" 是 无效 IP 地址。
+ * 给定一个只包含数字的字符串 s ，用以表示一个 IP 地址，返回所有可能的有效 IP 地址，这些地址可以通过在 s 中插入 '.' 来形成。你 不能 重新排序或删除 s 中的任何数字。你可以按 任何 顺序返回答案。
+ *
+ * 示例 1：
+ 输入：s = "25525511135"
+ 输出：["255.255.11.135","255.255.111.35"]
+
+ * 链接：https://leetcode.cn/problems/restore-ip-addresses/
+ */
+public class RestoreIpAddresses {
+    void dfs(List<String>res,List<String>path,String s,int minStep){
+        if(path.size()==4){
+            StringBuilder sb=new StringBuilder();
+            sb.append(path.get(0));
+            for (int i = 1; i < path.size(); i++) {
+                sb.append('.').append(path.get(i));
+            }
+            res.add(sb.toString());
+        }
+        for (int i = minStep; i < s.length(); i++) {
+            
+        }
+    }
+    public List<String> restoreIpAddresses(String s) {
+        List<String>res=new ArrayList<>();
+        List<String>path=new ArrayList<>();
+        StringBuilder sb=new StringBuilder();
+        return null;
+    }
+}

src/main/java/tree/ConvertBST.java

@@ -0,0 +1,41 @@
+package tree;
+
+/**
+ * 题目：538. 把二叉搜索树转换为累加树 (convertBST)
+ * 描述：给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。
+ * 提醒一下，二叉搜索树满足下列约束条件：
+ * 节点的左子树仅包含键 小于 节点键的节点。
+ * 节点的右子树仅包含键 大于 节点键的节点。
+ * 左右子树也必须是二叉搜索树。
+ *
+ * 示例 1：
+ 输入：[4,1,6,0,2,5,7,null,null,null,3,null,null,null,8]
+ 输出：[30,36,21,36,35,26,15,null,null,null,33,null,null,null,8]
+
+ * 链接：https://leetcode.cn/problems/convert-bst-to-greater-tree/
+ */
+//反向中序遍历，得到降序数组
+public class ConvertBST {
+    // 全局累加和，用于记录当前“比本节点值大的所有节点之和”
+    private int sum = 0;
+
+    // 对给定的 BST 做逆序中序遍历，更新节点值
+    private void reverseInorder(TreeNode node) {
+        if (node == null) return;
+
+        // 1. 先遍历右子树（右子树节点值都比 node.val 大）
+        reverseInorder(node.right);
+
+        // 2. 处理当前节点：sum 里存的是“之前访问过的所有节点（即比它值更大的那些节点）的累加值”
+        sum += node.val;
+        node.val = sum;
+
+        // 3. 再遍历左子树（左子树节点值都比 node.val 小）
+        reverseInorder(node.left);
+    }
+
+    public TreeNode convertBST(TreeNode root) {
+        reverseInorder(root);
+        return root;
+    }
+}