add 16_11

Author: Blankj

README.md

@@ -32,6 +32,7 @@
 | 9    | [Palindrome Number][0009]                                         | Math                                              |
 | 13   | [Roman to Integer][0013]                                          | Math, String                                      |
 | 14   | [Longest Common Prefix][0014]                                     | String                                            |
+| 16.11| [跳水板(Diving Board LCCI)][16_11]                                 | 递归、记忆化                                       |
 | 20   | [Valid Parentheses][0020]                                         | Stack, String                                     |
 | 21   | [Merge Two Sorted Lists][0021]                                    | Linked List                                       |
 | 26   | [Remove Duplicates from Sorted Array][0026]                       | Array, Two Pointers                               |
@@ -121,6 +122,7 @@
 [0009]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0009/README.md
 [0013]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0013/README.md
 [0014]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0014/README.md
+[16_11]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/16_11/README.md
 [0020]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0020/README.md
 [0021]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0021/README.md
 [0026]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0026/README.md

note/16_11/README.md

@@ -0,0 +1,116 @@
+# [跳水板(Diving Board LCCI)][title]
+
+## 题目描述
+
+你正在使用一堆木板建造跳水板。有两种类型的木板，其中长度较短的木板长度为`shorter`，长度较长的木板长度为`longer`。你必须正好使用`k`块木板。编写一个方法，生成跳水板所有可能的长度。
+
+返回的长度需要从小到大排列。
+
+**示例：**
+
+```
+输入：
+shorter = 1
+longer = 2
+k = 3
+输出： {3,4,5,6}
+```
+
+**提示：**
+
+*   0 < shorter <= longer
+*   0 <= k <= 100000
+
+**标签：** 递归、记忆化
+
+
+## 思路
+
+这题乍一看，好像得用递归或动态规划来解，仔细一想，其实就是高中数学学过的等差数列知识。
+
+当 `k == 0` 时，返回 `[]` 即可；
+
+当 `shorter == longer` 时，返回 `[k * shorter]` 即可；
+
+当 `shorter != longer` 时，那么其实就是一个首项为 `k * shorter`，末项为 `k * longer`，公差为 `longer - shorter` 的等差数列么；
+
+我们根据以上情况就可以写出如下代码了：
+
+
+```java
+public class Solution {
+    public int[] divingBoard(int shorter, int longer, int k) {
+        if (k == 0) {
+            return new int[0];
+        }
+        if (shorter == longer) {
+            return new int[]{shorter * k};
+        }
+        int[] ans = new int[k + 1];
+        int st = k * shorter;// 等差数列的首项
+        int delta = longer - shorter;// 公差
+        for (int i = 0; i <= k; i++) {
+            ans[i] = st + i * delta;
+        }
+        return ans;
+    }
+}
+```
+
+
+## 思路 1
+
+基于上面的思路，其实我们没有必要把所有层级都保存下来，由于是先序遍历，在找待插入节点它爹时，我们可以把不小于它层级的元素都删除，基于此，用一个辅助栈便可完成寻爹之旅，具体如下所示：
+
+```java
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+public class Solution {
+    public TreeNode recoverFromPreorder(String S) {
+        char[] chars = S.toCharArray();
+        int len = chars.length;
+        LinkedList<TreeNode> stack = new LinkedList<>();
+        for (int i = 0; i < len; ) {
+            int level = 0, val = 0;
+            while (chars[i] == '-') { // 获取所在层级，Character.isDigit() 会比较慢
+                ++i;
+                ++level;
+            }
+            while (i < len && chars[i] != '-') { // 获取节点的值
+                val = val * 10 + chars[i++] - '0';
+            }
+            TreeNode curNode = new TreeNode(val);
+            while (stack.size() > level) { // 栈顶不是父亲，栈顶出栈
+                stack.removeLast();
+            }
+            if (level > 0) {
+                TreeNode parent = stack.getLast();
+                if (parent.left == null) { // 如果节点只有一个子节点，那么保证该子节点为左子节点。
+                    parent.left = curNode;
+                } else {
+                    parent.right = curNode;
+                }
+            }
+            stack.addLast(curNode);
+        }
+        return stack.get(0);
+    }
+}
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
+
+
+
+[title]: https://leetcode-cn.com/problems/recover-a-tree-from-preorder-traversal
+[ajl]: https://github.com/Blankj/awesome-java-leetcode

src/com/blankj/easy/_16_11/Solution.java

@@ -0,0 +1,34 @@
+package com.blankj.easy._16_11;
+
+import java.util.Arrays;
+
+/**
+ * <pre>
+ *     author: Blankj
+ *     blog  : http://blankj.com
+ *     time  : 2020/07/08
+ *     desc  :
+ * </pre>
+ */
+public class Solution {
+    public int[] divingBoard(int shorter, int longer, int k) {
+        if (k == 0) {
+            return new int[0];
+        }
+        if (shorter == longer) {
+            return new int[]{shorter * k};
+        }
+        int[] ans = new int[k + 1];
+        int st = k * shorter;// 等差数列的首项
+        int delta = longer - shorter;// 公差
+        for (int i = 0; i <= k; i++) {
+            ans[i] = st + i * delta;
+        }
+        return ans;
+    }
+
+    public static void main(String[] args) {
+        Solution solution = new Solution();
+        System.out.println(Arrays.toString(solution.divingBoard(1, 2, 3)));
+    }
+}