levels = 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);
-// if (level > 0) {
-// TreeNode parent = levels.get(level - 1);
-// if (parent.left == null) { // 如果节点只有一个子节点，那么保证该子节点为左子节点。
-// parent.left = curNode;
-// } else {
-// parent.right = curNode;
-// }
-// }
-// levels.add(level, curNode); // 因为是前序遍历（根-左-右），也就是右覆盖左时，此时左树已遍历完成，故无需考虑覆盖问题
-// }
-// return levels.get(0);
-// }
-
public static void main(String[] args) {
Solution solution = new Solution();
TreeNode.print(solution.recoverFromPreorder("1-2--3--4-5--6--7"));
diff --git a/src/com/blankj/medium/_0209/Solution.java b/src/com/blankj/medium/_0209/Solution.java
new file mode 100644
index 00000000..cdfedebc
--- /dev/null
+++ b/src/com/blankj/medium/_0209/Solution.java
@@ -0,0 +1,70 @@
+package com.blankj.medium._0209;
+
+import java.util.Arrays;
+
+/**
+ *
+ * author: Blankj
+ * blog : http://blankj.com
+ * time : 2020/06/30
+ * desc :
+ *
+ */
+public class Solution {
+// public int minSubArrayLen(int s, int[] nums) {
+// int ans = Integer.MAX_VALUE;
+// for (int i = 0; i < nums.length; i++) {
+// int sum = nums[i];
+// if (sum >= s) {
+// return 1;
+// }
+// for (int j = i + 1; j < nums.length; j++) {
+// sum += nums[j];
+// if (sum >= s) {
+// ans = Math.min(ans, j - i + 1);
+// break;
+// }
+// }
+// }
+// return ans == Integer.MAX_VALUE ? 0 : ans;
+// }
+
+// public int minSubArrayLen(int s, int[] nums) {
+// int left = 0, right = 0, sum = 0, ans = Integer.MAX_VALUE;
+// while (right < nums.length) {
+// sum += nums[right++]; // 向右扩大窗口
+// while (sum >= s) { // 如果不小于 s，则收缩窗口左边界
+// ans = Math.min(ans, right - left);// 更新结果
+// sum -= nums[left++]; // 向左缩小窗口
+// }
+// }
+// return ans == Integer.MAX_VALUE ? 0 : ans;
+// }
+
+ public int minSubArrayLen(int s, int[] nums) {
+ int ans = Integer.MAX_VALUE;
+ int[] sums = new int[nums.length + 1];
+ for (int i = 0; i < nums.length; i++) {
+ sums[i + 1] = sums[i] + nums[i];
+ }
+ for (int i = 0; i < nums.length; i++) {
+ int target = s + sums[i]; // 确定要搜索的目标值
+ // Java 二分查找 Arrays.binarySearch 如果找到就会返回该元素的索引；
+ // 如果没找到就会返回一个负数，这个负数取反之后再减一就是查找的值应该在数组中的位置；
+ // 例如 [-1, 0, 1, 5] 中二分查找 2，其返回值就是 -4，其 -(-4) - 1 = 3，所以 2 这个元素插入到数组的索引就是 3
+ int bound = Arrays.binarySearch(sums, target);
+ if (bound < 0) {
+ bound = -bound - 1;
+ }
+ if (bound < sums.length) { // 当 bound 确定插入点不在 sums 数组的最后面时，说明不小于 target 的值了
+ ans = Math.min(ans, bound - i);
+ }
+ }
+ return ans == Integer.MAX_VALUE ? 0 : ans;
+ }
+
+ public static void main(String[] args) {
+ Solution solution = new Solution();
+ System.out.println(solution.minSubArrayLen(7, new int[]{2, 3, 1, 2, 4, 3}));
+ }
+}
\ No newline at end of file
From 81ed96d217df7ab6a2be481f2013db12dacf179b Mon Sep 17 00:00:00 2001
From: Blankj
Date: Tue, 7 Jul 2020 19:25:03 +0800
Subject: [PATCH 13/15] add 0063
---
README.md | 2 +
note/0063/README.md | 86 +++++++++++++++++++
.../{medium => hard}/_0057/Solution.java | 2 +-
src/com/blankj/medium/_0067/Solution.java | 40 +++++++++
4 files changed, 129 insertions(+), 1 deletion(-)
create mode 100644 note/0063/README.md
rename src/com/blankj/{medium => hard}/_0057/Solution.java (97%)
create mode 100644 src/com/blankj/medium/_0067/Solution.java
diff --git a/README.md b/README.md
index d3d2aaff..2bff41d9 100644
--- a/README.md
+++ b/README.md
@@ -85,6 +85,7 @@
| 49 | [Group Anagrams][0049] | Hash Table, String |
| 50 | [Pow(x, n)][0050] | Math, Binary Search |
| 56 | [Merge Intervals][0056] | Array, Sort |
+| 63 | [不同路径 II(Unique Paths II)][0063] | 数组、动态规划 |
| 209 | [长度最小的子数组(Minimum Size Subarray Sum)][0209] | 数组、双指针、二分查找 |
| 215 | [数组中的第K个最大元素(Kth Largest Element in an Array)][0215] | 堆、分治算法 |
| 554 | [Brick Wall][0554] | Hash Table |
@@ -169,6 +170,7 @@
[0049]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0049/README.md
[0050]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0050/README.md
[0056]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0056/README.md
+[0063]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0063/README.md
[0209]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0209/README.md
[0215]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0215/README.md
[0554]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0554/README.md
diff --git a/note/0063/README.md b/note/0063/README.md
new file mode 100644
index 00000000..2905be6f
--- /dev/null
+++ b/note/0063/README.md
@@ -0,0 +1,86 @@
+# [不同路径 II(Unique Paths II)][title]
+
+## 题目描述
+
+一个机器人位于一个 _m x n_ 网格的左上角 （起始点在下图中标记为“Start” ）。
+
+机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。
+
+现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？
+
+
+
+网格中的障碍物和空位置分别用 `1` 和 `0` 来表示。
+
+**说明：**_m_ 和 _n_ 的值均不超过 100。
+
+**示例 1:**
+```
+输入:
+[
+ [0,0,0],
+ [0,1,0],
+ [0,0,0]
+]
+输出: 2
+解释:
+3x3 网格的正中间有一个障碍物。
+从左上角到右下角一共有 2 条不同的路径：
+1. 向右 -> 向右 -> 向下 -> 向下
+2. 向下 -> 向下 -> 向右 -> 向右
+```
+
+**标签：** 数组、动态规划
+
+
+## 思路
+
+做过爬楼梯的应该很快就能想到这是一道很典型的动态规划题目，
+
+我们令 `dp[i][j]` 表示走到格子 `(i, j)` 的路径数，
+
+那么当 `(i, j)` 没障碍物时，`dp[i][j] = 0`；
+
+那么当 `(i, j)` 有障碍物时，`dp[i][j] = dp[i - 1][j] + dp[i][j - 1]`；
+
+其初始态第 1 列（行）的格子只有从其上（左）边格子走过去这一种走法，因此初始化 `dp[i][0]`（`dp[0][j]`）值为 1，且遇到障碍物时后面值都为 0；
+
+有了这些条件，我相信你肯定可以写出代码来了，具体如下所示：
+
+
+```java
+class Solution {
+ public int uniquePathsWithObstacles(int[][] obstacleGrid) {
+ int m = obstacleGrid.length, n = obstacleGrid[0].length;
+ int[][] dp = new int[m][n];
+ // 其初始态第 1 列（行）的格子只有从其上（左）边格子走过去这一种走法，
+ // 因此初始化 dp[i][0]（dp[0][j]）值为 1，且遇到障碍物时后面值都为 0；
+ for (int i = 0; i < m && obstacleGrid[i][0] == 0; i++) {
+ dp[i][0] = 1;
+ }
+ for (int j = 0; j < n && obstacleGrid[0][j] == 0; j++) {
+ dp[0][j] = 1;
+ }
+
+ for (int i = 1; i < m; i++) {
+ for (int j = 1; j < n; j++) {
+ if (obstacleGrid[i][j] == 0) {
+ // 当 (i, j) 有障碍物时，dp[i][j] = dp[i - 1][j] + dp[i][j - 1]；
+ dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
+ }
+ }
+ }
+ return dp[m - 1][n - 1];
+ }
+}
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
+
+
+
+[title]: https://leetcode-cn.com/problems/unique-paths-ii
+[ajl]: https://github.com/Blankj/awesome-java-leetcode
diff --git a/src/com/blankj/medium/_0057/Solution.java b/src/com/blankj/hard/_0057/Solution.java
similarity index 97%
rename from src/com/blankj/medium/_0057/Solution.java
rename to src/com/blankj/hard/_0057/Solution.java
index 8fde4e3a..1e5b4cea 100644
--- a/src/com/blankj/medium/_0057/Solution.java
+++ b/src/com/blankj/hard/_0057/Solution.java
@@ -1,4 +1,4 @@
-package com.blankj.medium._057;
+package com.blankj.hard._0057;
import com.blankj.structure.Interval;
diff --git a/src/com/blankj/medium/_0067/Solution.java b/src/com/blankj/medium/_0067/Solution.java
new file mode 100644
index 00000000..aba07bad
--- /dev/null
+++ b/src/com/blankj/medium/_0067/Solution.java
@@ -0,0 +1,40 @@
+package com.blankj.medium._0067;
+
+/**
+ *
+ * author: Blankj
+ * blog : http://blankj.com
+ * time : 2020/07/07
+ * desc :
+ *
+ */
+public class Solution {
+ public int uniquePathsWithObstacles(int[][] obstacleGrid) {
+ int m = obstacleGrid.length, n = obstacleGrid[0].length;
+ int[][] dp = new int[m][n];
+ // 其初始态第 1 列（行）的格子只有从其上（左）边格子走过去这一种走法，
+ // 因此初始化 dp[i][0]（dp[0][j]）值为 1，且遇到障碍物时后面值都为 0；
+ for (int i = 0; i < m && obstacleGrid[i][0] == 0; i++) {
+ dp[i][0] = 1;
+ }
+ for (int j = 0; j < n && obstacleGrid[0][j] == 0; j++) {
+ dp[0][j] = 1;
+ }
+
+ for (int i = 1; i < m; i++) {
+ for (int j = 1; j < n; j++) {
+ if (obstacleGrid[i][j] == 0) {
+ // 当 (i, j) 有障碍物时，dp[i][j] = dp[i - 1][j] + dp[i][j - 1]；
+ dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
+ }
+ }
+ }
+ return dp[m - 1][n - 1];
+ }
+
+ public static void main(String[] args) {
+ Solution solution = new Solution();
+ int[][] obstacleGrid = {{0, 0, 0}, {0, 1, 0}, {0, 0, 0}};
+ System.out.println(solution.uniquePathsWithObstacles(obstacleGrid));
+ }
+}
From c781c4987cfe8a9fdcebcd99d86e64a85b3770db Mon Sep 17 00:00:00 2001
From: Blankj
Date: Wed, 8 Jul 2020 13:37:41 +0800
Subject: [PATCH 14/15] add 16_11
---
README.md | 2 +
note/16_11/README.md | 68 ++++++++++++++++++++++++
src/com/blankj/easy/_16_11/Solution.java | 34 ++++++++++++
3 files changed, 104 insertions(+)
create mode 100644 note/16_11/README.md
create mode 100644 src/com/blankj/easy/_16_11/Solution.java
diff --git a/README.md b/README.md
index 2bff41d9..3ca83443 100644
--- a/README.md
+++ b/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
diff --git a/note/16_11/README.md b/note/16_11/README.md
new file mode 100644
index 00000000..13e6d104
--- /dev/null
+++ b/note/16_11/README.md
@@ -0,0 +1,68 @@
+# [跳水板(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;
+ }
+}
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
+
+
+
+[title]: https://leetcode-cn.com/problems/diving-board-lcci
+[ajl]: https://github.com/Blankj/awesome-java-leetcode
diff --git a/src/com/blankj/easy/_16_11/Solution.java b/src/com/blankj/easy/_16_11/Solution.java
new file mode 100644
index 00000000..2e9e7906
--- /dev/null
+++ b/src/com/blankj/easy/_16_11/Solution.java
@@ -0,0 +1,34 @@
+package com.blankj.easy._16_11;
+
+import java.util.Arrays;
+
+/**
+ *
+ * author: Blankj
+ * blog : http://blankj.com
+ * time : 2020/07/08
+ * desc :
+ *
+ */
+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)));
+ }
+}
From 0d17728bfbe128132b21156dce19d4a5aa5001e9 Mon Sep 17 00:00:00 2001
From: Blankj
Date: Thu, 10 Dec 2020 23:20:20 +0800
Subject: [PATCH 15/15] Update README.md
---
README.md | 6 ++----
1 file changed, 2 insertions(+), 4 deletions(-)
diff --git a/README.md b/README.md
index 3ca83443..7f7fa5da 100644
--- a/README.md
+++ b/README.md
@@ -108,9 +108,7 @@
## 打个小广告
-欢迎加入我的知识星球「**[基你太美](https://t.zsxq.com/FmeqfYF)**」，我会在星球中分享 [AucFrame](https://blankj.com/2019/07/22/auc-frame/) 框架、大厂面经、[AndroidUtilCode](https://github.com/Blankj/AndroidUtilCode) 更详尽的说明...一切我所了解的知识，你可以通过支付进入我的星球「**[基你太美](https://t.zsxq.com/FmeqfYF)**」进行体验，加入后优先观看星球中精华的部分，如果觉得星球的内容对自身没有收益，你可以自行申请退款退出星球，也没必要加我好友；**如果你已确定要留在我的星球，可以通过扫描如下二维码（备注：基你太美+你的星球昵称）加我个人微信，方便我后续拉你进群(PS：进得越早价格越便宜)。**
-
-
+欢迎加入我的小专栏「**[基你太美](https://xiaozhuanlan.com/Blankj)**」一起学习。
[src]: https://github.com/Blankj/awesome-java-leetcode/tree/master/src
@@ -186,4 +184,4 @@
[0044]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0044/README.md
[0057]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0057/README.md
[0068]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0068/README.md
-[1028]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/1028/README.md
\ No newline at end of file
+[1028]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/1028/README.md