From f2fa69fe349b3c52fe7d4c9f9a2546f93c0b9f8e Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Fri, 3 Nov 2017 11:42:47 +0800
Subject: [PATCH 01/58] feat: update 021

---
 note/021/README.md | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

diff --git a/note/021/README.md b/note/021/README.md
index 4e907659..3c11f380 100644
--- a/note/021/README.md
+++ b/note/021/README.md
@@ -2,14 +2,7 @@
 
 ## Description
 
-Given a sorted array, remove the duplicates in place such that each element appear only *once* and return the new length.
-
-Do not allocate extra space for another array, you must do this in place with constant memory.
-
-For example,
-Given input array *nums* = `[1,1,2]`,
-
-Your function should return length = `2`, with the first two elements of *nums* being `1` and `2` respectively. It doesn't matter what you leave beyond the new length.
+Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists.
 
 **Tags:** Linked List
 

From 12d90741d50b093b10d70b04f166e2c5cca7bc4f Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Fri, 3 Nov 2017 13:41:33 +0800
Subject: [PATCH 02/58] feat: add 068

---
 README.md                              |  2 +
 note/068/README.md                     | 95 ++++++++++++++++++++++++++
 src/com/blankj/hard/_068/Solution.java | 61 +++++++++++++++++
 3 files changed, 158 insertions(+)
 create mode 100644 note/068/README.md
 create mode 100644 src/com/blankj/hard/_068/Solution.java

diff --git a/README.md b/README.md
index d0cfe765..793cd9e0 100644
--- a/README.md
+++ b/README.md
@@ -91,6 +91,7 @@
 |25|[Reverse Nodes in k-Group][025]|Linked List|
 |44|[Reverse Nodes in k-Group][044]|String, Dynamic Programming, Backtracking, Greedy|
 |57|[Insert Interval][057]|Array, Sort|
+|68|[Text Justification][068]|String|
 
 
 
@@ -152,3 +153,4 @@
 [025]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/025/README.md
 [044]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/044/README.md
 [057]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/057/README.md
+[068]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/068/README.md
diff --git a/note/068/README.md b/note/068/README.md
new file mode 100644
index 00000000..32f2f432
--- /dev/null
+++ b/note/068/README.md
@@ -0,0 +1,95 @@
+# [Text Justification][title]
+
+## Description
+
+Given an array of words and a length *L*, format the text such that each line has exactly *L* characters and is fully (left and right) justified.
+
+You should pack your words in a greedy approach; that is, pack as many words as you can in each line. Pad extra spaces `' '` when necessary so that each line has exactly *L* characters.
+
+Extra spaces between words should be distributed as evenly as possible. If the number of spaces on a line do not divide evenly between words, the empty slots on the left will be assigned more spaces than the slots on the right.
+
+For the last line of text, it should be left justified and no extra space is inserted between words.
+
+For example,
+**words**: `["This", "is", "an", "example", "of", "text", "justification."]`
+**L**: `16`.
+
+Return the formatted lines as:
+
+```
+[
+   "This    is    an",
+   "example  of text",
+   "justification.  "
+]
+
+```
+
+**Note:** Each word is guaranteed not to exceed *L* in length.
+
+**Corner Cases:**
+
+- A line other than the last line might contain only one word. What should you do in this case?
+  In this case, that line should be left-justified.
+
+**Tags:** String
+
+
+## 思路
+
+题意是给你一组单词和最大行宽，让你对齐他们，对齐的规则就是尽可能一行可以放下足够多的单词，如果最后有多余的空格，那就把空格均匀地插入到单词之间，如果不能平分的话，那就从左开始依次多插一个空格，最后一行单词之间就正常地一个空格即可，如果凑不到最大行宽，那就在末尾补充空格即可，描述地比较差，不懂的话其实看看demo也就懂了哈。题还是比较坑的，毕竟踩的比赞的人多，我也是靠模拟老老实实做出来的，求出可以最多插入空格数，然后用它除以可以插入的槽数获取每个单词之间的空格，它两取余的话就是最面需要多插入一个空格的个数，最后一行的话就单独处理即可。
+
+```java
+class Solution {
+    public List<String> fullJustify(String[] words, int maxWidth) {
+        int len = words.length;
+        List<String> ans = new ArrayList<>();
+        StringBuilder spaces = new StringBuilder();
+        for (int i = 0; i < maxWidth; ++i) {
+            spaces.append(" ");
+        }
+        int curLen = -1, start = 0;
+        for (int i = 0; i < len; ++i) {
+            if (curLen + words[i].length() + 1 <= maxWidth) {
+                curLen += words[i].length() + 1;
+            } else {
+                StringBuilder sub = new StringBuilder(words[start]);
+                int rest = maxWidth - curLen;
+                int l = i - start - 1;
+                if (l <= 0) {
+                    sub.append(spaces.substring(0, rest));
+                } else {
+                    int m = rest / l + 1;
+                    int mod = rest % l;
+                    for (int j = start + 1; j < i; ++j) {
+                        if (mod-- > 0) {
+                            sub.append(spaces.substring(0, m + 1)).append(words[j]);
+                        } else {
+                            sub.append(spaces.substring(0, m)).append(words[j]);
+                        }
+                    }
+                }
+                ans.add(sub.toString());
+                start = i;
+                curLen = words[i].length();
+            }
+        }
+        StringBuilder sub = new StringBuilder(words[start]);
+        for (int i = start + 1; i < len; ++i) {
+            sub.append(" ").append(words[i]);
+        }
+        ans.add(sub + spaces.substring(0, maxWidth - sub.length()));
+        return ans;
+    }
+}
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+
+
+
+[title]: https://leetcode.com/problems/text-justification
+[ajl]: https://github.com/Blankj/awesome-java-leetcode
diff --git a/src/com/blankj/hard/_068/Solution.java b/src/com/blankj/hard/_068/Solution.java
new file mode 100644
index 00000000..14b3a98f
--- /dev/null
+++ b/src/com/blankj/hard/_068/Solution.java
@@ -0,0 +1,61 @@
+package com.blankj.hard._068;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * <pre>
+ *     author: Blankj
+ *     blog  : http://blankj.com
+ *     time  : 2017/11/01
+ *     desc  :
+ * </pre>
+ */
+public class Solution {
+
+    public List<String> fullJustify(String[] words, int maxWidth) {
+        int len = words.length;
+        List<String> ans = new ArrayList<>();
+        StringBuilder spaces = new StringBuilder();
+        for (int i = 0; i < maxWidth; ++i) {
+            spaces.append(" ");
+        }
+        int curLen = -1, start = 0;
+        for (int i = 0; i < len; ++i) {
+            if (curLen + words[i].length() + 1 <= maxWidth) {
+                curLen += words[i].length() + 1;
+            } else {
+                StringBuilder sub = new StringBuilder(words[start]);
+                int rest = maxWidth - curLen;
+                int l = i - start - 1;
+                if (l <= 0) {
+                    sub.append(spaces.substring(0, rest));
+                } else {
+                    int m = rest / l + 1;
+                    int mod = rest % l;
+                    for (int j = start + 1; j < i; ++j) {
+                        if (mod-- > 0) {
+                            sub.append(spaces.substring(0, m + 1)).append(words[j]);
+                        } else {
+                            sub.append(spaces.substring(0, m)).append(words[j]);
+                        }
+                    }
+                }
+                ans.add(sub.toString());
+                start = i;
+                curLen = words[i].length();
+            }
+        }
+        StringBuilder sub = new StringBuilder(words[start]);
+        for (int i = start + 1; i < len; ++i) {
+            sub.append(" ").append(words[i]);
+        }
+        ans.add(sub + spaces.substring(0, maxWidth - sub.length()));
+        return ans;
+    }
+
+    public static void main(String[] args) {
+        Solution solution = new Solution();
+        System.out.println(solution.fullJustify(new String[]{"This", "is", "an", "example", "of", "text", "justification."}, 16));
+    }
+}

From ca3a4933ff771bfbb569c6f4736e4158ec90f856 Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Sat, 4 Nov 2017 15:06:35 +0800
Subject: [PATCH 03/58] feat: add 005

---
 README.md                                |  1 +
 note/005/README.md                       | 77 ++++++++++++++++++++++++
 src/com/blankj/medium/_005/Solution.java | 41 +++++++++++++
 3 files changed, 119 insertions(+)
 create mode 100644 note/005/README.md
 create mode 100644 src/com/blankj/medium/_005/Solution.java

diff --git a/README.md b/README.md
index 793cd9e0..296c88bf 100644
--- a/README.md
+++ b/README.md
@@ -69,6 +69,7 @@
 |:------------- |:------------- |:------------- |
 |2|[Add Two Numbers][002]|Linked List, Math|
 |3|[Longest Substring Without Repeating Characters][003]|Hash Table, Two Pointers, String|
+|5|[Longest Palindromic Substring][005]|String|
 |8|[String to Integer (atoi)][008]|Math, String|
 |15|[3Sum][015]|Array, Two Pointers|
 |17|[Letter Combinations of a Phone Number][017]|String, Backtracking|
diff --git a/note/005/README.md b/note/005/README.md
new file mode 100644
index 00000000..e8e32d11
--- /dev/null
+++ b/note/005/README.md
@@ -0,0 +1,77 @@
+# [Longest Palindromic Substring][title]
+
+## Description
+
+Given a string **s**, find the longest palindromic substring in **s**. You may assume that the maximum length of **s** is 1000.
+
+**Example:**
+
+```
+Input: "babad"
+
+Output: "bab"
+
+Note: "aba" is also a valid answer.
+
+```
+
+**Example:**
+
+```
+Input: "cbbd"
+
+Output: "bb"
+```
+
+**Tags:** String
+
+
+## 思路0
+
+题意是寻找出字符串中最长的回文串，所谓回文串就是正序和逆序相同的字符串，也就是关于中间对称。我们先用最常规的做法，依次去求得每个字符的最长回文，要注意每个字符有奇数长度的回文串和偶数长度的回文串两种情况，相信你可以很轻易地从如下代码中找到相关代码，记录最长回文的始末位置即可，时间复杂度的话，首先要遍历一遍字符串，然后对每个字符都去求得最长回文，所以时间复杂度为O(n^2)。
+
+```java
+class Solution {
+    int st, end;
+
+    public String longestPalindrome(String s) {
+        int len = s.length();
+        if (len <= 1) return s;
+        char[] chars = s.toCharArray();
+        for (int i = 0; i < len; i++) {
+            helper(chars, i, i);
+            helper(chars, i, i + 1);
+        }
+        return s.substring(st, end + 1);
+    }
+
+    private void helper(char[] chars, int l, int r) {
+        while (l >= 0 && r < chars.length && chars[l] == chars[r]) {
+            --l;
+            ++r;
+        }
+        if (end - st < r - l - 2) {
+            st = l + 1;
+            end = r - 1;
+        }
+    }
+}
+```
+
+## 思路1
+
+
+
+```java
+
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+
+
+
+[title]: https://leetcode.com/problems/longest-palindromic-substring
+[ajl]: https://github.com/Blankj/awesome-java-leetcode
diff --git a/src/com/blankj/medium/_005/Solution.java b/src/com/blankj/medium/_005/Solution.java
new file mode 100644
index 00000000..e0c4eebe
--- /dev/null
+++ b/src/com/blankj/medium/_005/Solution.java
@@ -0,0 +1,41 @@
+package com.blankj.medium._005;
+
+/**
+ * <pre>
+ *     author: Blankj
+ *     blog  : http://blankj.com
+ *     time  : 2017/11/04
+ *     desc  :
+ * </pre>
+ */
+public class Solution {
+    int st, end;
+
+    public String longestPalindrome(String s) {
+        int len = s.length();
+        if (len <= 1) return s;
+        char[] chars = s.toCharArray();
+        for (int i = 0; i < len; i++) {
+            helper(chars, i, i);
+            helper(chars, i, i + 1);
+        }
+        return s.substring(st, end + 1);
+    }
+
+    private void helper(char[] chars, int l, int r) {
+        while (l >= 0 && r < chars.length && chars[l] == chars[r]) {
+            --l;
+            ++r;
+        }
+        if (end - st < r - l - 2) {
+            st = l + 1;
+            end = r - 1;
+        }
+    }
+
+    public static void main(String[] args) {
+        Solution solution = new Solution();
+        System.out.println(solution.longestPalindrome("babad"));
+        System.out.println(solution.longestPalindrome("cbbd"));
+    }
+}

From 99608a03b17b539f927f7d2ad9738a7fcc21e5e8 Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Sun, 5 Nov 2017 16:20:55 +0800
Subject: [PATCH 04/58] feat: update 005

---
 note/005/README.md                       | 39 +++++++++++++++--
 src/com/blankj/medium/_005/Solution.java | 53 +++++++++++++++++-------
 2 files changed, 75 insertions(+), 17 deletions(-)

diff --git a/note/005/README.md b/note/005/README.md
index e8e32d11..49dbfa62 100644
--- a/note/005/README.md
+++ b/note/005/README.md
@@ -28,7 +28,7 @@ Output: "bb"
 
 ## 思路0
 
-题意是寻找出字符串中最长的回文串，所谓回文串就是正序和逆序相同的字符串，也就是关于中间对称。我们先用最常规的做法，依次去求得每个字符的最长回文，要注意每个字符有奇数长度的回文串和偶数长度的回文串两种情况，相信你可以很轻易地从如下代码中找到相关代码，记录最长回文的始末位置即可，时间复杂度的话，首先要遍历一遍字符串，然后对每个字符都去求得最长回文，所以时间复杂度为O(n^2)。
+题意是寻找出字符串中最长的回文串，所谓回文串就是正序和逆序相同的字符串，也就是关于中间对称。我们先用最常规的做法，依次去求得每个字符的最长回文，要注意每个字符有奇数长度的回文串和偶数长度的回文串两种情况，相信你可以很轻易地从如下代码中找到相关代码，记录最长回文的始末位置即可，时间复杂度的话，首先要遍历一遍字符串，然后对每个字符都去求得最长回文，所以时间复杂度为 `O(n^2)`。
 
 ```java
 class Solution {
@@ -58,15 +58,48 @@ class Solution {
 }
 ```
 
-## 思路1
 
+## 思路1
 
+如果利用暴力法遍历所有字串是否回文的情况这道题肯定是 `Time Limit Exceeded` 的，那么我们是否可以把之前遍历的结果利用上呢，那么动态规划的想法就呼之欲出了，我们定义 `dp[i][j]` 的意思为字符串区间`[i, j]`是否为回文串，那么我们分三种情况：
+1. 当 `i == j` 时，那么毫无疑问 `dp[i][j] = true`；
+2. 当 `i + 1 == j` 时，那么 `dp[i][j]` 的值取决于 `s[i] == s[j]`；
+3. 当 `i + 1 < j` 时，那么 `dp[i][j]` 的值取决于 `dp[i + 1][j - 1] && s[i] == s[j]`；
+根据以上的动态转移方程，我们的问题即可迎刃而解，时间复杂度的话很显而易见，也是 `O(n^2)`。
 
 ```java
-
+class Solution {
+    public String longestPalindrome(String s) {
+        int len = s.length();
+        if (len <= 1) return s;
+        int st = 0, end = 0;
+        char[] chars = s.toCharArray();
+        boolean[][] dp = new boolean[len][len];
+        for (int i = 0; i < len; i++) {
+            dp[i][i] = true;
+            for (int j = 0; j < i; j++) {
+                if (j + 1 == i) {
+                    dp[j][i] = chars[j] == chars[i];
+                } else {
+                    dp[j][i] = dp[j + 1][i - 1] && chars[j] == chars[i];
+                }
+                if (dp[j][i] && i - j > end - st) {
+                    st = j;
+                    end = i;
+                }
+            }
+        }
+        return s.substring(st, end + 1);
+    }
+}
 ```
 
 
+## 思路2
+
+最后一种思路那就是 `Manacher's Algorithm`，中文名叫马拉车算法，该算法就是专为解决此问题而发明的。
+
+
 ## 结语
 
 如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
diff --git a/src/com/blankj/medium/_005/Solution.java b/src/com/blankj/medium/_005/Solution.java
index e0c4eebe..effdf1b6 100644
--- a/src/com/blankj/medium/_005/Solution.java
+++ b/src/com/blankj/medium/_005/Solution.java
@@ -9,30 +9,55 @@
  * </pre>
  */
 public class Solution {
-    int st, end;
+//    int st, end;
+//
+//    public String longestPalindrome(String s) {
+////        st = 0;
+////        end = 0;
+//        int len = s.length();
+//        if (len <= 1) return s;
+//        char[] chars = s.toCharArray();
+//        for (int i = 0; i < len; i++) {
+//            helper(chars, i, i);
+//            helper(chars, i, i + 1);
+//        }
+//        return s.substring(st, end + 1);
+//    }
+//
+//    private void helper(char[] chars, int l, int r) {
+//        while (l >= 0 && r < chars.length && chars[l] == chars[r]) {
+//            --l;
+//            ++r;
+//        }
+//        if (end - st < r - l - 2) {
+//            st = l + 1;
+//            end = r - 1;
+//        }
+//    }
 
     public String longestPalindrome(String s) {
         int len = s.length();
         if (len <= 1) return s;
+        int st = 0, end = 0;
         char[] chars = s.toCharArray();
+        boolean[][] dp = new boolean[len][len];
         for (int i = 0; i < len; i++) {
-            helper(chars, i, i);
-            helper(chars, i, i + 1);
+            dp[i][i] = true;
+            for (int j = 0; j < i; j++) {
+                if (j + 1 == i) {
+                    dp[j][i] = chars[j] == chars[i];
+                } else {
+                    dp[j][i] = dp[j + 1][i - 1] && chars[j] == chars[i];
+                }
+                if (dp[j][i] && i - j > end - st) {
+                    st = j;
+                    end = i;
+                }
+            }
         }
         return s.substring(st, end + 1);
     }
 
-    private void helper(char[] chars, int l, int r) {
-        while (l >= 0 && r < chars.length && chars[l] == chars[r]) {
-            --l;
-            ++r;
-        }
-        if (end - st < r - l - 2) {
-            st = l + 1;
-            end = r - 1;
-        }
-    }
-
     public static void main(String[] args) {
         Solution solution = new Solution();
         System.out.println(solution.longestPalindrome("babad"));

From db178b644d85f955d3a5d6df30438f3045069c97 Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Sun, 5 Nov 2017 16:22:20 +0800
Subject: [PATCH 05/58] feat: add 005

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index 296c88bf..f3a2fce8 100644
--- a/README.md
+++ b/README.md
@@ -137,6 +137,7 @@
 
 [002]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/002/README.md
 [003]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/003/README.md
+[005]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/005/README.md
 [008]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/008/README.md
 [015]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/015/README.md
 [017]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/017/README.md

From 5765dbc6301e30251449096e49efa9c3d17163cb Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Mon, 6 Nov 2017 18:24:20 +0800
Subject: [PATCH 06/58] feat: update 005

---
 note/005/README.md                       | 31 ++++++++++++++--
 src/com/blankj/medium/_005/Solution.java | 46 +++++++++++++-----------
 2 files changed, 55 insertions(+), 22 deletions(-)

diff --git a/note/005/README.md b/note/005/README.md
index 49dbfa62..a5f6519d 100644
--- a/note/005/README.md
+++ b/note/005/README.md
@@ -62,10 +62,12 @@ class Solution {
 ## 思路1
 
 如果利用暴力法遍历所有字串是否回文的情况这道题肯定是 `Time Limit Exceeded` 的，那么我们是否可以把之前遍历的结果利用上呢，那么动态规划的想法就呼之欲出了，我们定义 `dp[i][j]` 的意思为字符串区间`[i, j]`是否为回文串，那么我们分三种情况：
+
 1. 当 `i == j` 时，那么毫无疑问 `dp[i][j] = true`；
 2. 当 `i + 1 == j` 时，那么 `dp[i][j]` 的值取决于 `s[i] == s[j]`；
 3. 当 `i + 1 < j` 时，那么 `dp[i][j]` 的值取决于 `dp[i + 1][j - 1] && s[i] == s[j]`；
-根据以上的动态转移方程，我们的问题即可迎刃而解，时间复杂度的话很显而易见，也是 `O(n^2)`。
+
+根据以上的动态转移方程，我们的问题即可迎刃而解，时间复杂度的话显而易见，也是 `O(n^2)`。
 
 ```java
 class Solution {
@@ -97,7 +99,32 @@ class Solution {
 
 ## 思路2
 
-最后一种思路那就是 `Manacher's Algorithm`，中文名叫马拉车算法，该算法就是专为解决此问题而发明的。
+马拉车算法(Manacher's Algorithm)
+
+## 背景
+
+给定一个字符串，求出其最长回文子串。例如：
+
+1. s = "babad"，最长回文长度为 `3`，可以是 `bab` 或者 `aba`；
+2. s = "cbbda"，最长回文长度为 `2`，即 `bb`；
+3. s = "abcde"，最长回文长度为 `1`，即单个字符本身。
+
+等同于LeetCode上的第五题：[Longest Palindromic Substring](https://leetcode.com/problems/longest-palindromic-substring)
+
+其相关题解可以查看这里：[传送门](https://github.com/Blankj/awesome-java-leetcode/blob/master/note/005/README.md)
+
+以上问题的传统思路大概是，遍历每一个字符，以该字符为中心向两边查找。其时间复杂度为 `O(n2)`，效率很差。
+
+1975 年，一个叫 Manacher 的人发明了一个算法，Manacher 算法（中文名：马拉车算法），该算法可以把时间复杂度提升到 `O(n)`。下面来看看马拉车算法是如何工作的。
+
+最后一种思路那就是 `Manacher's Algorithm`，中文名叫马拉车算法，该算法就是专为解决此问题而发明的，其时间复杂度提升到了线性。下面我以我理解的思路来讲解其原理。
+由于回文串的奇偶行不确定，比如 `lol` 是奇回文，而 `lool` 是偶回文，马拉车算法的第一步就是对其进行预处理，做法就是在每个字符两侧都加上一个特殊字符，一般就是不会出现在原串中的即可，我们可以选取 `#`，那么
+
+`lol` -> `#l#o#l#`
+`lool` -> `#l#o#o#l#`
+
+这样处理后不管原来字符串长度是奇还是偶，最终得到的长度都将是奇数，这样就能把两种情况合并起来考虑。
+
 
 
 ## 结语
diff --git a/src/com/blankj/medium/_005/Solution.java b/src/com/blankj/medium/_005/Solution.java
index effdf1b6..5e35da9f 100644
--- a/src/com/blankj/medium/_005/Solution.java
+++ b/src/com/blankj/medium/_005/Solution.java
@@ -33,34 +33,40 @@ public class Solution {
 //            st = l + 1;
 //            end = r - 1;
 //        }
+//    }
+
+//    public String longestPalindrome(String s) {
+//        int len = s.length();
+//        if (len <= 1) return s;
+//        int st = 0, end = 0;
+//        char[] chars = s.toCharArray();
+//        boolean[][] dp = new boolean[len][len];
+//        for (int i = 0; i < len; i++) {
+//            dp[i][i] = true;
+//            for (int j = 0; j < i; j++) {
+//                if (j + 1 == i) {
+//                    dp[j][i] = chars[j] == chars[i];
+//                } else {
+//                    dp[j][i] = dp[j + 1][i - 1] && chars[j] == chars[i];
+//                }
+//                if (dp[j][i] && i - j > end - st) {
+//                    st = j;
+//                    end = i;
+//                }
+//            }
+//        }
+//        return s.substring(st, end + 1);
 //    }
 
     public String longestPalindrome(String s) {
-        int len = s.length();
-        if (len <= 1) return s;
-        int st = 0, end = 0;
-        char[] chars = s.toCharArray();
-        boolean[][] dp = new boolean[len][len];
-        for (int i = 0; i < len; i++) {
-            dp[i][i] = true;
-            for (int j = 0; j < i; j++) {
-                if (j + 1 == i) {
-                    dp[j][i] = chars[j] == chars[i];
-                } else {
-                    dp[j][i] = dp[j + 1][i - 1] && chars[j] == chars[i];
-                }
-                if (dp[j][i] && i - j > end - st) {
-                    st = j;
-                    end = i;
-                }
-            }
-        }
-        return s.substring(st, end + 1);
+
+        return s;
     }
 
     public static void main(String[] args) {
         Solution solution = new Solution();
         System.out.println(solution.longestPalindrome("babad"));
         System.out.println(solution.longestPalindrome("cbbd"));
+
     }
 }

From 58ee959c4fdffdc5ea7c215f44afc52ec7a5db49 Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Mon, 6 Nov 2017 23:06:27 +0800
Subject: [PATCH 07/58] feat: update 005

---
 note/005/README.md                     | 33 +++++++---
 src/com/blankj/hard/_044/Solution.java | 85 +++++++++++++++++++-------
 2 files changed, 89 insertions(+), 29 deletions(-)

diff --git a/note/005/README.md b/note/005/README.md
index a5f6519d..c29b7981 100644
--- a/note/005/README.md
+++ b/note/005/README.md
@@ -103,27 +103,44 @@ class Solution {
 
 ## 背景
 
-给定一个字符串，求出其最长回文子串。例如：
+给定一个字符串，求出其最长回文子串（回文字符串就是从左到右读和从右往左读完全一样，也就是字符串关于中间对称）。例如：
 
 1. s = "babad"，最长回文长度为 `3`，可以是 `bab` 或者 `aba`；
 2. s = "cbbda"，最长回文长度为 `2`，即 `bb`；
 3. s = "abcde"，最长回文长度为 `1`，即单个字符本身。
 
-等同于LeetCode上的第五题：[Longest Palindromic Substring](https://leetcode.com/problems/longest-palindromic-substring)
+这个问题等同于LeetCode上的 [Longest Palindromic Substring](https://leetcode.com/problems/longest-palindromic-substring)。
 
 其相关题解可以查看这里：[传送门](https://github.com/Blankj/awesome-java-leetcode/blob/master/note/005/README.md)
 
-以上问题的传统思路大概是，遍历每一个字符，以该字符为中心向两边查找。其时间复杂度为 `O(n2)`，效率很差。
+以上问题的传统思路大概是遍历每一个字符，以该字符为中心向两边查找，其时间复杂度为 `O(n2)`，效率很差。
 
-1975 年，一个叫 Manacher 的人发明了一个算法，Manacher 算法（中文名：马拉车算法），该算法可以把时间复杂度提升到 `O(n)`。下面来看看马拉车算法是如何工作的。
+1975年，一个叫 Manacher 的人发明了一个算法，Manacher 算法（中文名：马拉车算法），该算法可以把时间复杂度提升到 `O(n)`，下面按我理解的思路来讲解其原理。
 
-最后一种思路那就是 `Manacher's Algorithm`，中文名叫马拉车算法，该算法就是专为解决此问题而发明的，其时间复杂度提升到了线性。下面我以我理解的思路来讲解其原理。
 由于回文串的奇偶行不确定，比如 `lol` 是奇回文，而 `lool` 是偶回文，马拉车算法的第一步就是对其进行预处理，做法就是在每个字符两侧都加上一个特殊字符，一般就是不会出现在原串中的即可，我们可以选取 `#`，那么
 
-`lol` -> `#l#o#l#`
-`lool` -> `#l#o#o#l#`
+```
+lol  -> #l#o#l#
+lool -> #l#o#o#l#
+```
+
+这样处理后，不管原来字符串长度是奇数还是偶数，最终得到的长度都将是奇数，从而能把两种情况合并起来一起考虑，记预处理后的字符串为 `str`。
+
+我们把一个回文串中最左或最右位置的字符与其对称轴的距离称为回文半径。
+
+马拉车算法定义了一个回文半径数组 `len`，用 `len[i]` 表示以第 `i` 个字符为对称轴的回文串的回文半径，比如以 `str[i]` 为中心的最长回文串是 `str[l, r]`，那么 `len[i] = r - i + 1`
+
+我们以 `lollool` 为例，参看下表。
+
+| str  | #    | l    | #    | o    | #    | l    | #    | l    | #    | o    | #    | o    | #    | l    | #    |
+| :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- |
+| len  | 1    | 2    | 1    | 4    | l    | 2    | 3    | 2    | 1    | 2    | 5    | 2    | 1    | 2    | 1    |
+
+可以发现 `len[i] - 1` 就等于该回文串在原串中的长度。
+
+证明：在转换后的字符串 `str` 中，那么对于以 `str[i]` 为中心的最长回文串的长度为 `2 * len[i] - 1`,其中又有 `len[i]` 个分隔符，所以在原字符串中的长度就是 `len[i] - 1`。
 
-这样处理后不管原来字符串长度是奇还是偶，最终得到的长度都将是奇数，这样就能把两种情况合并起来考虑。
+那么我们剩下的工作就是求 `len` 数组
 
 
 
diff --git a/src/com/blankj/hard/_044/Solution.java b/src/com/blankj/hard/_044/Solution.java
index 3fa17b75..2a9de72c 100644
--- a/src/com/blankj/hard/_044/Solution.java
+++ b/src/com/blankj/hard/_044/Solution.java
@@ -1,5 +1,9 @@
 package com.blankj.hard._044;
 
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
 /**
  * <pre>
  *     author: Blankj
@@ -30,35 +34,74 @@ public class Solution {
 //        return pi == pl;
 //    }
 
-    public boolean isMatch(String s, String p) {
-        if (p.length() == 0) return s.length() == 0;
-        int sl = s.length(), pl = p.length();
-        boolean[][] dp = new boolean[sl + 1][pl + 1];
-        char[] sc = s.toCharArray(), pc = p.toCharArray();
-        dp[0][0] = true;
-        for (int i = 1; i <= pl; ++i) {
-            if (pc[i - 1] == '*') dp[0][i] = dp[0][i - 1];
+//    public boolean isMatch(String s, String p) {
+//        if (p.length() == 0) return s.length() == 0;
+//        int sl = s.length(), pl = p.length();
+//        boolean[][] dp = new boolean[sl + 1][pl + 1];
+//        char[] sc = s.toCharArray(), pc = p.toCharArray();
+//        dp[0][0] = true;
+//        for (int i = 1; i <= pl; ++i) {
+//            if (pc[i - 1] == '*') dp[0][i] = dp[0][i - 1];
+//        }
+//        for (int i = 1; i <= sl; ++i) {
+//            for (int j = 1; j <= pl; ++j) {
+//                if (pc[j - 1] != '*') {
+//                    dp[i][j] = dp[i - 1][j - 1] && (sc[i - 1] == pc[j - 1] || pc[j - 1] == '?');
+//                } else {
+//                    dp[i][j] = dp[i][j - 1] || dp[i - 1][j];
+//                }
+//            }
+//        }
+//        return dp[sl][pl];
+//    }
+
+    public List<String> fullJustify(String[] words, int maxWidth) {
+        int len = words.length;
+        if (len == 0) return Collections.emptyList();
+        List<String> ans = new ArrayList<>();
+        StringBuilder spaces = new StringBuilder();
+        for (int i = 0; i < maxWidth; ++i) {
+            spaces.append(" ");
         }
-        for (int i = 1; i <= sl; ++i) {
-            for (int j = 1; j <= pl; ++j) {
-                if (pc[j - 1] != '*') {
-                    dp[i][j] = dp[i - 1][j - 1] && (sc[i - 1] == pc[j - 1] || pc[j - 1] == '?');
+        int sLen = -1, left = 0;
+        for (int i = 0; i < len; ++i) {
+            if (sLen + words[i].length() + 1 <= maxWidth) {
+                sLen += words[i].length() + 1;
+            } else {
+                StringBuilder sub = new StringBuilder(words[left]);
+                int rest = maxWidth - sLen;
+                int seg = i - left;
+                if (seg == 0) {
+                    sub.append(spaces.substring(0, rest));
                 } else {
-                    dp[i][j] = dp[i][j - 1] || dp[i - 1][j];
+                    int leastSpace = rest / seg + 1;
+                    int restSpace = rest % seg;
+                    for (int j = left + 1; j < i; ++j) {
+                        if (restSpace-- > 0) {
+                            sub.append(spaces.substring(0, leastSpace + 1)).append(words[j]);
+                        } else {
+                            sub.append(spaces.substring(0, leastSpace)).append(words[j]);
+                        }
+                    }
                 }
+                ans.add(sub.toString());
+                left = i;
+                sLen = words[i].length();
             }
         }
-        return dp[sl][pl];
+        StringBuilder sub = new StringBuilder(words[left]);
+        for (int i = left + 1; i < len; ++i) {
+            sub.append(" ").append(words[i]);
+        }
+        ans.add(sub + spaces.substring(0, maxWidth - sub.length()));
+        return ans;
     }
 
+
     public static void main(String[] args) {
         Solution solution = new Solution();
-        System.out.println(solution.isMatch("aa", "a"));     // false
-        System.out.println(solution.isMatch("aa", "aa"));    // true
-        System.out.println(solution.isMatch("aaa", "aa"));   // false
-        System.out.println(solution.isMatch("aa", "*"));     // true
-        System.out.println(solution.isMatch("aa", "a*"));    // true
-        System.out.println(solution.isMatch("ab", "?*"));    // true
-        System.out.println(solution.isMatch("aab", "c*a*b"));// false
+        System.out.println(solution.fullJustify(new String[]{"", ""}, 0));
+        System.out.println(solution.fullJustify(new String[]{"a"}, 1));
+        System.out.println(solution.fullJustify(new String[]{"This", "is", "an", "example", "of", "text", "justification."}, 16));
     }
 }

From 631870e32b48a2e1990378ca8d7e3b3cfb749edf Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Tue, 7 Nov 2017 18:14:24 +0800
Subject: [PATCH 08/58] feat: update 005

---
 note/005/README.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/note/005/README.md b/note/005/README.md
index c29b7981..5f5dcce4 100644
--- a/note/005/README.md
+++ b/note/005/README.md
@@ -115,7 +115,7 @@ class Solution {
 
 以上问题的传统思路大概是遍历每一个字符，以该字符为中心向两边查找，其时间复杂度为 `O(n2)`，效率很差。
 
-1975年，一个叫 Manacher 的人发明了一个算法，Manacher 算法（中文名：马拉车算法），该算法可以把时间复杂度提升到 `O(n)`，下面按我理解的思路来讲解其原理。
+1975年，一个叫 Manacher 的人发明了 Manacher 算法（中文名：马拉车算法），该算法可以把时间复杂度提升到 `O(n)`，下面我以我理解的思路来讲解其原理。
 
 由于回文串的奇偶行不确定，比如 `lol` 是奇回文，而 `lool` 是偶回文，马拉车算法的第一步就是对其进行预处理，做法就是在每个字符两侧都加上一个特殊字符，一般就是不会出现在原串中的即可，我们可以选取 `#`，那么
 
@@ -134,13 +134,13 @@ lool -> #l#o#o#l#
 
 | str  | #    | l    | #    | o    | #    | l    | #    | l    | #    | o    | #    | o    | #    | l    | #    |
 | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- |
-| len  | 1    | 2    | 1    | 4    | l    | 2    | 3    | 2    | 1    | 2    | 5    | 2    | 1    | 2    | 1    |
+| len  | 1    | 2    | 1    | 4    | l    | 2    | 5    | 2    | 1    | 2    | 5    | 2    | 1    | 2    | 1    |
 
 可以发现 `len[i] - 1` 就等于该回文串在原串中的长度。
 
-证明：在转换后的字符串 `str` 中，那么对于以 `str[i]` 为中心的最长回文串的长度为 `2 * len[i] - 1`,其中又有 `len[i]` 个分隔符，所以在原字符串中的长度就是 `len[i] - 1`。
+证明：在转换后的字符串 `str` 中，那么对于以 `str[i]` 为中心的最长回文串的长度为 `2 * len[i] - 1`，其中又有 `len[i]` 个分隔符，所以在原字符串中的回文串长度就是 `len[i] - 1`。
 
-那么我们剩下的工作就是求 `len` 数组
+那么我们剩下的工作就是求 `len` 数组。
 
 
 

From 1ae153444cf4dd67363d3be09ddc751a5da40f3e Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Sun, 12 Nov 2017 23:33:18 +0800
Subject: [PATCH 09/58] feat: update 005

---
 note/005/README.md | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/note/005/README.md b/note/005/README.md
index 5f5dcce4..d5318270 100644
--- a/note/005/README.md
+++ b/note/005/README.md
@@ -109,14 +109,15 @@ class Solution {
 2. s = "cbbda"，最长回文长度为 `2`，即 `bb`；
 3. s = "abcde"，最长回文长度为 `1`，即单个字符本身。
 
-这个问题等同于LeetCode上的 [Longest Palindromic Substring](https://leetcode.com/problems/longest-palindromic-substring)。
-
-其相关题解可以查看这里：[传送门](https://github.com/Blankj/awesome-java-leetcode/blob/master/note/005/README.md)
+这个问题等同于LeetCode上的 [Longest Palindromic Substring](https://leetcode.com/problems/longest-palindromic-substring)，其相关题解可以查看这里：[传送门](https://github.com/Blankj/awesome-java-leetcode/blob/master/note/005/README.md)
 
 以上问题的传统思路大概是遍历每一个字符，以该字符为中心向两边查找，其时间复杂度为 `O(n2)`，效率很差。
 
 1975年，一个叫 Manacher 的人发明了 Manacher 算法（中文名：马拉车算法），该算法可以把时间复杂度提升到 `O(n)`，下面我以我理解的思路来讲解其原理。
 
+
+## 分析
+
 由于回文串的奇偶行不确定，比如 `lol` 是奇回文，而 `lool` 是偶回文，马拉车算法的第一步就是对其进行预处理，做法就是在每个字符两侧都加上一个特殊字符，一般就是不会出现在原串中的即可，我们可以选取 `#`，那么
 
 ```
@@ -132,9 +133,9 @@ lool -> #l#o#o#l#
 
 我们以 `lollool` 为例，参看下表。
 
-| str  | #    | l    | #    | o    | #    | l    | #    | l    | #    | o    | #    | o    | #    | l    | #    |
-| :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- |
-| len  | 1    | 2    | 1    | 4    | l    | 2    | 5    | 2    | 1    | 2    | 5    | 2    | 1    | 2    | 1    |
+| str   | #    | l    | #    | o    | #    | l    | #    | l    | #    | o    | #    | o    | #    | l    | #    |
+| :---  | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- |
+| len[] | 1    | 2    | 1    | 4    | l    | 2    | 5    | 2    | 1    | 2    | 5    | 2    | 1    | 2    | 1    |
 
 可以发现 `len[i] - 1` 就等于该回文串在原串中的长度。
 
@@ -142,6 +143,10 @@ lool -> #l#o#o#l#
 
 那么我们剩下的工作就是求 `len` 数组。
 
+为了防止数组越界，我们在首位再加上非 `#` 的不常用字符，比如 `~`，那么 `lollool` 就表示为 `~#l#o#l#l#o#o#l#~`，这样我们就省去写很多 `if else` 的边界处理。
+
+我们先看一张
+
 
 
 ## 结语

From b2bd0a23217cccaf73e95349e21407b2949fb6a0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=B8=83=E5=85=B0=E6=9F=AF=E5=9F=BA?= <blankj@qq.com>
Date: Mon, 13 Nov 2017 23:42:46 +0800
Subject: [PATCH 10/58] feat: update 005

---
 note/005/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/note/005/README.md b/note/005/README.md
index d5318270..ca543a41 100644
--- a/note/005/README.md
+++ b/note/005/README.md
@@ -145,7 +145,7 @@ lool -> #l#o#o#l#
 
 为了防止数组越界，我们在首位再加上非 `#` 的不常用字符，比如 `~`，那么 `lollool` 就表示为 `~#l#o#l#l#o#o#l#~`，这样我们就省去写很多 `if else` 的边界处理。
 
-我们先看一张
+我们先看一张图，如下所示：
 
 
 

From e185615e04f81b3ab74dc65ae7786f4bbe867557 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=B8=83=E5=85=B0=E6=9F=AF=E5=9F=BA?= <blankj@qq.com>
Date: Tue, 14 Nov 2017 23:49:41 +0800
Subject: [PATCH 11/58] feat: update 005

---
 note/005/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/note/005/README.md b/note/005/README.md
index ca543a41..745a0599 100644
--- a/note/005/README.md
+++ b/note/005/README.md
@@ -111,7 +111,7 @@ class Solution {
 
 这个问题等同于LeetCode上的 [Longest Palindromic Substring](https://leetcode.com/problems/longest-palindromic-substring)，其相关题解可以查看这里：[传送门](https://github.com/Blankj/awesome-java-leetcode/blob/master/note/005/README.md)
 
-以上问题的传统思路大概是遍历每一个字符，以该字符为中心向两边查找，其时间复杂度为 `O(n2)`，效率很差。
+以上问题的传统思路大概是遍历每一个字符，以该字符为中心向两边查找，其时间复杂度为 `O(n^2)`，效率很差。
 
 1975年，一个叫 Manacher 的人发明了 Manacher 算法（中文名：马拉车算法），该算法可以把时间复杂度提升到 `O(n)`，下面我以我理解的思路来讲解其原理。
 

From 46133412ae4d6ac123fec903343fb044b4f6e96e Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Wed, 6 Dec 2017 16:19:58 +0800
Subject: [PATCH 12/58] feat: update README

---
 README.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/README.md b/README.md
index f3a2fce8..a253a9d5 100644
--- a/README.md
+++ b/README.md
@@ -1,8 +1,8 @@
 # awesome-java-leetcode
 
-我如今是一名Android Developer，大学的我曾是一名ACMer，我一直认为数据结构和算法是作为一名程序员必须掌握和善于利用的，为了不让数据结构和算法淡出我的记忆，所以我打算重拾LeetCode之Algorithm，语言选择的是Java，题库会一点点完善起来，按简单，中等，困难分类，相应难度下按题号排序，源代码在[src][src]目录中，相关解题都在[note][note]目录中，想要学习数据结构和算法或打算刷LeetCode的小伙伴们欢迎star哦。
+我如今是一名 Android Developer，大学的我曾是一名 ACMer，我一直认为数据结构和算法是作为一名程序员必须掌握和善于利用的，为了不让数据结构和算法淡出我的记忆，所以我打算重拾 LeetCode 之 Algorithm，语言选择的是 Java，题库会一点点完善起来，按简单，中等，困难分类，相应难度下按题号排序，源代码在 [src][src] 目录中，相关解题都在 [note][note] 目录中，想要学习数据结构和算法或打算刷 LeetCode 的小伙伴们欢迎 star 哦。
 
-如今有机会面试Facebook，附上LeetCode上Facebook的面试题目序号，希望可以帮助到以后想入Facebook的小伙伴:-)
+如今有机会面试 Facebook，附上 LeetCode 上 Facebook 的面试题目序号，希望可以帮助到以后想入 Facebook 的小伙伴:-)
 
 ```
 1,10,13,15,17,20,23,25,26,28,33,38,43,44,49,50,56,57,67,68,69,71,75,76
@@ -12,12 +12,12 @@
 341,377,380,398,404,410,461,477,494,523,525,534,535,543,554
 ```
 
-如果想知道更多公司LeetCode面试题，可以参看[Companies.md][companies]。
+如果想知道更多公司 LeetCode 面试题，可以参看 [Companies.md][companies]。
 
 附上镇楼诗：
 
-> 明有科举八股，今有LeetCode。  
-> 八股定格式而取文采心意，LeetCode定题目且重答案背诵。  
+> 明有科举八股，今有 LeetCode。  
+> 八股定格式而取文采心意，LeetCode 定题目且重答案背诵。  
 > 美其名曰："practice makes perfect."  
 > 为何今不如古？  
 > 非也非也，  

From 7ab806004e5e3111b1a8db9c58d239328d30e1cb Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Fri, 8 Dec 2017 13:45:36 +0800
Subject: [PATCH 13/58] feat: update some description

---
 README.md          | 118 ++++++++++++++++++++++-----------------------
 note/002/README.md |  11 +++--
 note/003/README.md |   2 +-
 note/004/README.md |   1 -
 note/005/README.md |  11 +++--
 note/007/README.md |  29 ++++++-----
 note/010/README.md |  30 +++++++-----
 note/013/README.md |   6 ++-
 note/017/README.md |   1 +
 note/021/README.md |   7 +++
 note/023/README.md |   2 +-
 note/025/README.md |  10 ++--
 note/026/README.md |  14 ++++--
 note/027/README.md |  10 ++--
 note/028/README.md |  20 ++++++--
 note/033/README.md |   2 +
 note/035/README.md |  31 ++++++++++--
 note/038/README.md |   6 +--
 note/043/README.md |   3 ++
 note/044/README.md |   2 +
 note/049/README.md |   3 +-
 note/050/README.md |  16 +++++-
 note/053/README.md |   3 +-
 note/056/README.md |   2 +
 note/057/README.md |   5 ++
 note/058/README.md |   9 ++--
 note/067/README.md |   3 ++
 note/068/README.md |   3 ++
 note/069/README.md |  19 +++++++-
 note/070/README.md |  23 +++++++++
 note/083/README.md |   2 +
 note/088/README.md |   1 +
 note/100/README.md |  40 ++++++++++++++-
 note/101/README.md |   4 +-
 note/107/README.md |   2 +-
 note/108/README.md |  19 ++++++++
 note/110/README.md |   1 -
 note/111/README.md |   3 +-
 note/112/README.md |   1 -
 note/118/README.md |   1 +
 note/119/README.md |   2 +
 note/121/README.md |   1 -
 note/543/README.md |   1 +
 note/554/README.md |   1 +
 44 files changed, 346 insertions(+), 135 deletions(-)

diff --git a/README.md b/README.md
index a253a9d5..decbb6dd 100644
--- a/README.md
+++ b/README.md
@@ -26,73 +26,73 @@
 
 ## Easy
 
-|#|Title|Tag|
-|:------------- |:------------- |:------------- |
-|1|[Two Sum][001]|Array, Hash Table|
-|7|[Reverse Integer][007]|Math|
-|9|[Palindrome Number][009]|Math|
-|13|[Roman to Integer][013]|Math, String|
-|14|[Longest Common Prefix][014]|String|
-|20|[Valid Parentheses][020]|Stack, String|
-|21|[Merge Two Sorted Lists][021]|Linked List|
-|26|[Remove Duplicates from Sorted Array][026]|Array, Two Pointers|
-|27|[Remove Element][027]|Array, Two Pointers|
-|28|[Implement strStr()][028]|Two Pointers, String|
-|35|[Search Insert Position][035]|String|
-|38|[Count and Say][038]|String|
-|53|[Maximum Subarray][053]|Array, Dynamic Programming, Divide and Conquer|
-|58|[Length of Last Word][058]|String|
-|66|[Plus One][066]|Array, Math|
-|67|[Add Binary][067]|Math, String|
-|69|[Sqrt(x)][069]|Binary Search, Math|
-|70|[Climbing Stairs][070]|Dynamic Programming|
-|83|[Remove Duplicates from Sorted List][083]|Linked List|
-|88|[Merge Sorted Array][088]|Array, Two Pointers|
-|100|[Same Tree][100]|Tree, Depth-first Search|
-|101|[Symmetric Tree][101]|Tree, Depth-first Search, Breadth-first Search|
-|104|[Maximum Depth of Binary Tree][104]|Tree, Depth-first Search|
-|107|[Binary Tree Level Order Traversal II][107]|Tree, Breadth-first Search|
-|108|[Convert Sorted Array to Binary Search Tree][108]|Tree, Depth-first Search|
-|110|[Balanced Binary Tree][110]|Tree, Depth-first Search|
-|111|[Minimum Depth of Binary Tree][111]|Tree, Depth-first Search, Breadth-first Search|
-|112|[Path Sum][112]|Tree, Depth-first Search|
-|118|[Pascal's Triangle][118]|Array|
-|119|[Pascal's Triangle II][119]|Array|
-|121|[Best Time to Buy and Sell Stock][121]|Array, Dynamic Programmin|
-|122|[Best Time to Buy and Sell Stock II][122]|Array, Greedy|
-|543|[Diameter of Binary Tree][543]|Tree|
+| #    | Title                                    | Tag                                      |
+| :--- | :--------------------------------------- | :--------------------------------------- |
+| 1    | [Two Sum][001]                           | Array, Hash Table                        |
+| 7    | [Reverse Integer][007]                   | Math                                     |
+| 9    | [Palindrome Number][009]                 | Math                                     |
+| 13   | [Roman to Integer][013]                  | Math, String                             |
+| 14   | [Longest Common Prefix][014]             | String                                   |
+| 20   | [Valid Parentheses][020]                 | Stack, String                            |
+| 21   | [Merge Two Sorted Lists][021]            | Linked List                              |
+| 26   | [Remove Duplicates from Sorted Array][026] | Array, Two Pointers                      |
+| 27   | [Remove Element][027]                    | Array, Two Pointers                      |
+| 28   | [Implement strStr()][028]                | Two Pointers, String                     |
+| 35   | [Search Insert Position][035]            | String                                   |
+| 38   | [Count and Say][038]                     | String                                   |
+| 53   | [Maximum Subarray][053]                  | Array, Divide and Conquer, Dynamic Programming |
+| 58   | [Length of Last Word][058]               | String                                   |
+| 66   | [Plus One][066]                          | Array, Math                              |
+| 67   | [Add Binary][067]                        | Math, String                             |
+| 69   | [Sqrt(x)][069]                           | Binary Search, Math                      |
+| 70   | [Climbing Stairs][070]                   | Dynamic Programming                      |
+| 83   | [Remove Duplicates from Sorted List][083] | Linked List                              |
+| 88   | [Merge Sorted Array][088]                | Array, Two Pointers                      |
+| 100  | [Same Tree][100]                         | Tree, Depth-first Search                 |
+| 101  | [Symmetric Tree][101]                    | Tree, Depth-first Search, Breadth-first Search |
+| 104  | [Maximum Depth of Binary Tree][104]      | Tree, Depth-first Search                 |
+| 107  | [Binary Tree Level Order Traversal II][107] | Tree, Breadth-first Search               |
+| 108  | [Convert Sorted Array to Binary Search Tree][108] | Tree, Depth-first Search                 |
+| 110  | [Balanced Binary Tree][110]              | Tree, Depth-first Search                 |
+| 111  | [Minimum Depth of Binary Tree][111]      | Tree, Depth-first Search, Breadth-first Search |
+| 112  | [Path Sum][112]                          | Tree, Depth-first Search                 |
+| 118  | [Pascal's Triangle][118]                 | Array                                    |
+| 119  | [Pascal's Triangle II][119]              | Array                                    |
+| 121  | [Best Time to Buy and Sell Stock][121]   | Array, Dynamic Programmin                |
+| 122  | [Best Time to Buy and Sell Stock II][122] | Array, Greedy                            |
+| 543  | [Diameter of Binary Tree][543]           | Tree                                     |
 
 
 ## Medium
 
-|#|Title|Tag|
-|:------------- |:------------- |:------------- |
-|2|[Add Two Numbers][002]|Linked List, Math|
-|3|[Longest Substring Without Repeating Characters][003]|Hash Table, Two Pointers, String|
-|5|[Longest Palindromic Substring][005]|String|
-|8|[String to Integer (atoi)][008]|Math, String|
-|15|[3Sum][015]|Array, Two Pointers|
-|17|[Letter Combinations of a Phone Number][017]|String, Backtracking|
-|19|[Remove Nth Node From End of List][019]|Linked List, Two Pointers|
-|33|[Search in Rotated Sorted Array][033]|Arrays, Binary Search|
-|43|[Multiply Strings][043]|Math, String|
-|49|[Group Anagrams][049]|Hash Table, String|
-|50|[Pow(x, n)][050]|Math, Binary Search|
-|56|[Merge Intervals][056]|Array, Sort|
-|554|[Brick Wall][554]|Hash Table|
+| #    | Title                                    | Tag                              |
+| :--- | :--------------------------------------- | :------------------------------- |
+| 2    | [Add Two Numbers][002]                   | Linked List, Math                |
+| 3    | [Longest Substring Without Repeating Characters][003] | Hash Table, Two Pointers, String |
+| 5    | [Longest Palindromic Substring][005]     | String                           |
+| 8    | [String to Integer (atoi)][008]          | Math, String                     |
+| 15   | [3Sum][015]                              | Array, Two Pointers              |
+| 17   | [Letter Combinations of a Phone Number][017] | String, Backtracking             |
+| 19   | [Remove Nth Node From End of List][019]  | Linked List, Two Pointers        |
+| 33   | [Search in Rotated Sorted Array][033]    | Arrays, Binary Search            |
+| 43   | [Multiply Strings][043]                  | Math, String                     |
+| 49   | [Group Anagrams][049]                    | Hash Table, String               |
+| 50   | [Pow(x, n)][050]                         | Math, Binary Search              |
+| 56   | [Merge Intervals][056]                   | Array, Sort                      |
+| 554  | [Brick Wall][554]                        | Hash Table                       |
 
 
 ## Hard
 
-|#|Title|Tag|
-|:------------- |:------------- |:------------- |
-|4|[Median of Two Sorted Arrays][004]|Array, Binary Search, Divide and Conquer|
-|10|[Regular Expression Matching][010]|String, Dynamic Programming, Backtracking|
-|23|[Merge k Sorted Lists][023]|Linked List, Divide and Conquer, Heap|
-|25|[Reverse Nodes in k-Group][025]|Linked List|
-|44|[Reverse Nodes in k-Group][044]|String, Dynamic Programming, Backtracking, Greedy|
-|57|[Insert Interval][057]|Array, Sort|
-|68|[Text Justification][068]|String|
+| #    | Title                              | Tag                                      |
+| :--- | :--------------------------------- | :--------------------------------------- |
+| 4    | [Median of Two Sorted Arrays][004] | Array, Binary Search, Divide and Conquer |
+| 10   | [Regular Expression Matching][010] | String, Dynamic Programming, Backtracking |
+| 23   | [Merge k Sorted Lists][023]        | Linked List, Divide and Conquer, Heap    |
+| 25   | [Reverse Nodes in k-Group][025]    | Linked List                              |
+| 44   | [Wildcard Matching][044]           | String, Dynamic Programming, Backtracking, Greedy |
+| 57   | [Insert Interval][057]             | Array, Sort                              |
+| 68   | [Text Justification][068]          | String                                   |
 
 
 
diff --git a/note/002/README.md b/note/002/README.md
index 1aa30033..3c9a9a74 100644
--- a/note/002/README.md
+++ b/note/002/README.md
@@ -2,12 +2,17 @@
 
 ## Description
 
-You are given two **non-empty** linked lists representing two non-negative integers. The digits are stored in reverse order and each of their nodes contain a single digit. Add the two numbers and return it as a linked list.
+You are given two **non-empty** linked lists representing two non-negative integers. The digits are stored in **reverse order** and each of their nodes contain a single digit. Add the two numbers and return it as a linked list.
 
 You may assume the two numbers do not contain any leading zero, except the number 0 itself.
 
-**Input:** (2 -> 4 -> 3) + (5 -> 6 -> 4)
-**Output:** 7 -> 0 -> 8
+**Example**
+
+```
+Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)
+Output: 7 -> 0 -> 8
+Explanation: 342 + 465 = 807.
+```
 
 **Tags:** Linked List, Math
 
diff --git a/note/003/README.md b/note/003/README.md
index 527314c0..5baaba74 100644
--- a/note/003/README.md
+++ b/note/003/README.md
@@ -10,7 +10,7 @@ Given `"abcabcbb"`, the answer is `"abc"`, which the length is 3.
 
 Given `"bbbbb"`, the answer is `"b"`, with the length of 1.
 
-Given `"pwwkew"`, the answer is `"wke"`, with the length of 3. Note that the answer must be a **substring**, `"pwke"` is a *subsequence*and not a substring.
+Given `"pwwkew"`, the answer is `"wke"`, with the length of 3. Note that the answer must be a **substring**, `"pwke"` is a *subsequence* and not a substring.
 
 **Tags:** Hash Table, Two Pointers, String
 
diff --git a/note/004/README.md b/note/004/README.md
index e60a7009..f0871db4 100644
--- a/note/004/README.md
+++ b/note/004/README.md
@@ -13,7 +13,6 @@ nums1 = [1, 3]
 nums2 = [2]
 
 The median is 2.0
-
 ```
 
 **Example 2:**
diff --git a/note/005/README.md b/note/005/README.md
index 745a0599..03c2e1d0 100644
--- a/note/005/README.md
+++ b/note/005/README.md
@@ -12,7 +12,6 @@ Input: "babad"
 Output: "bab"
 
 Note: "aba" is also a valid answer.
-
 ```
 
 **Example:**
@@ -64,8 +63,10 @@ class Solution {
 如果利用暴力法遍历所有字串是否回文的情况这道题肯定是 `Time Limit Exceeded` 的，那么我们是否可以把之前遍历的结果利用上呢，那么动态规划的想法就呼之欲出了，我们定义 `dp[i][j]` 的意思为字符串区间`[i, j]`是否为回文串，那么我们分三种情况：
 
 1. 当 `i == j` 时，那么毫无疑问 `dp[i][j] = true`；
+
 2. 当 `i + 1 == j` 时，那么 `dp[i][j]` 的值取决于 `s[i] == s[j]`；
-3. 当 `i + 1 < j` 时，那么 `dp[i][j]` 的值取决于 `dp[i + 1][j - 1] && s[i] == s[j]`；
+
+3. 当 `i + 1 < j` 时，那么 `dp[i][j]` 的值取决于 `dp[i + 1][j - 1] && s[i] == s[j]`。
 
 根据以上的动态转移方程，我们的问题即可迎刃而解，时间复杂度的话显而易见，也是 `O(n^2)`。
 
@@ -101,12 +102,14 @@ class Solution {
 
 马拉车算法(Manacher's Algorithm)
 
-## 背景
+### 背景
 
 给定一个字符串，求出其最长回文子串（回文字符串就是从左到右读和从右往左读完全一样，也就是字符串关于中间对称）。例如：
 
 1. s = "babad"，最长回文长度为 `3`，可以是 `bab` 或者 `aba`；
+
 2. s = "cbbda"，最长回文长度为 `2`，即 `bb`；
+
 3. s = "abcde"，最长回文长度为 `1`，即单个字符本身。
 
 这个问题等同于LeetCode上的 [Longest Palindromic Substring](https://leetcode.com/problems/longest-palindromic-substring)，其相关题解可以查看这里：[传送门](https://github.com/Blankj/awesome-java-leetcode/blob/master/note/005/README.md)
@@ -116,7 +119,7 @@ class Solution {
 1975年，一个叫 Manacher 的人发明了 Manacher 算法（中文名：马拉车算法），该算法可以把时间复杂度提升到 `O(n)`，下面我以我理解的思路来讲解其原理。
 
 
-## 分析
+### 分析
 
 由于回文串的奇偶行不确定，比如 `lol` 是奇回文，而 `lool` 是偶回文，马拉车算法的第一步就是对其进行预处理，做法就是在每个字符两侧都加上一个特殊字符，一般就是不会出现在原串中的即可，我们可以选取 `#`，那么
 
diff --git a/note/007/README.md b/note/007/README.md
index a029947f..bc73dfca 100644
--- a/note/007/README.md
+++ b/note/007/README.md
@@ -2,27 +2,32 @@
 
 ## Description
 
-Reverse digits of an integer.
+Given a 32-bit signed integer, reverse digits of an integer.
 
-**Example1:** x = 123, return 321
+**Example 1:**
 
-**Example2:** x = -123, return -321
-
-**Spoilers:**
-
-**Have you thought about this?**
+```
+Input: 123
+Output:  321
+```
 
-Here are some good questions to ask before coding. Bonus points for you if you have already thought through this!
+**Example 2:**
 
-If the integer's last digit is 0, what should the output be? ie, cases such as 10, 100.
+```
+Input: -123
+Output: -321
+```
 
-Did you notice that the reversed integer might overflow? Assume the input is a 32-bit integer, then the reverse of 1000000003 overflows. How should you handle such cases?
+**Example 3:**
 
-For the purpose of this problem, assume that your function returns 0 when the reversed integer overflows.
+```
+Input: 120
+Output: 21
+```
 
 **Note:**
 
-The input is assumed to be a 32-bit signed integer. Your function should **return 0 when the reversed integer overflows**.
+Assume we are dealing with an environment which could only hold integers within the 32-bit signed integer range. For the purpose of this problem, assume that your function returns 0 when the reversed integer overflows.
 
 **Tags:** Math
 
diff --git a/note/010/README.md b/note/010/README.md
index 08e6674d..ee921625 100644
--- a/note/010/README.md
+++ b/note/010/README.md
@@ -29,11 +29,16 @@ isMatch("aab", "c*a*b") → true
 ## 思路0
 
 题意是让让你从判断`s`字符串是否正则匹配于`p`，这道题和[Wildcard Matching][044]很是相似，区别在于`*`，通配符的`*`是可以随意出现的，跟前面字符没有任何关系，其作用是可以表示任意字符串；而正则匹配的`*`不能单独存在，前面必须具有一个字符，其意义是表明前面的这个字符个数可以是任意个数，包括0个。首先我们用递归的方式来实现，其思路如下：
-* 如果`s`和`p`都为空，那么返回`true`
-* 如果`p`的长度为1，当`s`的长度也为1，并且他们首位匹配则返回`true`，否则返回`false`
-* 如果`p`的第二个字符不为'*'，如果`s`为空，那就返回`false`，首位匹配则返回递归调用他们去掉首位的子字符串，否则返回`false`
-* 如果`p`的第二个字符为'*'，循环当`s`不为空，且首位匹配，如果递归调用是否匹配`s`字符串和`p`去掉前两位的子字符串，则返回`true`，否则`s`去掉首字母继续循环
-* 返回递归调用`s`字符串和`p`去掉前两位的子字符串是否匹配
+
+* 如果`s`和`p`都为空，那么返回`true`；
+
+* 如果`p`的长度为1，当`s`的长度也为1，并且他们首位匹配则返回`true`，否则返回`false`；
+
+* 如果`p`的第二个字符不为 '*'，如果`s`为空，那就返回`false`，首位匹配则返回递归调用他们去掉首位的子字符串，否则返回`false`；
+
+* 如果`p`的第二个字符为 '*'，循环当`s`不为空，且首位匹配，如果递归调用是否匹配`s`字符串和`p`去掉前两位的子字符串，则返回`true`，否则`s`去掉首字母继续循环；
+
+* 返回递归调用`s`字符串和`p`去掉前两位的子字符串是否匹配。
 
 ```java
 class Solution {
@@ -61,10 +66,13 @@ class Solution {
 
 ## 思路1
 
-我们可以把上面的思路更简单化，如下
-* 如果`s`和`p`都为空，那么返回`true`
-* 如果`p`的第二个字符为`*`，由于`*`前面的字符个数可以为任意，那么我们先递归调用个数为0的情况；或者当`s`不为空，如果他们的首字母匹配，那么我们就递归调用去掉去掉首字母的`s`和完整的`p`
-* 如果`p`的第二个字符不为`*`，那么我们就老老实实判断第一个字符是否匹配并且递归调用他们去掉首位的子字符串
+我们可以把上面的思路更简单化，如下：
+
+* 如果`s`和`p`都为空，那么返回`true`；
+
+* 如果`p`的第二个字符为`*`，由于`*`前面的字符个数可以为任意，那么我们先递归调用个数为0的情况；或者当`s`不为空，如果他们的首字母匹配，那么我们就递归调用去掉去掉首字母的`s`和完整的`p`；
+
+* 如果`p`的第二个字符不为`*`，那么我们就老老实实判断第一个字符是否匹配并且递归调用他们去掉首位的子字符串。
 
 ```java
 class Solution {
@@ -84,10 +92,10 @@ class Solution {
 ## 思路2
 
 另一种思路就是动态规划了，我们定义`dp[i][j]`的真假来表示`s[0..i)`是否匹配`p[0..j)`，通过思路1，我们可以确定其状态转移方程如下所示：
-* 如果`p[j - 1] == '*'`, `dp[i][j] = dp[i][j - 2] || (pc[j - 2] == sc[i - 1] || pc[j - 2] == '.') && dp[i - 1][j];`
-* 如果`p[j - 1] != '*'`，`dp[i][j] = dp[i - 1][j - 1] && (pc[j - 1] == '.' || pc[j - 1] == sc[i - 1]);`
 
+* 如果`p[j - 1] == '*'`, `dp[i][j] = dp[i][j - 2] || (pc[j - 2] == sc[i - 1] || pc[j - 2] == '.') && dp[i - 1][j];`；
 
+* 如果`p[j - 1] != '*'`，`dp[i][j] = dp[i - 1][j - 1] && (pc[j - 1] == '.' || pc[j - 1] == sc[i - 1]);`。
 
 ```java
 class Solution {
diff --git a/note/013/README.md b/note/013/README.md
index 557ba029..a94a6a02 100644
--- a/note/013/README.md
+++ b/note/013/README.md
@@ -11,11 +11,13 @@ Input is guaranteed to be within the range from 1 to 3999.
 
 ## 思路
 
-题意是罗马数字转整型数，范围从1到3999，查看下百度百科的罗马数字介绍如下，
+题意是罗马数字转整型数，范围从1到3999，查看下百度百科的罗马数字介绍如下：
 
 * 相同的数字连写，所表示的数等于这些数字相加得到的数，如 Ⅲ=3；
+
 * 小的数字在大的数字的右边，所表示的数等于这些数字相加得到的数，如 Ⅷ=8、Ⅻ=12；
-* 小的数字（限于 Ⅰ、X 和 C）在大的数字的左边，所表示的数等于大数减小数得到的数，如 Ⅳ=4、Ⅸ=9；
+
+* 小的数字（限于 Ⅰ、X 和 C）在大的数字的左边，所表示的数等于大数减小数得到的数，如 Ⅳ=4、Ⅸ=9。
 
 那么我们可以利用map来完成罗马数字的7个数字符号：I、V、X、L、C、D、M和整数的映射关系，然后根据上面的解释来模拟完成即可。
 
diff --git a/note/017/README.md b/note/017/README.md
index 2ebe22f0..85616a28 100644
--- a/note/017/README.md
+++ b/note/017/README.md
@@ -14,6 +14,7 @@ Output: ["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].
 ```
 
 **Note:**
+
 Although the above answer is in lexicographical order, your answer could be in any order you want.
 
 **Tags:** String, Backtracking
diff --git a/note/021/README.md b/note/021/README.md
index 3c11f380..026e51cc 100644
--- a/note/021/README.md
+++ b/note/021/README.md
@@ -4,6 +4,13 @@
 
 Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists.
 
+**Example:**
+
+```
+Input: 1->2->4, 1->3->4
+Output: 1->1->2->3->4->4
+```
+
 **Tags:** Linked List
 
 
diff --git a/note/023/README.md b/note/023/README.md
index 30bab15f..430ea738 100644
--- a/note/023/README.md
+++ b/note/023/README.md
@@ -2,7 +2,7 @@
 
 ## Description
 
-Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.
+Merge *k* sorted linked lists and return it as one sorted list. Analyze and describe its complexity.
 
 **Tags:** Linked List, Divide and Conquer, Heap
 
diff --git a/note/025/README.md b/note/025/README.md
index 39d78ee9..10f67ee5 100644
--- a/note/025/README.md
+++ b/note/025/README.md
@@ -1,4 +1,4 @@
-# [Merge k Sorted Lists][title]
+# [Reverse Nodes in k-Group][title]
 
 ## Description
 
@@ -11,6 +11,7 @@ You may not alter the values in the nodes, only nodes itself may be changed.
 Only constant memory is allowed.
 
 For example,
+
 Given this linked list: `1->2->3->4->5`
 
 For *k* = 2, you should return: `2->1->4->3->5`
@@ -23,12 +24,15 @@ For *k* = 3, you should return: `3->2->1->4->5`
 ## 思路
 
 题意是让你以`k`个元素为一组来翻转链表，最后不足`k`个的话不需要翻转，最传统的思路就是每遇到`k`个元素，对其`k`个元素进行翻转，而难点就是在此，下面介绍其原理，我们以例子中的`k = 3`为例，其`pre`和`next`如下所示。
+
 ```
 0->1->2->3->4->5
 |           |
 pre        next
 ```
+
 我们要做的就是把`pre`和`next`之间的元素逆序，思想是依次从第二个元素到第`k`个元素，依次把它插入到`pre`后面，过程如下。
+
 ```
  head move
    |  |
@@ -48,8 +52,8 @@ pre        next
 |           |
 pre        next
 ```
-好了，根据原理，那写出代码就不难了。
 
+好了，根据原理，那写出代码就不难了。
 
 ```java
 /**
@@ -97,5 +101,5 @@ class Solution {
 
 
 
-[title]: https://leetcode.com/problems/merge-k-sorted-lists
+[title]: https://leetcode.com/problems/reverse-nodes-in-k-group
 [ajl]: https://github.com/Blankj/awesome-java-leetcode
diff --git a/note/026/README.md b/note/026/README.md
index ca163f6c..89ee9639 100644
--- a/note/026/README.md
+++ b/note/026/README.md
@@ -2,14 +2,18 @@
 
 ## Description
 
-Given a sorted array, remove the duplicates in place such that each element appear only *once* and return the new length.
+Given a sorted array, remove the duplicates [**in-place**](https://en.wikipedia.org/wiki/In-place_algorithm) such that each element appear only *once* and return the new length.
 
-Do not allocate extra space for another array, you must do this in place with constant memory.
+Do not allocate extra space for another array, you must do this by **modifying the input array in-place** with O(1) extra memory.
 
-For example,
-Given input array *nums* = `[1,1,2]`,
+**Example:**
 
-Your function should return length = `2`, with the first two elements of *nums* being `1` and `2` respectively. It doesn't matter what you leave beyond the new length.
+```
+Given nums = [1,1,2],
+
+Your function should return length = 2, with the first two elements of nums being 1 and 2 respectively.
+It doesn't matter what you leave beyond the new length.
+```
 
 **Tags:** Array, Two Pointers
 
diff --git a/note/027/README.md b/note/027/README.md
index 4d3d89a5..2e99431e 100644
--- a/note/027/README.md
+++ b/note/027/README.md
@@ -2,17 +2,19 @@
 
 ## Description
 
-Given an array and a value, remove all instances of that value in place and return the new length.
+Given an array and a value, remove all instances of that value [**in-place**](https://en.wikipedia.org/wiki/In-place_algorithm) and return the new length.
 
-Do not allocate extra space for another array, you must do this in place with constant memory.
+Do not allocate extra space for another array, you must do this by **modifying the input array [in-place](https://en.wikipedia.org/wiki/In-place_algorithm)** with O(1) extra memory.
 
 The order of elements can be changed. It doesn't matter what you leave beyond the new length.
 
 **Example:**
 
-Given input array *nums* = `[3,2,2,3]`, *val* = `3`
+```
+Given nums = [3,2,2,3], val = 3,
 
-Your function should return length = 2, with the first two elements of *nums* being 2.
+Your function should return length = 2, with the first two elements of nums being 2.
+```
 
 **Tags:** Array, Two Pointers
 
diff --git a/note/028/README.md b/note/028/README.md
index 6f681933..135a8d76 100644
--- a/note/028/README.md
+++ b/note/028/README.md
@@ -2,11 +2,25 @@
 
 ## Description
 
-Implement strStr().
+Implement [strStr()](http://www.cplusplus.com/reference/cstring/strstr/).
 
-Returns the index of the first occurrence of needle in haystack, or -1 if needle is not part of haystack.
+Return the index of the first occurrence of needle in haystack, or **-1** if needle is not part of haystack.
 
-**Tags:** Two Pointers, String
+**Example 1:**
+
+```
+Input: haystack = "hello", needle = "ll"
+Output: 2
+```
+
+**Example 2:**
+
+```
+Input: haystack = "aaaaa", needle = "bba"
+Output: -1
+```
+
+Tags:** Two Pointers, String
 
 
 ## 思路
diff --git a/note/033/README.md b/note/033/README.md
index 937b00c7..4dc2fe08 100644
--- a/note/033/README.md
+++ b/note/033/README.md
@@ -16,6 +16,7 @@ You may assume no duplicate exists in the array.
 ## 思路
 
 题意是让你从一个旋转过后的递增序列中寻找给定值，找到返回索引，找不到返回-1，我们在下面这组数据中寻找规律。
+
 ```
 1 2 4 5 6 7 0
 2 4 5 6 7 0 1
@@ -24,6 +25,7 @@ You may assume no duplicate exists in the array.
 6 7 0 1 2 4 5
 7 0 1 2 4 5 6
 ```
+
 由于是旋转一次，所以肯定有一半及以上的序列仍然是具有递增性质的，我们观察到如果中间的数比左面的数大的话，那么左半部分序列是递增的，否则右半部分就是递增的，那么我们就可以确定给定值是否在递增序列中，从而决定取舍哪半边。
 
 
diff --git a/note/035/README.md b/note/035/README.md
index d259b583..1cf69aa9 100644
--- a/note/035/README.md
+++ b/note/035/README.md
@@ -6,12 +6,33 @@ Given a sorted array and a target value, return the index if the target is found
 
 You may assume no duplicates in the array.
 
-Here are few examples.
+**Example 1:**
 
-`[1,3,5,6]`, 5 → 2
-`[1,3,5,6]`, 2 → 1
-`[1,3,5,6]`, 7 → 4
-`[1,3,5,6]`, 0 → 0
+```
+Input: [1,3,5,6], 5
+Output: 2
+```
+
+**Example 2:**
+
+```
+Input: [1,3,5,6], 2
+Output: 1
+```
+
+**Example 3:**
+
+```
+Input: [1,3,5,6], 7
+Output: 4
+```
+
+**Example 1:**
+
+```
+Input: [1,3,5,6], 0
+Output: 0
+```
 
 **Tags:** Array, Binary Search
 
diff --git a/note/038/README.md b/note/038/README.md
index 04766156..e463a849 100644
--- a/note/038/README.md
+++ b/note/038/README.md
@@ -10,14 +10,15 @@ The count-and-say sequence is the sequence of integers with the first five terms
 3.     21
 4.     1211
 5.     111221
-
 ```
 
 `1` is read off as `"one 1"` or `11`.
+
 `11` is read off as `"two 1s"` or `21`.
+
 `21` is read off as `"one 2`, then `one 1"` or `1211`.
 
-Given an integer *n*, generate the *n*th term of the count-and-say sequence.
+Given an integer *n*, generate the *n*<sup>th</sup> term of the count-and-say sequence.
 
 Note: Each term of the sequence of integers will be represented as a string.
 
@@ -26,7 +27,6 @@ Note: Each term of the sequence of integers will be represented as a string.
 ```
 Input: 1
 Output: "1"
-
 ```
 
 **Example 2:**
diff --git a/note/043/README.md b/note/043/README.md
index 1ec3ae74..4719e1f0 100644
--- a/note/043/README.md
+++ b/note/043/README.md
@@ -7,8 +7,11 @@ Given two non-negative integers `num1` and `num2` represented as strings, return
 **Note:**
 
 1. The length of both `num1` and `num2` is < 110.
+
 2. Both `num1` and `num2` contains only digits `0-9`.
+
 3. Both `num1` and `num2` does not contain any leading zero.
+
 4. You **must not use any built-in BigInteger library** or **convert the inputs to integer** directly.
 
 **Tags:** Math, String
diff --git a/note/044/README.md b/note/044/README.md
index 59291b91..d0a42fca 100644
--- a/note/044/README.md
+++ b/note/044/README.md
@@ -59,7 +59,9 @@ class Solution {
 ## 思路1
 
 另一种思路就是动态规划了，我们定义`dp[i][j]`的真假来表示`s[0..i)`是否匹配`p[0..j)`，其状态转移方程如下所示：
+
 * 如果`p[j - 1] != '*'`，`P[i][j] = P[i - 1][j - 1] && (s[i - 1] == p[j - 1] || p[j - 1] == '?');`
+
 * 如果`p[j - 1] == '*'`，`P[i][j] = P[i][j - 1] || P[i - 1][j]`
 
 ```java
diff --git a/note/049/README.md b/note/049/README.md
index 6930def9..122d3fb1 100644
--- a/note/049/README.md
+++ b/note/049/README.md
@@ -4,7 +4,8 @@
 
 Given an array of strings, group anagrams together.
 
-For example, given: `["eat", "tea", "tan", "ate", "nat", "bat"]`, 
+For example, given: `["eat", "tea", "tan", "ate", "nat", "bat"]`,
+
 Return:
 
 ```
diff --git a/note/050/README.md b/note/050/README.md
index c8b3a99e..5e4fd278 100644
--- a/note/050/README.md
+++ b/note/050/README.md
@@ -2,7 +2,21 @@
 
 ## Description
 
-Implement pow(x, n).
+Implement [pow(*x*, *n*)](http://www.cplusplus.com/reference/valarray/pow/).
+
+**Example 1:**
+
+```
+Input: 2.00000, 10
+Output: 1024.00000
+```
+
+**Example 2:**
+
+```
+Input: 2.10000, 3
+Output: 9.26100
+```
 
 **Tags:** Math, Binary Search
 
diff --git a/note/053/README.md b/note/053/README.md
index 53a57465..6f0d0fb5 100644
--- a/note/053/README.md
+++ b/note/053/README.md
@@ -5,13 +5,14 @@
 Find the contiguous subarray within an array (containing at least one number) which has the largest sum.
 
 For example, given the array `[-2,1,-3,4,-1,2,1,-5,4]`,
+
 the contiguous subarray `[4,-1,2,1]` has the largest sum = `6`.
 
 **More practice:**
 
 If you have figured out the O(*n*) solution, try coding another solution using the divide and conquer approach, which is more subtle.
 
-**Tags:** Array, Dynamic Programming, Divide and Conquer
+**Tags:** Array, Divide and Conquer, Dynamic Programming
 
 
 ## 思路0
diff --git a/note/056/README.md b/note/056/README.md
index ec9009d9..25831ec8 100644
--- a/note/056/README.md
+++ b/note/056/README.md
@@ -5,7 +5,9 @@
 Given a collection of intervals, merge all overlapping intervals.
 
 For example,
+
 Given `[1,3],[2,6],[8,10],[15,18]`,
+
 return `[1,6],[8,10],[15,18]`.
 
 **Tags:** Array, Sort
diff --git a/note/057/README.md b/note/057/README.md
index 91767640..04e544be 100644
--- a/note/057/README.md
+++ b/note/057/README.md
@@ -7,9 +7,11 @@ Given a set of *non-overlapping* intervals, insert a new interval into the inter
 You may assume that the intervals were initially sorted according to their start times.
 
 **Example 1:**
+
 Given intervals `[1,3],[6,9]`, insert and merge `[2,5]` in as `[1,5],[6,9]`.
 
 **Example 2:**
+
 Given `[1,2],[3,5],[6,7],[8,10],[12,16]`, insert and merge `[4,9]` in as `[1,2],[3,10],[12,16]`.
 
 This is because the new interval `[4,9]` overlaps with `[3,5],[6,7],[8,10]`.
@@ -20,8 +22,11 @@ This is because the new interval `[4,9]` overlaps with `[3,5],[6,7],[8,10]`.
 ## 思路
 
 题意是给你一组有序区间，和一个待插入区间，让你待插入区间插入到前面的区间中，我们分三步走：
+
 1. 首先把有序区间中小于待插入区间的部分加入到结果中；
+
 2. 其次是插入待插入区间，如果有交集的话取两者交集的端点值；
+
 3. 最后把有序区间中大于待插入区间的部分加入到结果中；
 
 ```java
diff --git a/note/058/README.md b/note/058/README.md
index a8925546..fe7dc06c 100644
--- a/note/058/README.md
+++ b/note/058/README.md
@@ -8,11 +8,12 @@ If the last word does not exist, return 0.
 
 **Note:** A word is defined as a character sequence consists of non-space characters only.
 
-For example,
+**Example:**
 
-Given *s* = `"Hello World"`,
-
-return `5`.
+```
+Input: "Hello World"
+Output: 5
+```
 
 **Tags:** String
 
diff --git a/note/067/README.md b/note/067/README.md
index 9cdf218b..ab84ac55 100644
--- a/note/067/README.md
+++ b/note/067/README.md
@@ -5,8 +5,11 @@
 Given two binary strings, return their sum (also a binary string).
 
 For example,
+
 a = `"11"`
+
 b = `"1"`
+
 Return `"100"`.
 
 **Tags:** Math, String
diff --git a/note/068/README.md b/note/068/README.md
index 32f2f432..f6a7000d 100644
--- a/note/068/README.md
+++ b/note/068/README.md
@@ -11,7 +11,9 @@ Extra spaces between words should be distributed as evenly as possible. If the n
 For the last line of text, it should be left justified and no extra space is inserted between words.
 
 For example,
+
 **words**: `["This", "is", "an", "example", "of", "text", "justification."]`
+
 **L**: `16`.
 
 Return the formatted lines as:
@@ -30,6 +32,7 @@ Return the formatted lines as:
 **Corner Cases:**
 
 - A line other than the last line might contain only one word. What should you do in this case?
+
   In this case, that line should be left-justified.
 
 **Tags:** String
diff --git a/note/069/README.md b/note/069/README.md
index 4525d2a4..2479c73f 100644
--- a/note/069/README.md
+++ b/note/069/README.md
@@ -4,7 +4,24 @@
 
 Implement `int sqrt(int x)`.
 
-Compute and return the square root of x.
+Compute and return the square root of *x*.
+
+**x** is guaranteed to be a non-negative integer.
+
+**Example 1:**
+
+```
+Input: 4
+Output: 2
+```
+
+**Example 2:**
+
+```
+Input: 8
+Output: 2
+Explanation: The square root of 8 is 2.82842..., and since we want to return an integer, the decimal part will be truncated.
+```
 
 **Tags:** Binary Search, Math
 
diff --git a/note/070/README.md b/note/070/README.md
index d1b98fe4..05e6ce0b 100644
--- a/note/070/README.md
+++ b/note/070/README.md
@@ -8,6 +8,29 @@ Each time you can either climb 1 or 2 steps. In how many distinct ways can you c
 
 **Note:** Given *n* will be a positive integer.
 
+**Example 1:**
+
+```
+Input: 2
+Output:  2
+Explanation:  There are two ways to climb to the top.
+
+1. 1 step + 1 step
+2. 2 steps
+```
+
+**Example 2:**
+
+```
+Input: 3
+Output:  3
+Explanation:  There are three ways to climb to the top.
+
+1. 1 step + 1 step + 1 step
+2. 1 step + 2 steps
+3. 2 steps + 1 step
+```
+
 **Tags:** Dynamic Programming
 
 
diff --git a/note/083/README.md b/note/083/README.md
index e581ec26..c77aaff0 100644
--- a/note/083/README.md
+++ b/note/083/README.md
@@ -5,7 +5,9 @@
 Given a sorted linked list, delete all duplicates such that each element appear only *once*.
 
 For example,
+
 Given `1->1->2`, return `1->2`.
+
 Given `1->1->2->3->3`, return `1->2->3`.
 
 **Tags:** Linked List
diff --git a/note/088/README.md b/note/088/README.md
index b4cf4532..07d48f85 100644
--- a/note/088/README.md
+++ b/note/088/README.md
@@ -5,6 +5,7 @@
 Given two sorted integer arrays *nums1* and *nums2*, merge *nums2* into *nums1* as one sorted array.
 
 **Note:**
+
 You may assume that *nums1* has enough space (size that is greater or equal to *m* + *n*) to hold additional elements from *nums2*. The number of elements initialized in *nums1* and *nums2* are *m* and *n* respectively.
 
 **Tags:** Array, Two Pointers
diff --git a/note/100/README.md b/note/100/README.md
index a06660f0..f862282d 100644
--- a/note/100/README.md
+++ b/note/100/README.md
@@ -2,9 +2,45 @@
 
 ## Description
 
-Given two binary trees, write a function to check if they are equal or not.
+Given two binary trees, write a function to check if they are the same or not.
 
-Two binary trees are considered equal if they are structurally identical and the nodes have the same value.
+Two binary trees are considered the same if they are structurally identical and the nodes have the same value.
+
+**Example 1:**
+
+```
+Input:     1         1
+          / \       / \
+         2   3     2   3
+
+        [1,2,3],   [1,2,3]
+
+Output: true
+```
+
+**Example 2:**
+
+```
+Input:     1         1
+          /           \
+         2             2
+
+        [1,2],     [1,null,2]
+
+Output: false
+```
+
+**Example 3:**
+
+```
+Input:     1         1
+          / \       / \
+         2   1     1   2
+
+        [1,2,1],   [1,1,2]
+
+Output: false
+```
 
 **Tags:** Tree, Depth-first Search
 
diff --git a/note/101/README.md b/note/101/README.md
index 1f83fd85..4edf8bdc 100644
--- a/note/101/README.md
+++ b/note/101/README.md
@@ -12,7 +12,6 @@ For example, this binary tree `[1,2,2,3,4,4,3]` is symmetric:
   2   2
  / \ / \
 3  4 4  3
-
 ```
 
 But the following `[1,2,2,null,3,null,3]` is not:
@@ -23,10 +22,10 @@ But the following `[1,2,2,null,3,null,3]` is not:
   2   2
    \   \
    3    3
-
 ```
 
 **Note:**
+
 Bonus points if you could solve it both recursively and iteratively.
 
 **Tags:** Tree, Depth-first Search, Breadth-first Search
@@ -96,6 +95,7 @@ class Solution {
 }
 ```
 
+
 ## 结语
 
 如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
diff --git a/note/107/README.md b/note/107/README.md
index 7d220cc9..84024387 100644
--- a/note/107/README.md
+++ b/note/107/README.md
@@ -5,6 +5,7 @@
 Given a binary tree, return the *bottom-up level order* traversal of its nodes' values. (ie, from left to right, level by level from leaf to root).
 
 For example:
+
 Given binary tree `[3,9,20,null,null,15,7]`,
 
 ```
@@ -32,7 +33,6 @@ return its bottom-up level order traversal as:
 
 题意是从下往上按层遍历二叉树，每一层是从左到右，按层遍历，很明显，宽搜第一时间符合，因为是从下往上，所以插入的时候每次插到链表头即可。
 
-
 ```java
 /**
  * Definition for a binary tree node.
diff --git a/note/108/README.md b/note/108/README.md
index 95b1be29..6d2866d1 100644
--- a/note/108/README.md
+++ b/note/108/README.md
@@ -4,6 +4,22 @@
 
 Given an array where elements are sorted in ascending order, convert it to a height balanced BST.
 
+For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of *every* node never differ by more than 1.
+
+**Example:**
+
+```
+Given the sorted array: [-10,-3,0,5,9],
+
+One possible answer is: [0,-3,9,-10,null,5], which represents the following height balanced BST:
+
+      0
+     / \
+   -3   9
+   /   /
+ -10  5
+```
+
 **Tags:** Tree, Depth-first Search
 
 
@@ -12,8 +28,11 @@ Given an array where elements are sorted in ascending order, convert it to a hei
 题意是把一个有序数组转化为一棵二叉搜索树，二叉搜索树具有以下性质：
 
 1. 若任意节点的左子树不空，则左子树上所有节点的值均小于它的根节点的值；
+
 2. 若任意节点的右子树不空，则右子树上所有节点的值均大于它的根节点的值；
+
 3. 任意节点的左、右子树也分别为二叉查找树；
+
 4. 没有键值相等的节点。
 
 所以我们可以用递归来构建一棵二叉搜索树，每次把数组分为两半，把数组中间的值作为其父节点，然后把数组的左右两部分继续构造其左右子树。
diff --git a/note/110/README.md b/note/110/README.md
index 773aff0c..3a5c1781 100644
--- a/note/110/README.md
+++ b/note/110/README.md
@@ -13,7 +13,6 @@ For this problem, a height-balanced binary tree is defined as a binary tree in w
 
 题意是判断一棵二叉树是否是高度平衡的，所谓二叉树高度平衡指的是二叉树的每个节点的两棵子树的高度差都不超过1，那么我们只需计算左右子树的高度，判断其高度差是否不超过1即可，如果超过1，就代表其不是高度平衡的，立即返回不是即可，我这里用返回`-1`代表不是。
 
-
 ```java
 /**
  * Definition for a binary tree node.
diff --git a/note/111/README.md b/note/111/README.md
index e816e619..3add8b8d 100644
--- a/note/111/README.md
+++ b/note/111/README.md
@@ -13,7 +13,6 @@ The minimum depth is the number of nodes along the shortest path from the root n
 
 题意是查找二叉树的最小深度，也就是找到从根结点到叶子节点的最小深度，最容易想到的当然是深搜，如果节点的左右深度都不是0的话，说明该节点含有左右子树，所以它的最小高度就是1加上其左右子树高度较小者，否则如果左子树为空或者右子树为空或者两者都为空，那么就是1加上非空子树高度。
 
-
 ```java
 /**
  * Definition for a binary tree node.
@@ -79,5 +78,5 @@ class Solution {
 
 
 
-[title]: https://leetcode.com/problems/balanced-binary-tree
+[title]: https://leetcode.com/problems/minimum-depth-of-binary-tree
 [ajl]: https://github.com/Blankj/awesome-java-leetcode
diff --git a/note/112/README.md b/note/112/README.md
index 9483d7df..f1c6afeb 100644
--- a/note/112/README.md
+++ b/note/112/README.md
@@ -16,7 +16,6 @@ Given the below binary tree and `sum = 22`,
           11  13  4
          /  \      \
         7    2      1
-
 ```
 
 return true, as there exist a root-to-leaf path `5->4->11->2` which sum is 22.
diff --git a/note/118/README.md b/note/118/README.md
index f0fac05c..7e4e37f5 100644
--- a/note/118/README.md
+++ b/note/118/README.md
@@ -5,6 +5,7 @@
 Given *numRows*, generate the first *numRows* of Pascal's triangle.
 
 For example, given *numRows* = 5,
+
 Return
 
 ```
diff --git a/note/119/README.md b/note/119/README.md
index cc754b06..d8f4701b 100644
--- a/note/119/README.md
+++ b/note/119/README.md
@@ -5,9 +5,11 @@
 Given an index *k*, return the *k*<sup>th</sup> row of the Pascal's triangle.
 
 For example, given *k* = 3,
+
 Return `[1,3,3,1]`.
 
 **Note:**
+
 Could you optimize your algorithm to use only *O*(*k*) extra space?
 
 **Tags:** Array
diff --git a/note/121/README.md b/note/121/README.md
index 8ed719d4..d7d151a0 100644
--- a/note/121/README.md
+++ b/note/121/README.md
@@ -13,7 +13,6 @@ Input: [7, 1, 5, 3, 6, 4]
 Output: 5
 
 max. difference = 6-1 = 5 (not 7-1 = 6, as selling price needs to be larger than buying price)
-
 ```
 
 **Example 2:**
diff --git a/note/543/README.md b/note/543/README.md
index 551dbca2..e1ed43ae 100644
--- a/note/543/README.md
+++ b/note/543/README.md
@@ -5,6 +5,7 @@
 Given a binary tree, you need to compute the length of the diameter of the tree. The diameter of a binary tree is the length of the **longest** path between any two nodes in a tree. This path may or may not pass through the root.
 
 **Example:**
+
 Given a binary tree
 
 ```
diff --git a/note/554/README.md b/note/554/README.md
index a99b35ae..16e36860 100644
--- a/note/554/README.md
+++ b/note/554/README.md
@@ -29,6 +29,7 @@ Explanation:
 **Note:**
 
 1. The width sum of bricks in different rows are the same and won't exceed INT_MAX.
+
 2. The number of bricks in each row is in range [1,10,000]. The height of wall is in range [1,10,000]. Total number of bricks of the wall won't exceed 20,000.
 
 **Tags:** Hash Table

From 722d8595fa35a8e3c2bb9e8e752d3220458d8ce7 Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Sat, 9 Dec 2017 11:33:06 +0800
Subject: [PATCH 14/58] fix: fix the format

---
 note/001/README.md | 2 +-
 note/002/README.md | 2 +-
 note/003/README.md | 2 +-
 note/004/README.md | 6 ++++--
 note/005/README.md | 2 +-
 note/007/README.md | 2 +-
 note/008/README.md | 2 +-
 note/009/README.md | 2 +-
 note/010/README.md | 2 +-
 note/013/README.md | 2 +-
 note/014/README.md | 2 +-
 note/015/README.md | 2 +-
 note/017/README.md | 2 +-
 note/019/README.md | 2 +-
 note/020/README.md | 2 +-
 note/021/README.md | 2 +-
 note/023/README.md | 2 +-
 note/025/README.md | 2 +-
 note/026/README.md | 2 +-
 note/027/README.md | 2 +-
 note/028/README.md | 2 +-
 note/033/README.md | 2 +-
 note/035/README.md | 2 +-
 note/038/README.md | 2 +-
 note/043/README.md | 2 +-
 note/044/README.md | 2 +-
 note/049/README.md | 2 +-
 note/050/README.md | 2 +-
 note/053/README.md | 2 +-
 note/056/README.md | 2 +-
 note/057/README.md | 2 +-
 note/058/README.md | 2 +-
 note/066/README.md | 2 +-
 note/067/README.md | 2 +-
 note/068/README.md | 2 +-
 note/069/README.md | 2 +-
 note/070/README.md | 2 +-
 note/083/README.md | 2 +-
 note/088/README.md | 2 +-
 note/100/README.md | 2 +-
 note/101/README.md | 2 +-
 note/104/README.md | 2 +-
 note/107/README.md | 2 +-
 note/108/README.md | 2 +-
 note/110/README.md | 2 +-
 note/111/README.md | 2 +-
 note/112/README.md | 2 +-
 note/118/README.md | 2 +-
 note/119/README.md | 2 +-
 note/121/README.md | 2 +-
 note/122/README.md | 2 +-
 note/543/README.md | 2 +-
 note/554/README.md | 2 +-
 53 files changed, 56 insertions(+), 54 deletions(-)

diff --git a/note/001/README.md b/note/001/README.md
index 5a4e5866..efb3b86b 100644
--- a/note/001/README.md
+++ b/note/001/README.md
@@ -60,7 +60,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/002/README.md b/note/002/README.md
index 3c9a9a74..5d2a804d 100644
--- a/note/002/README.md
+++ b/note/002/README.md
@@ -57,7 +57,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/003/README.md b/note/003/README.md
index 5baaba74..d01605d9 100644
--- a/note/003/README.md
+++ b/note/003/README.md
@@ -43,7 +43,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/004/README.md b/note/004/README.md
index f0871db4..15b22518 100644
--- a/note/004/README.md
+++ b/note/004/README.md
@@ -29,7 +29,9 @@ The median is (2 + 3)/2 = 2.5
 
 ## 思路
 
-题意是给你两个已排序的递增数组，让你找出其中位数，乍一看这题并不是很难，其实这题难度不可小觑，要做出时间复杂度为O(log (m+n))的话需要了解从两个递增数组中找出第k大的元素，也就是我写的`helper`函数所起到的作用。下面来解释以下其原理：假设数组分别记为A，B，当前需要搜索第k大的数，于是我们可以考虑从数组A中取出前m个元素，从数组B中取出k-m个元素。由于数组A，B分别排序，则A[m]大于从数组A中取出的其他所有元素，B[k-m] 大于数组B中取出的其他所有元素。此时，尽管取出元素之间的相对大小关系不确定，但A[m]与B[k-m]的较大者一定是这k个元素中最大的。那么，较小的那个元素一定不是第k大的，它至多是第k-1大的：因为它小于其他未被取出的所有元素，并且小于取出的k个元素中最大的那个。为叙述方便，假设A[m]是较小的那个元素。那么，我们可以进一步说，A[1], A[2]…A[m-1]也一定不是第k大的元素，因为它们小于A[m]，而A[m]至多是第k-1大的。因此，我们可以把较小元素所在数组中选出的所有元素统统排除，并且相应地减少k值。这样，我们就完成了一次范围缩小。特别地，我们可以选取m=k/2。而本题只是其一种情况而已，也就当总长为偶数时，找出其中间的两个数，相加除二即可；当总长为奇数时，找到中间的数即可。
+题意是给你两个已排序的递增数组，让你找出其中位数，乍一看这题并不是很难，其实这题难度不可小觑，要做出时间复杂度为 `O(log(m+n))` 的话需要了解从两个递增数组中找出第 `k` 大的元素，也就是我写的 `helper` 函数所起到的作用。下面来解释其原理：
+
+假设数组分别记为 `A`，`B`，当前需要搜索第 `k` 大的数，于是我们可以考虑从数组 `A` 中取出前 `m` 个元素，从数组 `B` 中取出 `k - m` 个元素。由于数组 `A`，`B` 分别排序，则 `A[m]` 大于从数组 `A` 中取出的其他所有元素，`B[k - m]` 大于数组 `B` 中取出的其他所有元素。此时，尽管取出元素之间的相对大小关系不确定，但 `A[m]` 与 `B[k - m]` 的较大者一定是这 `k` 个元素中最大的。那么，较小的那个元素一定不是第 `k` 大的，它至多是第 `k - 1` 大的：因为它小于其他未被取出的所有元素，并且小于取出的 `k` 个元素中最大的那个。为叙述方便，假设 `A[m]` 是较小的那个元素。那么，我们可以进一步说，`A[1]`，`A[2]`...`A[m-1]` 也一定不是第 `k` 大的元素，因为它们小于 `A[m]`，而 `A[m]` 至多是第 `k - 1` 大的。因此，我们可以把较小元素所在数组中选出的所有元素统统排除，并且相应地减少 `k` 值。这样，我们就完成了一次范围缩小。特别地，我们可以选取 `m = k / 2`。而本题只是其一种情况而已，也就当总长为偶数时，找出其中间的两个数，相加除二即可；当总长为奇数时，找到中间的数即可。
 
 ```java
 class Solution {
@@ -61,7 +63,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/005/README.md b/note/005/README.md
index 03c2e1d0..29f9321a 100644
--- a/note/005/README.md
+++ b/note/005/README.md
@@ -154,7 +154,7 @@ lool -> #l#o#o#l#
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/007/README.md b/note/007/README.md
index bc73dfca..4312bd67 100644
--- a/note/007/README.md
+++ b/note/007/README.md
@@ -50,7 +50,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/008/README.md b/note/008/README.md
index d0565433..061e9c9d 100644
--- a/note/008/README.md
+++ b/note/008/README.md
@@ -52,7 +52,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/009/README.md b/note/009/README.md
index 0dd1d5a1..dc80e2a4 100644
--- a/note/009/README.md
+++ b/note/009/README.md
@@ -56,7 +56,7 @@ public boolean isPalindrome(int x) {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/010/README.md b/note/010/README.md
index ee921625..036597f9 100644
--- a/note/010/README.md
+++ b/note/010/README.md
@@ -127,7 +127,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/013/README.md b/note/013/README.md
index a94a6a02..8ff2a83c 100644
--- a/note/013/README.md
+++ b/note/013/README.md
@@ -49,7 +49,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/014/README.md b/note/014/README.md
index a6bd44ae..5ac1b5f5 100644
--- a/note/014/README.md
+++ b/note/014/README.md
@@ -30,7 +30,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/015/README.md b/note/015/README.md
index 70a6ca0c..bb622cf6 100644
--- a/note/015/README.md
+++ b/note/015/README.md
@@ -51,7 +51,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/017/README.md b/note/017/README.md
index 85616a28..97182e4c 100644
--- a/note/017/README.md
+++ b/note/017/README.md
@@ -77,7 +77,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/019/README.md b/note/019/README.md
index d62a4314..7471db68 100644
--- a/note/019/README.md
+++ b/note/019/README.md
@@ -58,7 +58,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/020/README.md b/note/020/README.md
index 431a6674..ac912ee1 100644
--- a/note/020/README.md
+++ b/note/020/README.md
@@ -37,7 +37,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/021/README.md b/note/021/README.md
index 026e51cc..90d77ed4 100644
--- a/note/021/README.md
+++ b/note/021/README.md
@@ -50,7 +50,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/023/README.md b/note/023/README.md
index 430ea738..67a2e54c 100644
--- a/note/023/README.md
+++ b/note/023/README.md
@@ -93,7 +93,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/025/README.md b/note/025/README.md
index 10f67ee5..13dd7180 100644
--- a/note/025/README.md
+++ b/note/025/README.md
@@ -97,7 +97,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/026/README.md b/note/026/README.md
index 89ee9639..bf955846 100644
--- a/note/026/README.md
+++ b/note/026/README.md
@@ -41,7 +41,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/027/README.md b/note/027/README.md
index 2e99431e..23a2d575 100644
--- a/note/027/README.md
+++ b/note/027/README.md
@@ -40,7 +40,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/028/README.md b/note/028/README.md
index 135a8d76..8cfa67bc 100644
--- a/note/028/README.md
+++ b/note/028/README.md
@@ -46,7 +46,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/033/README.md b/note/033/README.md
index 4dc2fe08..821640f7 100644
--- a/note/033/README.md
+++ b/note/033/README.md
@@ -52,7 +52,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/035/README.md b/note/035/README.md
index 1cf69aa9..66f39e6a 100644
--- a/note/035/README.md
+++ b/note/035/README.md
@@ -58,7 +58,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/038/README.md b/note/038/README.md
index e463a849..376ce4d1 100644
--- a/note/038/README.md
+++ b/note/038/README.md
@@ -70,7 +70,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/043/README.md b/note/043/README.md
index 4719e1f0..48b955f1 100644
--- a/note/043/README.md
+++ b/note/043/README.md
@@ -53,7 +53,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/044/README.md b/note/044/README.md
index d0a42fca..878f2760 100644
--- a/note/044/README.md
+++ b/note/044/README.md
@@ -92,7 +92,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/049/README.md b/note/049/README.md
index 122d3fb1..cc2ebbaa 100644
--- a/note/049/README.md
+++ b/note/049/README.md
@@ -53,7 +53,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/050/README.md b/note/050/README.md
index 5e4fd278..9dafa42e 100644
--- a/note/050/README.md
+++ b/note/050/README.md
@@ -45,7 +45,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/053/README.md b/note/053/README.md
index 6f0d0fb5..80f969d8 100644
--- a/note/053/README.md
+++ b/note/053/README.md
@@ -66,7 +66,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/056/README.md b/note/056/README.md
index 25831ec8..a89b8b1a 100644
--- a/note/056/README.md
+++ b/note/056/README.md
@@ -59,7 +59,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/057/README.md b/note/057/README.md
index 04e544be..fcf217cd 100644
--- a/note/057/README.md
+++ b/note/057/README.md
@@ -68,7 +68,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/058/README.md b/note/058/README.md
index fe7dc06c..1581fa6e 100644
--- a/note/058/README.md
+++ b/note/058/README.md
@@ -37,7 +37,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/066/README.md b/note/066/README.md
index 37a3377d..c8732c60 100644
--- a/note/066/README.md
+++ b/note/066/README.md
@@ -40,7 +40,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/067/README.md b/note/067/README.md
index ab84ac55..606304b6 100644
--- a/note/067/README.md
+++ b/note/067/README.md
@@ -51,7 +51,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/068/README.md b/note/068/README.md
index f6a7000d..8630ad34 100644
--- a/note/068/README.md
+++ b/note/068/README.md
@@ -90,7 +90,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/069/README.md b/note/069/README.md
index 2479c73f..09974689 100644
--- a/note/069/README.md
+++ b/note/069/README.md
@@ -45,7 +45,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/070/README.md b/note/070/README.md
index 05e6ce0b..bca0ecdb 100644
--- a/note/070/README.md
+++ b/note/070/README.md
@@ -54,7 +54,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/083/README.md b/note/083/README.md
index c77aaff0..305b3fa7 100644
--- a/note/083/README.md
+++ b/note/083/README.md
@@ -45,7 +45,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/088/README.md b/note/088/README.md
index 07d48f85..f4c8069a 100644
--- a/note/088/README.md
+++ b/note/088/README.md
@@ -30,7 +30,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/100/README.md b/note/100/README.md
index f862282d..341c01de 100644
--- a/note/100/README.md
+++ b/note/100/README.md
@@ -74,7 +74,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/101/README.md b/note/101/README.md
index 4edf8bdc..b0e9d9ac 100644
--- a/note/101/README.md
+++ b/note/101/README.md
@@ -98,7 +98,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/104/README.md b/note/104/README.md
index 960f325d..676c55cc 100644
--- a/note/104/README.md
+++ b/note/104/README.md
@@ -34,7 +34,7 @@ The maximum depth is the number of nodes along the longest path from the root no
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/107/README.md b/note/107/README.md
index 84024387..7e107b73 100644
--- a/note/107/README.md
+++ b/note/107/README.md
@@ -101,7 +101,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/108/README.md b/note/108/README.md
index 6d2866d1..115a8f02 100644
--- a/note/108/README.md
+++ b/note/108/README.md
@@ -68,7 +68,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/110/README.md b/note/110/README.md
index 3a5c1781..f2b26061 100644
--- a/note/110/README.md
+++ b/note/110/README.md
@@ -43,7 +43,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/111/README.md b/note/111/README.md
index 3add8b8d..ad219316 100644
--- a/note/111/README.md
+++ b/note/111/README.md
@@ -74,7 +74,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/112/README.md b/note/112/README.md
index f1c6afeb..abf1975c 100644
--- a/note/112/README.md
+++ b/note/112/README.md
@@ -50,7 +50,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/118/README.md b/note/118/README.md
index 7e4e37f5..dd1a60b6 100644
--- a/note/118/README.md
+++ b/note/118/README.md
@@ -50,7 +50,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/119/README.md b/note/119/README.md
index d8f4701b..7967f72c 100644
--- a/note/119/README.md
+++ b/note/119/README.md
@@ -37,7 +37,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/121/README.md b/note/121/README.md
index d7d151a0..648606f5 100644
--- a/note/121/README.md
+++ b/note/121/README.md
@@ -48,7 +48,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/122/README.md b/note/122/README.md
index ab4a45a2..b1c18ed6 100644
--- a/note/122/README.md
+++ b/note/122/README.md
@@ -28,7 +28,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/543/README.md b/note/543/README.md
index e1ed43ae..16e0c303 100644
--- a/note/543/README.md
+++ b/note/543/README.md
@@ -59,7 +59,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
diff --git a/note/554/README.md b/note/554/README.md
index 16e36860..2bfa6a4a 100644
--- a/note/554/README.md
+++ b/note/554/README.md
@@ -63,7 +63,7 @@ class Solution {
 
 ## 结语
 
-如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 

From 90f64bd16c5fd0b15720c57eadf884820e9c6e38 Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Sat, 9 Dec 2017 16:26:02 +0800
Subject: [PATCH 15/58] fix: fix the format

---
 README.md          |  2 +-
 note/001/README.md |  8 ++++----
 note/002/README.md |  2 +-
 note/003/README.md |  2 +-
 note/005/README.md | 12 ++++++------
 note/007/README.md |  2 +-
 note/008/README.md |  2 +-
 note/009/README.md |  6 +++---
 note/010/README.md | 30 +++++++++++++++---------------
 note/013/README.md |  4 ++--
 note/014/README.md |  2 +-
 note/015/README.md |  2 +-
 note/017/README.md |  4 ++--
 note/019/README.md |  2 +-
 note/020/README.md |  2 +-
 note/023/README.md |  8 ++++----
 note/025/README.md |  4 ++--
 note/026/README.md |  2 +-
 note/027/README.md |  2 +-
 note/035/README.md |  2 +-
 note/038/README.md |  2 +-
 note/044/README.md | 12 ++++++------
 note/050/README.md |  2 +-
 note/053/README.md |  8 ++++----
 note/056/README.md |  2 +-
 note/058/README.md |  2 +-
 note/066/README.md |  2 +-
 note/067/README.md |  2 +-
 note/068/README.md |  2 +-
 note/070/README.md |  2 +-
 note/088/README.md |  2 +-
 note/101/README.md |  6 +++---
 note/107/README.md |  4 ++--
 note/110/README.md |  2 +-
 note/111/README.md |  6 +++---
 35 files changed, 78 insertions(+), 78 deletions(-)

diff --git a/README.md b/README.md
index decbb6dd..389b8c0f 100644
--- a/README.md
+++ b/README.md
@@ -21,7 +21,7 @@
 > 美其名曰："practice makes perfect."  
 > 为何今不如古？  
 > 非也非也，  
-> 科举为国取士，LeetCode为Google筛码工，各取所需也。  
+> 科举为国取士，LeetCode 为 Google 筛码工，各取所需也。  
 
 
 ## Easy
diff --git a/note/001/README.md b/note/001/README.md
index efb3b86b..f0224222 100644
--- a/note/001/README.md
+++ b/note/001/README.md
@@ -18,9 +18,9 @@ return [0, 1].
 **Tags:** Array, Hash Table
 
 
-## 思路0
+## 思路 0
 
-题意是让你从给定的数组中找到两个元素的和为指定值的两个索引，最容易的当然是循环两次，复杂度为`O(n^2)`，首次提交居然是2ms，打败了100%的提交，谜一样的结果，之后再次提交就再也没跑到过2ms了。
+题意是让你从给定的数组中找到两个元素的和为指定值的两个索引，最容易的当然是循环两次，复杂度为 `O(n^2)`，首次提交居然是 2ms，打败了 100% 的提交，谜一样的结果，之后再次提交就再也没跑到过 2ms 了。
 
 ```java
 class Solution {
@@ -37,9 +37,9 @@ class Solution {
 }
 ```
 
-## 思路1
+## 思路 1
 
-利用HashMap作为存储，键为目标值减去当前元素值，索引为值，比如`i = 0`时，此时首先要判断`nums[0] = 2`是否在map中，如果不存在，那么插入键值对`key = 9 - 2 = 7, value = 0`，之后当`i = 1`时，此时判断`nums[1] = 7`已存在于map中，那么取出该`value = 0`作为第一个返回值，当前`i`作为第二个返回值，具体代码如下所示。
+利用 HashMap 作为存储，键为目标值减去当前元素值，索引为值，比如 `i = 0` 时，此时首先要判断 `nums[0] = 2` 是否在 map 中，如果不存在，那么插入键值对 `key = 9 - 2 = 7, value = 0`，之后当 `i = 1` 时，此时判断 `nums[1] = 7` 已存在于 map 中，那么取出该 `value = 0` 作为第一个返回值，当前 `i` 作为第二个返回值，具体代码如下所示。
 
 ```java
 class Solution {
diff --git a/note/002/README.md b/note/002/README.md
index 5d2a804d..1700c527 100644
--- a/note/002/README.md
+++ b/note/002/README.md
@@ -19,7 +19,7 @@ Explanation: 342 + 465 = 807.
 
 ## 思路
 
-题意我也是看了好久才看懂，就是以链表表示一个数，低位在前，高位在后，所以题中的例子就是`342 + 465 = 807`，所以我们模拟计算即可。
+题意我也是看了好久才看懂，就是以链表表示一个数，低位在前，高位在后，所以题中的例子就是 `342 + 465 = 807`，所以我们模拟计算即可。
 
 ```java
 /**
diff --git a/note/003/README.md b/note/003/README.md
index d01605d9..30366d46 100644
--- a/note/003/README.md
+++ b/note/003/README.md
@@ -17,7 +17,7 @@ Given `"pwwkew"`, the answer is `"wke"`, with the length of 3. Note that the ans
 
 ## 思路
 
-题意是计算不带重复字符的最长子字符串的长度，开辟一个hash数组来存储该字符上次出现的位置，比如`hash[a] = 3`就是代表`a`字符前一次出现的索引在3，遍历该字符串，获取到上次出现的最大索引（只能向前，不能退后），与当前的索引做差获取的就是本次所需长度，从中迭代出最大值就是最终答案。
+题意是计算不带重复字符的最长子字符串的长度，开辟一个 hash 数组来存储该字符上次出现的位置，比如 `hash[a] = 3` 就是代表 `a` 字符前一次出现的索引在 3，遍历该字符串，获取到上次出现的最大索引（只能向前，不能退后），与当前的索引做差获取的就是本次所需长度，从中迭代出最大值就是最终答案。
 
 ```java
 class Solution {
diff --git a/note/005/README.md b/note/005/README.md
index 29f9321a..cd3bc6c3 100644
--- a/note/005/README.md
+++ b/note/005/README.md
@@ -25,7 +25,7 @@ Output: "bb"
 **Tags:** String
 
 
-## 思路0
+## 思路 0
 
 题意是寻找出字符串中最长的回文串，所谓回文串就是正序和逆序相同的字符串，也就是关于中间对称。我们先用最常规的做法，依次去求得每个字符的最长回文，要注意每个字符有奇数长度的回文串和偶数长度的回文串两种情况，相信你可以很轻易地从如下代码中找到相关代码，记录最长回文的始末位置即可，时间复杂度的话，首先要遍历一遍字符串，然后对每个字符都去求得最长回文，所以时间复杂度为 `O(n^2)`。
 
@@ -58,9 +58,9 @@ class Solution {
 ```
 
 
-## 思路1
+## 思路 1
 
-如果利用暴力法遍历所有字串是否回文的情况这道题肯定是 `Time Limit Exceeded` 的，那么我们是否可以把之前遍历的结果利用上呢，那么动态规划的想法就呼之欲出了，我们定义 `dp[i][j]` 的意思为字符串区间`[i, j]`是否为回文串，那么我们分三种情况：
+如果利用暴力法遍历所有字串是否回文的情况这道题肯定是 `Time Limit Exceeded` 的，那么我们是否可以把之前遍历的结果利用上呢，那么动态规划的想法就呼之欲出了，我们定义 `dp[i][j]` 的意思为字符串区间 `[i, j]` 是否为回文串，那么我们分三种情况：
 
 1. 当 `i == j` 时，那么毫无疑问 `dp[i][j] = true`；
 
@@ -98,7 +98,7 @@ class Solution {
 ```
 
 
-## 思路2
+## 思路 2
 
 马拉车算法(Manacher's Algorithm)
 
@@ -112,11 +112,11 @@ class Solution {
 
 3. s = "abcde"，最长回文长度为 `1`，即单个字符本身。
 
-这个问题等同于LeetCode上的 [Longest Palindromic Substring](https://leetcode.com/problems/longest-palindromic-substring)，其相关题解可以查看这里：[传送门](https://github.com/Blankj/awesome-java-leetcode/blob/master/note/005/README.md)
+这个问题等同于 LeetCode 上的 [Longest Palindromic Substring](https://leetcode.com/problems/longest-palindromic-substring)，其相关题解可以查看这里：[传送门](https://github.com/Blankj/awesome-java-leetcode/blob/master/note/005/README.md)
 
 以上问题的传统思路大概是遍历每一个字符，以该字符为中心向两边查找，其时间复杂度为 `O(n^2)`，效率很差。
 
-1975年，一个叫 Manacher 的人发明了 Manacher 算法（中文名：马拉车算法），该算法可以把时间复杂度提升到 `O(n)`，下面我以我理解的思路来讲解其原理。
+1975 年，一个叫 Manacher 的人发明了 Manacher 算法（中文名：马拉车算法），该算法可以把时间复杂度提升到 `O(n)`，下面我以我理解的思路来讲解其原理。
 
 
 ### 分析
diff --git a/note/007/README.md b/note/007/README.md
index 4312bd67..e7809e9b 100644
--- a/note/007/README.md
+++ b/note/007/README.md
@@ -34,7 +34,7 @@ Assume we are dealing with an environment which could only hold integers within
 
 ## 思路
 
-题意是给你一个整型数，求它的逆序整型数，而且有个小坑点，当它的逆序整型数溢出的话，那么就返回0，用我们代码表示的话可以求得结果保存在long中，最后把结果和整型的两个范围比较即可。
+题意是给你一个整型数，求它的逆序整型数，而且有个小坑点，当它的逆序整型数溢出的话，那么就返回 0，用我们代码表示的话可以求得结果保存在 long 中，最后把结果和整型的两个范围比较即可。
 
 ```java
 class Solution {
diff --git a/note/008/README.md b/note/008/README.md
index 061e9c9d..4d0991f9 100644
--- a/note/008/README.md
+++ b/note/008/README.md
@@ -25,7 +25,7 @@ If no valid conversion could be performed, a zero value is returned. If the corr
 
 ## 思路
 
-题意是把一个字符串转为整型，但要注意所给的要求，先去除最前面的空格，然后判断正负数，注意正数可能包含`+`，如果之后存在非数字或全为空则返回`0`，而如果合法的值超过int表示的最大范围，则根据正负号返回`INT_MAX`或`INT_MIN`。
+题意是把一个字符串转为整型，但要注意所给的要求，先去除最前面的空格，然后判断正负数，注意正数可能包含 `+`，如果之后存在非数字或全为空则返回 `0`，而如果合法的值超过 int 表示的最大范围，则根据正负号返回 `INT_MAX` 或 `INT_MIN`。
 
 ```java
 class Solution {
diff --git a/note/009/README.md b/note/009/README.md
index dc80e2a4..59ee7d95 100644
--- a/note/009/README.md
+++ b/note/009/README.md
@@ -19,7 +19,7 @@ There is a more generic way of solving this problem.
 **Tags:** Math
 
 
-## 思路0
+## 思路 0
 
 题意是判断一个有符号整型数是否是回文，也就是逆序过来的整数和原整数相同，首先负数肯定不是，接下来我们分析一下最普通的解法，就是直接算出他的回文数，然后和给定值比较即可。
 
@@ -37,9 +37,9 @@ class Solution {
 }
 ```
 
-## 思路1
+## 思路 1
 
-好好思考下是否需要计算整个长度，比如1234321，其实不然，我们只需要计算一半的长度即可，就是在计算过程中的那个逆序数比不断除10的数大就结束计算即可，但是这也带来了另一个问题，比如10的倍数的数10010，它也会返回`true`，所以我们需要对10的倍数的数再加个判断即可，代码如下所示。
+好好思考下是否需要计算整个长度，比如 1234321，其实不然，我们只需要计算一半的长度即可，就是在计算过程中的那个逆序数比不断除 10 的数大就结束计算即可，但是这也带来了另一个问题，比如 10 的倍数的数 10010，它也会返回 `true`，所以我们需要对 10 的倍数的数再加个判断即可，代码如下所示。
 
 ```java
 public boolean isPalindrome(int x) {
diff --git a/note/010/README.md b/note/010/README.md
index 036597f9..f060497a 100644
--- a/note/010/README.md
+++ b/note/010/README.md
@@ -26,19 +26,19 @@ isMatch("aab", "c*a*b") → true
 **Tags:** String, Dynamic Programming, Backtracking
 
 
-## 思路0
+## 思路 0
 
-题意是让让你从判断`s`字符串是否正则匹配于`p`，这道题和[Wildcard Matching][044]很是相似，区别在于`*`，通配符的`*`是可以随意出现的，跟前面字符没有任何关系，其作用是可以表示任意字符串；而正则匹配的`*`不能单独存在，前面必须具有一个字符，其意义是表明前面的这个字符个数可以是任意个数，包括0个。首先我们用递归的方式来实现，其思路如下：
+题意是让让你从判断 `s` 字符串是否正则匹配于 `p`，这道题和[Wildcard Matching][044]很是相似，区别在于 `*`，通配符的 `*` 是可以随意出现的，跟前面字符没有任何关系，其作用是可以表示任意字符串；而正则匹配的 `*` 不能单独存在，前面必须具有一个字符，其意义是表明前面的这个字符个数可以是任意个数，包括 0 个。首先我们用递归的方式来实现，其思路如下：
 
-* 如果`s`和`p`都为空，那么返回`true`；
+* 如果 `s` 和 `p` 都为空，那么返回 `true`；
 
-* 如果`p`的长度为1，当`s`的长度也为1，并且他们首位匹配则返回`true`，否则返回`false`；
+* 如果 `p` 的长度为 1，当 `s` 的长度也为 1，并且他们首位匹配则返回 `true`，否则返回 `false`；
 
-* 如果`p`的第二个字符不为 '*'，如果`s`为空，那就返回`false`，首位匹配则返回递归调用他们去掉首位的子字符串，否则返回`false`；
+* 如果 `p` 的第二个字符不为 '*'，如果 `s` 为空，那就返回 `false`，首位匹配则返回递归调用他们去掉首位的子字符串，否则返回 `false`；
 
-* 如果`p`的第二个字符为 '*'，循环当`s`不为空，且首位匹配，如果递归调用是否匹配`s`字符串和`p`去掉前两位的子字符串，则返回`true`，否则`s`去掉首字母继续循环；
+* 如果 `p` 的第二个字符为 '*'，循环当 `s` 不为空，且首位匹配，如果递归调用是否匹配 `s` 字符串和 `p` 去掉前两位的子字符串，则返回 `true`，否则 `s` 去掉首字母继续循环；
 
-* 返回递归调用`s`字符串和`p`去掉前两位的子字符串是否匹配。
+* 返回递归调用 `s` 字符串和 `p` 去掉前两位的子字符串是否匹配。
 
 ```java
 class Solution {
@@ -64,15 +64,15 @@ class Solution {
 ```
 
 
-## 思路1
+## 思路 1
 
 我们可以把上面的思路更简单化，如下：
 
-* 如果`s`和`p`都为空，那么返回`true`；
+* 如果 `s` 和 `p` 都为空，那么返回 `true`；
 
-* 如果`p`的第二个字符为`*`，由于`*`前面的字符个数可以为任意，那么我们先递归调用个数为0的情况；或者当`s`不为空，如果他们的首字母匹配，那么我们就递归调用去掉去掉首字母的`s`和完整的`p`；
+* 如果 `p` 的第二个字符为 `*`，由于 `*` 前面的字符个数可以为任意，那么我们先递归调用个数为 0 的情况；或者当 `s` 不为空，如果他们的首字母匹配，那么我们就递归调用去掉去掉首字母的 `s` 和完整的 `p`；
 
-* 如果`p`的第二个字符不为`*`，那么我们就老老实实判断第一个字符是否匹配并且递归调用他们去掉首位的子字符串。
+* 如果 `p` 的第二个字符不为 `*`，那么我们就老老实实判断第一个字符是否匹配并且递归调用他们去掉首位的子字符串。
 
 ```java
 class Solution {
@@ -89,13 +89,13 @@ class Solution {
 }
 ```
 
-## 思路2
+## 思路 2
 
-另一种思路就是动态规划了，我们定义`dp[i][j]`的真假来表示`s[0..i)`是否匹配`p[0..j)`，通过思路1，我们可以确定其状态转移方程如下所示：
+另一种思路就是动态规划了，我们定义 `dp[i][j]` 的真假来表示 `s[0..i)` 是否匹配 `p[0..j)`，通过思路 1，我们可以确定其状态转移方程如下所示：
 
-* 如果`p[j - 1] == '*'`, `dp[i][j] = dp[i][j - 2] || (pc[j - 2] == sc[i - 1] || pc[j - 2] == '.') && dp[i - 1][j];`；
+* 如果 `p[j - 1] == '*'`, `dp[i][j] = dp[i][j - 2] || (pc[j - 2] == sc[i - 1] || pc[j - 2] == '.') && dp[i - 1][j];`；
 
-* 如果`p[j - 1] != '*'`，`dp[i][j] = dp[i - 1][j - 1] && (pc[j - 1] == '.' || pc[j - 1] == sc[i - 1]);`。
+* 如果 `p[j - 1] != '*'`，`dp[i][j] = dp[i - 1][j - 1] && (pc[j - 1] == '.' || pc[j - 1] == sc[i - 1]);`。
 
 ```java
 class Solution {
diff --git a/note/013/README.md b/note/013/README.md
index 8ff2a83c..5916ab9b 100644
--- a/note/013/README.md
+++ b/note/013/README.md
@@ -11,7 +11,7 @@ Input is guaranteed to be within the range from 1 to 3999.
 
 ## 思路
 
-题意是罗马数字转整型数，范围从1到3999，查看下百度百科的罗马数字介绍如下：
+题意是罗马数字转整型数，范围从 1 到 3999，查看下百度百科的罗马数字介绍如下：
 
 * 相同的数字连写，所表示的数等于这些数字相加得到的数，如 Ⅲ=3；
 
@@ -19,7 +19,7 @@ Input is guaranteed to be within the range from 1 to 3999.
 
 * 小的数字（限于 Ⅰ、X 和 C）在大的数字的左边，所表示的数等于大数减小数得到的数，如 Ⅳ=4、Ⅸ=9。
 
-那么我们可以利用map来完成罗马数字的7个数字符号：I、V、X、L、C、D、M和整数的映射关系，然后根据上面的解释来模拟完成即可。
+那么我们可以利用 map 来完成罗马数字的 7 个数字符号：I、V、X、L、C、D、M 和整数的映射关系，然后根据上面的解释来模拟完成即可。
 
 ```java
 class Solution {
diff --git a/note/014/README.md b/note/014/README.md
index 5ac1b5f5..fa6617d6 100644
--- a/note/014/README.md
+++ b/note/014/README.md
@@ -9,7 +9,7 @@ Write a function to find the longest common prefix string amongst an array of st
 
 ## 思路
 
-题意是让你从字符串数组中找出公共前缀，我的想法是找出最短的那个字符串的长度`minLen`，然后在`0...minLen`的范围比较所有字符串，如果比较到有不同的字符，那么直接返回当前索引长度的字符串即可，否则最后返回最短的字符串即可。
+题意是让你从字符串数组中找出公共前缀，我的想法是找出最短的那个字符串的长度 `minLen`，然后在 `0...minLen` 的范围比较所有字符串，如果比较到有不同的字符，那么直接返回当前索引长度的字符串即可，否则最后返回最短的字符串即可。
 
 ```java
 class Solution {
diff --git a/note/015/README.md b/note/015/README.md
index bb622cf6..04b23f6c 100644
--- a/note/015/README.md
+++ b/note/015/README.md
@@ -21,7 +21,7 @@ A solution set is:
 
 ## 思路
 
-题意是让你从数组中找出所有三个和为0的元素构成的非重复序列，这样的话我们可以把数组先做下排序，然后遍历这个排序数组，用两个指针分别指向当前元素的下一个和数组尾部，判断三者和与0的大小来移动两个指针，其中细节操作就是注意去重。
+题意是让你从数组中找出所有三个和为 0 的元素构成的非重复序列，这样的话我们可以把数组先做下排序，然后遍历这个排序数组，用两个指针分别指向当前元素的下一个和数组尾部，判断三者和与 0 的大小来移动两个指针，其中细节操作就是注意去重。
 
 ```java
 class Solution {
diff --git a/note/017/README.md b/note/017/README.md
index 97182e4c..ebf0bd5c 100644
--- a/note/017/README.md
+++ b/note/017/README.md
@@ -20,7 +20,7 @@ Although the above answer is in lexicographical order, your answer could be in a
 **Tags:** String, Backtracking
 
 
-## 思路0
+## 思路 0
 
 题意是给你按键，让你组合出所有不同结果，首先想到的肯定是回溯了，对每个按键的所有情况进行回溯，回溯的终点就是结果字符串长度和按键长度相同。
 
@@ -47,7 +47,7 @@ class Solution {
 }
 ```
 
-## 思路1
+## 思路 1
 
 还有一种思路就是利用队列，根据上一次队列中的值，该值拼接当前可选值来不断迭代其结果，具体代码如下。
 
diff --git a/note/019/README.md b/note/019/README.md
index 7471db68..1035c2a8 100644
--- a/note/019/README.md
+++ b/note/019/README.md
@@ -23,7 +23,7 @@ Try to do this in one pass.
 
 ## 思路
 
-题意是让你删除链表中的倒数第n个数，我的解法是利用双指针，这两个指针相差n个元素，当后面的指针扫到链表末尾的时候，自然它前面的那个指针所指向的下一个元素就是要删除的元素，即`pre.next = pre.next.next;`，但是如果一开始后面的指针指向的为空，此时代表的意思就是要删除第一个元素，即`head = head.next;`。
+题意是让你删除链表中的倒数第 n 个数，我的解法是利用双指针，这两个指针相差 n 个元素，当后面的指针扫到链表末尾的时候，自然它前面的那个指针所指向的下一个元素就是要删除的元素，即 `pre.next = pre.next.next;`，但是如果一开始后面的指针指向的为空，此时代表的意思就是要删除第一个元素，即 `head = head.next;`。
 
 ```java
 /**
diff --git a/note/020/README.md b/note/020/README.md
index ac912ee1..78837723 100644
--- a/note/020/README.md
+++ b/note/020/README.md
@@ -11,7 +11,7 @@ The brackets must close in the correct order, `"()"` and `"()[]{}"` are all vali
 
 ## 思路
 
-题意是判断括号匹配是否正确，很明显，我们可以用栈来解决这个问题，当出现左括号的时候入栈，当遇到右括号时，判断栈顶的左括号是否何其匹配，不匹配的话直接返回`false`即可，最终判断是否空栈即可，这里我们可以用数组模拟栈的操作使其操作更快，有个细节注意下`top =  1;`，从而省去了之后判空的操作和`top - 1`导致数组越界的错误。
+题意是判断括号匹配是否正确，很明显，我们可以用栈来解决这个问题，当出现左括号的时候入栈，当遇到右括号时，判断栈顶的左括号是否何其匹配，不匹配的话直接返回 `false` 即可，最终判断是否空栈即可，这里我们可以用数组模拟栈的操作使其操作更快，有个细节注意下 `top =  1;`，从而省去了之后判空的操作和 `top - 1` 导致数组越界的错误。
 
 ```java
 class Solution {
diff --git a/note/023/README.md b/note/023/README.md
index 67a2e54c..262a7d56 100644
--- a/note/023/README.md
+++ b/note/023/README.md
@@ -7,9 +7,9 @@ Merge *k* sorted linked lists and return it as one sorted list. Analyze and desc
 **Tags:** Linked List, Divide and Conquer, Heap
 
 
-## 思路0
+## 思路 0
 
-题意是合并多个已排序的链表，分析并描述其复杂度，我们可以用分治法来两两合并他们，假设`k`为总链表个数，`N`为总元素个数，那么其时间复杂度为`O(Nlogk)`。
+题意是合并多个已排序的链表，分析并描述其复杂度，我们可以用分治法来两两合并他们，假设 `k` 为总链表个数，`N` 为总元素个数，那么其时间复杂度为 `O(Nlogk)`。
 
 ```java
 /**
@@ -52,9 +52,9 @@ class Solution {
 }
 ```
 
-## 思路1
+## 思路 1
 
-还有另一种思路是利用优先队列，该数据结构用到的是堆排序，所以对总链表个数为`k`的复杂度为`logk`，总元素为个数为`N`的话，其时间复杂度也为`O(Nlogk)`。
+还有另一种思路是利用优先队列，该数据结构用到的是堆排序，所以对总链表个数为 `k` 的复杂度为 `logk`，总元素为个数为 `N` 的话，其时间复杂度也为 `O(Nlogk)`。
 
 ```java
 /**
diff --git a/note/025/README.md b/note/025/README.md
index 13dd7180..7bdeeab7 100644
--- a/note/025/README.md
+++ b/note/025/README.md
@@ -23,7 +23,7 @@ For *k* = 3, you should return: `3->2->1->4->5`
 
 ## 思路
 
-题意是让你以`k`个元素为一组来翻转链表，最后不足`k`个的话不需要翻转，最传统的思路就是每遇到`k`个元素，对其`k`个元素进行翻转，而难点就是在此，下面介绍其原理，我们以例子中的`k = 3`为例，其`pre`和`next`如下所示。
+题意是让你以 `k` 个元素为一组来翻转链表，最后不足 `k` 个的话不需要翻转，最传统的思路就是每遇到 `k` 个元素，对其 `k` 个元素进行翻转，而难点就是在此，下面介绍其原理，我们以例子中的 `k = 3` 为例，其 `pre` 和 `next` 如下所示。
 
 ```
 0->1->2->3->4->5
@@ -31,7 +31,7 @@ For *k* = 3, you should return: `3->2->1->4->5`
 pre        next
 ```
 
-我们要做的就是把`pre`和`next`之间的元素逆序，思想是依次从第二个元素到第`k`个元素，依次把它插入到`pre`后面，过程如下。
+我们要做的就是把 `pre` 和 `next` 之间的元素逆序，思想是依次从第二个元素到第 `k` 个元素，依次把它插入到 `pre` 后面，过程如下。
 
 ```
  head move
diff --git a/note/026/README.md b/note/026/README.md
index bf955846..53daaf2a 100644
--- a/note/026/README.md
+++ b/note/026/README.md
@@ -20,7 +20,7 @@ It doesn't matter what you leave beyond the new length.
 
 ## 思路
 
-题意是让你从一个有序的数组中移除重复的元素，并返回之后数组的长度。我的思路是判断长度小于等于1的话直接返回原长度即可，否则的话遍历一遍数组，用一个`tail`变量指向尾部，如果后面的元素和前面的元素不同，就让`tail`变量加一，最后返回`tail`即可。
+题意是让你从一个有序的数组中移除重复的元素，并返回之后数组的长度。我的思路是判断长度小于等于 1 的话直接返回原长度即可，否则的话遍历一遍数组，用一个 `tail` 变量指向尾部，如果后面的元素和前面的元素不同，就让 `tail` 变量加一，最后返回 `tail` 即可。
 
 ```java
 class Solution {
diff --git a/note/027/README.md b/note/027/README.md
index 23a2d575..f17349af 100644
--- a/note/027/README.md
+++ b/note/027/README.md
@@ -21,7 +21,7 @@ Your function should return length = 2, with the first two elements of nums bein
 
 ## 思路
 
-题意是移除数组中值等于`val`的元素，并返回之后数组的长度，并且题目中指定空间复杂度为O(1)，我的思路是用`tail`标记尾部，遍历该数组时当索引元素不等于`val`时，`tail`加一，尾部指向当前元素，最后返回`tail`即可。
+题意是移除数组中值等于 `val` 的元素，并返回之后数组的长度，并且题目中指定空间复杂度为 O(1)，我的思路是用 `tail` 标记尾部，遍历该数组时当索引元素不等于 `val` 时，`tail` 加一，尾部指向当前元素，最后返回 `tail` 即可。
 
 ```java
 class Solution {
diff --git a/note/035/README.md b/note/035/README.md
index 66f39e6a..3b78d99f 100644
--- a/note/035/README.md
+++ b/note/035/README.md
@@ -39,7 +39,7 @@ Output: 0
 
 ## 思路
 
-题意是让你从一个没有重复元素的已排序数组中找到插入位置的索引。因为数组已排序，所以我们可以想到二分查找法，因为查找到的条件是找到第一个等于或者大于`target`的元素的位置，所以二分法略作变动即可。
+题意是让你从一个没有重复元素的已排序数组中找到插入位置的索引。因为数组已排序，所以我们可以想到二分查找法，因为查找到的条件是找到第一个等于或者大于 `target` 的元素的位置，所以二分法略作变动即可。
 
 ```java
 class Solution {
diff --git a/note/038/README.md b/note/038/README.md
index 376ce4d1..2176dc5b 100644
--- a/note/038/README.md
+++ b/note/038/README.md
@@ -41,7 +41,7 @@ Output: "1211"
 
 ## 思路
 
-题意是数和说，根据如下序列`1, 11, 21, 1211, 111221, ...`，求第n个数，规则很简单,就是数和说，数就是数这个数数字有几个，说就是说这个数，所以`1`就是1个1：`11`,`11`就是有2个1：`21`，`21`就是1个2、1个1：`1211`，可想而知后面就是`111221`，思路的话就是按这个逻辑模拟出来即可。
+题意是数和说，根据如下序列 `1, 11, 21, 1211, 111221, ...`，求第 n 个数，规则很简单,就是数和说，数就是数这个数数字有几个，说就是说这个数，所以 `1` 就是 1 个 1：`11`,`11` 就是有 2 个 1：`21`，`21` 就是 1 个 2、1 个 1：`1211`，可想而知后面就是 `111221`，思路的话就是按这个逻辑模拟出来即可。
 
 ```java
 class Solution {
diff --git a/note/044/README.md b/note/044/README.md
index 878f2760..2798d17f 100644
--- a/note/044/README.md
+++ b/note/044/README.md
@@ -26,9 +26,9 @@ isMatch("aab", "c*a*b") → false
 **Tags:** String, Dynamic Programming, Backtracking, Greedy
 
 
-## 思路0
+## 思路 0
 
-题意是让让你从判断`s`字符串是否通配符匹配于`p`，这道题和[Regular Expression Matching][010]很是相似，区别在于`*`，正则匹配的`*`不能单独存在，前面必须具有一个字符，其意义是表明前面的这个字符个数可以是任意个数，包括0个；而通配符的`*`是可以随意出现的，跟前面字符没有任何关系，其作用是可以表示任意字符串。在此我们可以利用*贪心算法*来解决这个问题，需要两个额外指针`p`和`match`来分别记录最后一个`*`的位置和`*`匹配到`s`字符串的位置，其贪心体现在如果遇到`*`，那就尽可能取匹配后方的内容，如果匹配失败，那就回到上一个遇到`*`的位置来继续贪心。
+题意是让让你从判断 `s` 字符串是否通配符匹配于 `p`，这道题和[Regular Expression Matching][010]很是相似，区别在于 `*`，正则匹配的 `*` 不能单独存在，前面必须具有一个字符，其意义是表明前面的这个字符个数可以是任意个数，包括 0 个；而通配符的 `*` 是可以随意出现的，跟前面字符没有任何关系，其作用是可以表示任意字符串。在此我们可以利用 *贪心算法* 来解决这个问题，需要两个额外指针 `p` 和 `match` 来分别记录最后一个 `*` 的位置和 `*` 匹配到 `s` 字符串的位置，其贪心体现在如果遇到 `*`，那就尽可能取匹配后方的内容，如果匹配失败，那就回到上一个遇到 `*` 的位置来继续贪心。
 
 ```java
 class Solution {
@@ -56,13 +56,13 @@ class Solution {
 ```
 
 
-## 思路1
+## 思路 1
 
-另一种思路就是动态规划了，我们定义`dp[i][j]`的真假来表示`s[0..i)`是否匹配`p[0..j)`，其状态转移方程如下所示：
+另一种思路就是动态规划了，我们定义 `dp[i][j]` 的真假来表示 `s[0..i)` 是否匹配 `p[0..j)`，其状态转移方程如下所示：
 
-* 如果`p[j - 1] != '*'`，`P[i][j] = P[i - 1][j - 1] && (s[i - 1] == p[j - 1] || p[j - 1] == '?');`
+* 如果 `p[j - 1] != '*'`，`P[i][j] = P[i - 1][j - 1] && (s[i - 1] == p[j - 1] || p[j - 1] == '?');`
 
-* 如果`p[j - 1] == '*'`，`P[i][j] = P[i][j - 1] || P[i - 1][j]`
+* 如果 `p[j - 1] == '*'`，`P[i][j] = P[i][j - 1] || P[i - 1][j]`
 
 ```java
 class Solution {
diff --git a/note/050/README.md b/note/050/README.md
index 9dafa42e..a4140f5c 100644
--- a/note/050/README.md
+++ b/note/050/README.md
@@ -23,7 +23,7 @@ Output: 9.26100
 
 ## 思路
 
-题意是让你计算`x^n`，如果直接计算肯定会超时，那么我们可以想到可以使用二分法来降低时间复杂度。
+题意是让你计算 `x^n`，如果直接计算肯定会超时，那么我们可以想到可以使用二分法来降低时间复杂度。
 
 ```java
 class Solution {
diff --git a/note/053/README.md b/note/053/README.md
index 80f969d8..816a3d93 100644
--- a/note/053/README.md
+++ b/note/053/README.md
@@ -15,9 +15,9 @@ If you have figured out the O(*n*) solution, try coding another solution using t
 **Tags:** Array, Divide and Conquer, Dynamic Programming
 
 
-## 思路0
+## 思路 0
 
-题意是求数组中子数组的最大和，这种最优问题一般第一时间想到的就是动态规划，我们可以这样想，当部分序列和大于零的话就一直加下一个元素即可，并和当前最大值进行比较，如果出现部分序列小于零的情况，那肯定就是从当前元素算起。其转移方程就是`dp[i] = nums[i] + (dp[i - 1] > 0 ? dp[i - 1] : 0);`，由于我们不需要保留dp状态，故可以优化空间复杂度为1，即`dp = nums[i] + (dp > 0 ? dp : 0);`。
+题意是求数组中子数组的最大和，这种最优问题一般第一时间想到的就是动态规划，我们可以这样想，当部分序列和大于零的话就一直加下一个元素即可，并和当前最大值进行比较，如果出现部分序列小于零的情况，那肯定就是从当前元素算起。其转移方程就是 `dp[i] = nums[i] + (dp[i - 1] > 0 ? dp[i - 1] : 0);`，由于我们不需要保留 dp 状态，故可以优化空间复杂度为 1，即 `dp = nums[i] + (dp > 0 ? dp : 0);`。
 
 ```java
 class Solution {
@@ -32,9 +32,9 @@ class Solution {
 }
 ```
 
-## 思路1
+## 思路 1
 
-题目也给了我们另一种思路，就是分治，所谓分治就是把问题分割成更小的，最后再合并即可，我们把`nums`一分为二先，那么就有两种情况，一种最大序列包括中间的值，一种就是不包括，也就是在左边或者右边；当最大序列在中间的时候那我们就把它两侧的最大和算出即可；当在两侧的话就继续分治即可。
+题目也给了我们另一种思路，就是分治，所谓分治就是把问题分割成更小的，最后再合并即可，我们把 `nums` 一分为二先，那么就有两种情况，一种最大序列包括中间的值，一种就是不包括，也就是在左边或者右边；当最大序列在中间的时候那我们就把它两侧的最大和算出即可；当在两侧的话就继续分治即可。
 
 ```java
 class Solution {
diff --git a/note/056/README.md b/note/056/README.md
index a89b8b1a..70d8e5bd 100644
--- a/note/056/README.md
+++ b/note/056/README.md
@@ -15,7 +15,7 @@ return `[1,6],[8,10],[15,18]`.
 
 ## 思路
 
-题意是给你一组区间，让你把区间合并成没有交集的一组区间。我们可以把区间按`start`进行排序，然后遍历排序后的区间，如果当前的`start`小于前者的`end`，那么说明这两个存在交集，我们取两者中较大的`end`即可；否则的话直接插入到结果序列中即可。
+题意是给你一组区间，让你把区间合并成没有交集的一组区间。我们可以把区间按 `start` 进行排序，然后遍历排序后的区间，如果当前的 `start` 小于前者的 `end`，那么说明这两个存在交集，我们取两者中较大的 `end` 即可；否则的话直接插入到结果序列中即可。
 
 ```java
 /**
diff --git a/note/058/README.md b/note/058/README.md
index 1581fa6e..4afc1c35 100644
--- a/note/058/README.md
+++ b/note/058/README.md
@@ -20,7 +20,7 @@ Output: 5
 
 ## 思路
 
-题意是让你从一个只包含大小字母和空格字符的字符串中得到最后一个单词的长度，很简单，我们倒序遍历，先得到最后一个非空格字符的索引，然后再得到它前面的空格字符索引，两者相减即可。当然，我们使用API来完成这件事更加方便，只需一行代码`return s.trim().length() - s.trim().lastIndexOf(" ") - 1;`，但我相信作者出这道题的目的肯定不是考你API的使用，所以我们还是用自己的思路来实现。
+题意是让你从一个只包含大小字母和空格字符的字符串中得到最后一个单词的长度，很简单，我们倒序遍历，先得到最后一个非空格字符的索引，然后再得到它前面的空格字符索引，两者相减即可。当然，我们使用 API 来完成这件事更加方便，只需一行代码 `return s.trim().length() - s.trim().lastIndexOf(" ") - 1;`，但我相信作者出这道题的目的肯定不是考你 API 的使用，所以我们还是用自己的思路来实现。
 
 ```java
 class Solution {
diff --git a/note/066/README.md b/note/066/README.md
index c8732c60..aaacdb4f 100644
--- a/note/066/README.md
+++ b/note/066/README.md
@@ -13,7 +13,7 @@ The digits are stored such that the most significant digit is at the head of the
 
 ## 思路
 
-题意是给你一个数字数组，高位在前，并且首位不为0除非这个数组就是`[0]`，让你给该数组低位加一求其结果，那么我们就模拟小学数学那样进位去算即可，如果一直进位到首位，这种情况也就是都是由9组成的数组，此时我们只要new出一个多一个长度的数组即可，并把第0个元素赋1即可。
+题意是给你一个数字数组，高位在前，并且首位不为 0 除非这个数组就是 `[0]`，让你给该数组低位加一求其结果，那么我们就模拟小学数学那样进位去算即可，如果一直进位到首位，这种情况也就是都是由 9 组成的数组，此时我们只要 new 出一个多一个长度的数组即可，并把第 0 个元素赋 1 即可。
 
 ```java
 class Solution {
diff --git a/note/067/README.md b/note/067/README.md
index 606304b6..28bcab99 100644
--- a/note/067/README.md
+++ b/note/067/README.md
@@ -17,7 +17,7 @@ Return `"100"`.
 
 ## 思路
 
-题意是给你两个二进制串，求其和的二进制串。我们就按照小学算数那么来做，用`carry`表示进位，从后往前算，依次往前，每算出一位就插入到最前面即可，直到把两个二进制串都遍历完即可。
+题意是给你两个二进制串，求其和的二进制串。我们就按照小学算数那么来做，用 `carry` 表示进位，从后往前算，依次往前，每算出一位就插入到最前面即可，直到把两个二进制串都遍历完即可。
 
 ```java
 class Solution {
diff --git a/note/068/README.md b/note/068/README.md
index 8630ad34..70aa778a 100644
--- a/note/068/README.md
+++ b/note/068/README.md
@@ -40,7 +40,7 @@ Return the formatted lines as:
 
 ## 思路
 
-题意是给你一组单词和最大行宽，让你对齐他们，对齐的规则就是尽可能一行可以放下足够多的单词，如果最后有多余的空格，那就把空格均匀地插入到单词之间，如果不能平分的话，那就从左开始依次多插一个空格，最后一行单词之间就正常地一个空格即可，如果凑不到最大行宽，那就在末尾补充空格即可，描述地比较差，不懂的话其实看看demo也就懂了哈。题还是比较坑的，毕竟踩的比赞的人多，我也是靠模拟老老实实做出来的，求出可以最多插入空格数，然后用它除以可以插入的槽数获取每个单词之间的空格，它两取余的话就是最面需要多插入一个空格的个数，最后一行的话就单独处理即可。
+题意是给你一组单词和最大行宽，让你对齐他们，对齐的规则就是尽可能一行可以放下足够多的单词，如果最后有多余的空格，那就把空格均匀地插入到单词之间，如果不能平分的话，那就从左开始依次多插一个空格，最后一行单词之间就正常地一个空格即可，如果凑不到最大行宽，那就在末尾补充空格即可，描述地比较差，不懂的话其实看看 demo 也就懂了哈。题还是比较坑的，毕竟踩的比赞的人多，我也是靠模拟老老实实做出来的，求出可以最多插入空格数，然后用它除以可以插入的槽数获取每个单词之间的空格，它两取余的话就是最面需要多插入一个空格的个数，最后一行的话就单独处理即可。
 
 ```java
 class Solution {
diff --git a/note/070/README.md b/note/070/README.md
index bca0ecdb..30f8bcef 100644
--- a/note/070/README.md
+++ b/note/070/README.md
@@ -36,7 +36,7 @@ Explanation:  There are three ways to climb to the top.
 
 ## 思路
 
-题意是爬楼梯，每次你只能爬一步或者两步，问到顶层共有多少种方案。我们假设到顶层共有`f(n)`种，那么`f(n) = f(n - 1) + f(n - 2)`肯定是成立的，意思就是我们迈向顶层的最后一步是在倒数第一级台阶或者在倒数第二级台阶。算法我对空间复杂度进行了优化，因为在迭代过程中只需要两个变量即可。
+题意是爬楼梯，每次你只能爬一步或者两步，问到顶层共有多少种方案。我们假设到顶层共有 `f(n)` 种，那么 `f(n) = f(n - 1) + f(n - 2)` 肯定是成立的，意思就是我们迈向顶层的最后一步是在倒数第一级台阶或者在倒数第二级台阶。算法我对空间复杂度进行了优化，因为在迭代过程中只需要两个变量即可。
 
 ```java
 class Solution {
diff --git a/note/088/README.md b/note/088/README.md
index f4c8069a..44708357 100644
--- a/note/088/README.md
+++ b/note/088/README.md
@@ -13,7 +13,7 @@ You may assume that *nums1* has enough space (size that is greater or equal to *
 
 ## 思路
 
-题意是给两个已排序的数组`nums1`和`nums2`，合并`nums2`到`nums1`中，两数组元素个数分别为`m`和`n`，而且`nums1`数组的长度足够容纳`m + n`个元素，如果我们按顺序排下去，那肯定要开辟一个新数组来保存元素，如果我们选择逆序，这样利用`nums1`自身空间足矣，不会出现覆盖的情况，依次把大的元素插入到`nums1`的末尾，确保`nums2`中的元素全部插入到`nums1`即可。
+题意是给两个已排序的数组 `nums1` 和 `nums2`，合并 `nums2` 到 `nums1` 中，两数组元素个数分别为 `m` 和 `n`，而且 `nums1` 数组的长度足够容纳 `m + n` 个元素，如果我们按顺序排下去，那肯定要开辟一个新数组来保存元素，如果我们选择逆序，这样利用 `nums1` 自身空间足矣，不会出现覆盖的情况，依次把大的元素插入到 `nums1` 的末尾，确保 `nums2` 中的元素全部插入到 `nums1` 即可。
 
 ```java
 class Solution {
diff --git a/note/101/README.md b/note/101/README.md
index b0e9d9ac..9ae6063b 100644
--- a/note/101/README.md
+++ b/note/101/README.md
@@ -31,7 +31,7 @@ Bonus points if you could solve it both recursively and iteratively.
 **Tags:** Tree, Depth-first Search, Breadth-first Search
 
 
-## 思路0
+## 思路 0
 
 题意是判断一棵二叉树是否左右对称，首先想到的是深搜，比较根结点的左右两棵子树是否对称，如果左右子树的值相同，那么再分别对左子树的左节点和右子树的右节点，左子树的右节点和右子树的左节点做比较即可。
 
@@ -58,9 +58,9 @@ class Solution {
 }
 ```
 
-## 思路1
+## 思路 1
 
-第二种思路就是宽搜了，宽搜肯定要用到队列，Java中可用`LinkedList`替代，也是要做到左子树的左节点和右子树的右节点，左子树的右节点和右子树的左节点做比较即可。
+第二种思路就是宽搜了，宽搜肯定要用到队列，Java 中可用 `LinkedList` 替代，也是要做到左子树的左节点和右子树的右节点，左子树的右节点和右子树的左节点做比较即可。
 
 ```java
 /**
diff --git a/note/107/README.md b/note/107/README.md
index 7e107b73..a8600d7c 100644
--- a/note/107/README.md
+++ b/note/107/README.md
@@ -29,7 +29,7 @@ return its bottom-up level order traversal as:
 **Tags:** Tree, Breadth-first Search
 
 
-## 思路0
+## 思路 0
 
 题意是从下往上按层遍历二叉树，每一层是从左到右，按层遍历，很明显，宽搜第一时间符合，因为是从下往上，所以插入的时候每次插到链表头即可。
 
@@ -65,7 +65,7 @@ class Solution {
 }
 ```
 
-## 思路1
+## 思路 1
 
 另一种思路就是深搜，深搜的时候同时记录深度，然后在相应的层插入节点值即可。
 
diff --git a/note/110/README.md b/note/110/README.md
index f2b26061..70c9d8c0 100644
--- a/note/110/README.md
+++ b/note/110/README.md
@@ -11,7 +11,7 @@ For this problem, a height-balanced binary tree is defined as a binary tree in w
 
 ## 思路
 
-题意是判断一棵二叉树是否是高度平衡的，所谓二叉树高度平衡指的是二叉树的每个节点的两棵子树的高度差都不超过1，那么我们只需计算左右子树的高度，判断其高度差是否不超过1即可，如果超过1，就代表其不是高度平衡的，立即返回不是即可，我这里用返回`-1`代表不是。
+题意是判断一棵二叉树是否是高度平衡的，所谓二叉树高度平衡指的是二叉树的每个节点的两棵子树的高度差都不超过 1，那么我们只需计算左右子树的高度，判断其高度差是否不超过 1 即可，如果超过 1，就代表其不是高度平衡的，立即返回不是即可，我这里用返回 `-1` 代表不是。
 
 ```java
 /**
diff --git a/note/111/README.md b/note/111/README.md
index ad219316..f6ea8cdf 100644
--- a/note/111/README.md
+++ b/note/111/README.md
@@ -9,9 +9,9 @@ The minimum depth is the number of nodes along the shortest path from the root n
 **Tags:** Tree, Depth-first Search, Breadth-first Search
 
 
-## 思路0
+## 思路 0
 
-题意是查找二叉树的最小深度，也就是找到从根结点到叶子节点的最小深度，最容易想到的当然是深搜，如果节点的左右深度都不是0的话，说明该节点含有左右子树，所以它的最小高度就是1加上其左右子树高度较小者，否则如果左子树为空或者右子树为空或者两者都为空，那么就是1加上非空子树高度。
+题意是查找二叉树的最小深度，也就是找到从根结点到叶子节点的最小深度，最容易想到的当然是深搜，如果节点的左右深度都不是 0 的话，说明该节点含有左右子树，所以它的最小高度就是 1 加上其左右子树高度较小者，否则如果左子树为空或者右子树为空或者两者都为空，那么就是 1 加上非空子树高度。
 
 ```java
 /**
@@ -34,7 +34,7 @@ class Solution {
 }
 ```
 
-## 思路1
+## 思路 1
 
 第二种思路就是利用宽搜了，搜索到该层有叶子节点，那就返回该层宽度即可。
 

From 40e1e497d5b89bd9e2417874565085f50be2ae4b Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Mon, 11 Dec 2017 10:44:39 +0800
Subject: [PATCH 16/58] update: update 004

---
 note/004/README.md   |  22 ++++++++++++++++++++--
 note/004/my_draw.jpg | Bin 0 -> 45932 bytes
 2 files changed, 20 insertions(+), 2 deletions(-)
 create mode 100644 note/004/my_draw.jpg

diff --git a/note/004/README.md b/note/004/README.md
index 15b22518..70cb1e74 100644
--- a/note/004/README.md
+++ b/note/004/README.md
@@ -29,9 +29,27 @@ The median is (2 + 3)/2 = 2.5
 
 ## 思路
 
-题意是给你两个已排序的递增数组，让你找出其中位数，乍一看这题并不是很难，其实这题难度不可小觑，要做出时间复杂度为 `O(log(m+n))` 的话需要了解从两个递增数组中找出第 `k` 大的元素，也就是我写的 `helper` 函数所起到的作用。下面来解释其原理：
+题意是给你两个已排序的递增数组，让你找出其中位数。
 
-假设数组分别记为 `A`，`B`，当前需要搜索第 `k` 大的数，于是我们可以考虑从数组 `A` 中取出前 `m` 个元素，从数组 `B` 中取出 `k - m` 个元素。由于数组 `A`，`B` 分别排序，则 `A[m]` 大于从数组 `A` 中取出的其他所有元素，`B[k - m]` 大于数组 `B` 中取出的其他所有元素。此时，尽管取出元素之间的相对大小关系不确定，但 `A[m]` 与 `B[k - m]` 的较大者一定是这 `k` 个元素中最大的。那么，较小的那个元素一定不是第 `k` 大的，它至多是第 `k - 1` 大的：因为它小于其他未被取出的所有元素，并且小于取出的 `k` 个元素中最大的那个。为叙述方便，假设 `A[m]` 是较小的那个元素。那么，我们可以进一步说，`A[1]`，`A[2]`...`A[m-1]` 也一定不是第 `k` 大的元素，因为它们小于 `A[m]`，而 `A[m]` 至多是第 `k - 1` 大的。因此，我们可以把较小元素所在数组中选出的所有元素统统排除，并且相应地减少 `k` 值。这样，我们就完成了一次范围缩小。特别地，我们可以选取 `m = k / 2`。而本题只是其一种情况而已，也就当总长为偶数时，找出其中间的两个数，相加除二即可；当总长为奇数时，找到中间的数即可。
+乍一看这题并不是很难，因为两序列有序，所以我们很容想到时间复杂度为 `O(m + n)` 的做法，但这题要求的时间复杂度为 `O(log(m + n))`，那么我们自然而然地就能想到二分查找法。
+
+题目是让找两数组的中位数，我们可以泛化为求两数组中第 `k` 大的元素，那么，求中位数就是其中的一个特例而已。`helper` 函数所起到的作用就是求两数组中第 `k` 大的元素，下面来解释其原理：
+
+假设数组分别记为 `A`，`B`，当前需要搜索第 `k` 大的数，于是我们可以考虑从数组 `A` 中取出前 `m` 个元素，从数组 `B` 中取出 `k - m` 个元素。由于数组 `A`，`B` 分别排序，则 `A[m - 1]` 大于从数组 `A` 中取出的其他所有元素，`B[k - m - 1]` 大于数组 `B` 中取出的其他所有元素。此时，尽管取出元素之间的相对大小关系不确定，但 `A[m - 1]` 与 `B[k - m - 1]` 的较大者一定是这 `k` 个元素中最大的。那么，较小的那个元素一定不是第 `k` 大的，这里留给读者自己想象。
+
+为叙述方便，假设 `A[m - 1]` 是较小的那个元素，那么我们可以把 `A[0]`，`A[1]`...`A[m - 1]` 排除掉，并且更新 `k` 值为 `k - m`，也就是下一次就是从剩余的元素中寻找第 `k - m` 大的元素，这样，我们就完成了一次范围缩小，同理进行下一轮的操作。
+
+那么什么时候停止操作呢？分两种情况：
+
+1. 当某个数组的数都被取完了，那么直接返回另一个数组的后 `k` 个元素即可。
+
+2. 当 `k = 1` 时，也就是只需再找一个数即可，也就是取两者当前较小的那个即可。
+
+特别地，我们选取 `m = k / 2`，下面是我画的草图，希望能帮助大家理解。
+
+![](https://raw.githubusercontent.com/Blankj/awesome-java-leetcode/master/note/004/my_draw.jpg)
+
+借助上面的理论，你能写出相关代码了吗？
 
 ```java
 class Solution {
diff --git a/note/004/my_draw.jpg b/note/004/my_draw.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..160208c7af795970317a9d843f94927e8cc20159
GIT binary patch
literal 45932
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

literal 0
HcmV?d00001


From 21ea0de6b813ed252a441d0f4dd2dc1eef08bcf0 Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Mon, 11 Dec 2017 10:53:21 +0800
Subject: [PATCH 17/58] update: update 004

---
 note/004/my_draw.jpg | Bin 45932 -> 38219 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)

diff --git a/note/004/my_draw.jpg b/note/004/my_draw.jpg
index 160208c7af795970317a9d843f94927e8cc20159..0c3a0739ac4c683ea445882bb39fbdbdeaef77f4 100644
GIT binary patch
delta 27060
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%0ACm
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
L+4%?k$iM&Dr0la0

delta 28549
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


From 4ee26f8b5d46ab01b80533d39ae735e3bc091232 Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Mon, 11 Dec 2017 11:48:55 +0800
Subject: [PATCH 18/58] update: update 004

---
 note/004/README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/note/004/README.md b/note/004/README.md
index 70cb1e74..521fc440 100644
--- a/note/004/README.md
+++ b/note/004/README.md
@@ -31,11 +31,11 @@ The median is (2 + 3)/2 = 2.5
 
 题意是给你两个已排序的递增数组，让你找出其中位数。
 
-乍一看这题并不是很难，因为两序列有序，所以我们很容想到时间复杂度为 `O(m + n)` 的做法，但这题要求的时间复杂度为 `O(log(m + n))`，那么我们自然而然地就能想到二分查找法。
+乍一看这题并不是很难，因为两序列有序，所以我们很容想到时间复杂度为 `O(m + n)` 的做法：依次取出两数组中较小的元素，然后找到中间的元素即可。但这题要求的时间复杂度为 `O(log(m + n))`，那么我们自然而然地就能想到二分查找法进行求解。
 
 题目是让找两数组的中位数，我们可以泛化为求两数组中第 `k` 大的元素，那么，求中位数就是其中的一个特例而已。`helper` 函数所起到的作用就是求两数组中第 `k` 大的元素，下面来解释其原理：
 
-假设数组分别记为 `A`，`B`，当前需要搜索第 `k` 大的数，于是我们可以考虑从数组 `A` 中取出前 `m` 个元素，从数组 `B` 中取出 `k - m` 个元素。由于数组 `A`，`B` 分别排序，则 `A[m - 1]` 大于从数组 `A` 中取出的其他所有元素，`B[k - m - 1]` 大于数组 `B` 中取出的其他所有元素。此时，尽管取出元素之间的相对大小关系不确定，但 `A[m - 1]` 与 `B[k - m - 1]` 的较大者一定是这 `k` 个元素中最大的。那么，较小的那个元素一定不是第 `k` 大的，这里留给读者自己想象。
+假设数组分别记为 `A`，`B`，当前需要搜索第 `k` 大的数，于是我们可以考虑从数组 `A` 中取出前 `m` 个元素，从数组 `B` 中取出前 `k - m` 个元素。由于数组 `A`，`B` 分别排序，则 `A[m - 1]` 大于从数组 `A` 中取出的其他所有元素，`B[k - m - 1]` 大于数组 `B` 中取出的其他所有元素。此时，尽管取出元素之间的相对大小关系不确定，但 `A[m - 1]` 与 `B[k - m - 1]` 的较大者一定是这 `k` 个元素中最大的。那么，较小的那个元素一定不是第 `k` 大的，这里留给读者自己想象。
 
 为叙述方便，假设 `A[m - 1]` 是较小的那个元素，那么我们可以把 `A[0]`，`A[1]`...`A[m - 1]` 排除掉，并且更新 `k` 值为 `k - m`，也就是下一次就是从剩余的元素中寻找第 `k - m` 大的元素，这样，我们就完成了一次范围缩小，同理进行下一轮的操作。
 

From 6e2cf1402692de821b713dc224b87d41be333834 Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Mon, 11 Dec 2017 16:05:45 +0800
Subject: [PATCH 19/58] feat: add 006

---
 README.md                                |   2 +
 note/006/README.md                       | 112 +++++++++++++++++++++++
 src/com/blankj/medium/_006/Solution.java |  63 +++++++++++++
 3 files changed, 177 insertions(+)
 create mode 100644 note/006/README.md
 create mode 100644 src/com/blankj/medium/_006/Solution.java

diff --git a/README.md b/README.md
index 389b8c0f..5b058863 100644
--- a/README.md
+++ b/README.md
@@ -70,6 +70,7 @@
 | 2    | [Add Two Numbers][002]                   | Linked List, Math                |
 | 3    | [Longest Substring Without Repeating Characters][003] | Hash Table, Two Pointers, String |
 | 5    | [Longest Palindromic Substring][005]     | String                           |
+| 6    | [ZigZag Conversion][006]                 | String                           |
 | 8    | [String to Integer (atoi)][008]          | Math, String                     |
 | 15   | [3Sum][015]                              | Array, Two Pointers              |
 | 17   | [Letter Combinations of a Phone Number][017] | String, Backtracking             |
@@ -138,6 +139,7 @@
 [002]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/002/README.md
 [003]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/003/README.md
 [005]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/005/README.md
+[005]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/006/README.md
 [008]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/008/README.md
 [015]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/015/README.md
 [017]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/017/README.md
diff --git a/note/006/README.md b/note/006/README.md
new file mode 100644
index 00000000..fc1c6ef2
--- /dev/null
+++ b/note/006/README.md
@@ -0,0 +1,112 @@
+# [Longest Palindromic Substring][title]
+
+## Description
+
+The string `"PAYPALISHIRING"` is written in a zigzag pattern on a given number of rows like this: (you may want to display this pattern in a fixed font for better legibility)
+
+```
+P   A   H   N
+A P L S I I G
+Y   I   R
+```
+
+And then read line by line: `"PAHNAPLSIIGYIR"`
+
+Write the code that will take a string and make this conversion given a number of rows:
+
+```
+string convert(string text, int nRows);
+```
+
+`convert("PAYPALISHIRING", 3)` should return `"PAHNAPLSIIGYIR"`.
+
+**Tags:** String
+
+
+## 思路 0
+
+题意是让你把字符串按波浪形排好，然后返回横向读取的字符串。
+
+听不懂的话，看下图应该就明白了：
+
+```
+                                                       
+0                           2n-2                        4n-4
+1                    2n-3   2n-1                 4n-5   4n-5
+2              2n-4         2n               4n-6       .
+.           .               .             .             .
+.       n+1                 .          3n-1             .
+n-2   n                     3n-4   3n-2                 5n-6
+n-1                         3n-3                        5n-5
+                                                       
+```
+
+那么我们可以根据上图找规律，可以看到最波峰和波谷是单顶点的，它们周期是 `2 * (n - 1)`，单独处理即可；中间的部分每个周期会出现两次，规律很好找，留给读者自己想象，不懂的可以结合以下代码。
+
+```java
+class Solution {
+    public String convert(String s, int numRows) {
+        if (numRows <= 1) return s;
+        int len = s.length();
+        char[] chars = s.toCharArray();
+        int cycle = 2 * (numRows - 1);
+        StringBuilder sb = new StringBuilder();
+        for (int j = 0; j < len; j += cycle) {
+            sb.append(chars[j]);
+        }
+        for (int i = 1; i < numRows - 1; i++) {
+            int step = 2 * i;
+            for (int j = i; j < len; j += step) {
+                sb.append(chars[j]);
+                step = cycle - step;
+            }
+        }
+        for (int j = numRows - 1; j < len; j += cycle) {
+            sb.append(chars[j]);
+        }
+        return sb.toString();
+    }
+}
+```
+
+
+## 思路 1
+
+另外一种思路就是开辟相应行数的 `StringBuilder` 对象，然后模拟波浪生成的样子分别插入到相应的 `StringBuilder` 对象，具体代码如下，比较直白简单。
+
+```java
+class Solution {
+    public String convert(String s, int numRows) {
+        if (numRows <= 1) return s;
+        int len = s.length();
+        char[] chars = s.toCharArray();
+        StringBuilder[] sbs = new StringBuilder[numRows];
+        for (int i = 0; i < numRows; i++) {
+            sbs[i] = new StringBuilder();
+        }
+        int i = 0;
+        while (i < len) {
+            for (int j = 0; j < numRows && i < len; ++j) {
+                sbs[j].append(chars[i++]);
+            }
+            for (int j = numRows - 2; j >= 1 && i < len; --j) {
+                sbs[j].append(chars[i++]);
+            }
+        }
+        for (i = 1; i < numRows; i++) {
+            sbs[0].append(sbs[i]);
+        }
+        return sbs[0].toString();
+    }
+}
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
+
+
+
+[title]: https://leetcode.com/problems/longest-palindromic-substring
+[ajl]: https://github.com/Blankj/awesome-java-leetcode
diff --git a/src/com/blankj/medium/_006/Solution.java b/src/com/blankj/medium/_006/Solution.java
new file mode 100644
index 00000000..0def8017
--- /dev/null
+++ b/src/com/blankj/medium/_006/Solution.java
@@ -0,0 +1,63 @@
+package com.blankj.medium._006;
+
+/**
+ * <pre>
+ *     author: Blankj
+ *     blog  : http://blankj.com
+ *     time  : 2017/12/11
+ *     desc  :
+ * </pre>
+ */
+class Solution {
+
+//    public String convert(String s, int numRows) {
+//        if (numRows <= 1) return s;
+//        int len = s.length();
+//        char[] chars = s.toCharArray();
+//        int cycle = 2 * (numRows - 1);
+//        StringBuilder sb = new StringBuilder();
+//        for (int j = 0; j < len; j += cycle) {
+//            sb.append(chars[j]);
+//        }
+//        for (int i = 1; i < numRows - 1; i++) {
+//            int step = 2 * i;
+//            for (int j = i; j < len; j += step) {
+//                sb.append(chars[j]);
+//                step = cycle - step;
+//            }
+//        }
+//        for (int j = numRows - 1; j < len; j += cycle) {
+//            sb.append(chars[j]);
+//        }
+//        return sb.toString();
+//    }
+
+    public String convert(String s, int numRows) {
+        if (numRows <= 1) return s;
+        int len = s.length();
+        char[] chars = s.toCharArray();
+        StringBuilder[] sbs = new StringBuilder[numRows];
+        for (int i = 0; i < numRows; i++) {
+            sbs[i] = new StringBuilder();
+        }
+        int i = 0;
+        while (i < len) {
+            for (int j = 0; j < numRows && i < len; ++j) {
+                sbs[j].append(chars[i++]);
+            }
+            for (int j = numRows - 2; j >= 1 && i < len; --j) {
+                sbs[j].append(chars[i++]);
+            }
+        }
+        for (i = 1; i < numRows; i++) {
+            sbs[0].append(sbs[i]);
+        }
+        return sbs[0].toString();
+    }
+
+    public static void main(String[] args) {
+        Solution solution = new Solution();
+        System.out.println(solution.convert("PAYPALISHIRING", 3));// PAHNAPLSIIGYIR
+        System.out.println(solution.convert("ABCD", 4));
+    }
+}

From eccbf72703ca09b3935920372d9e64517d213d1b Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Mon, 11 Dec 2017 16:06:54 +0800
Subject: [PATCH 20/58] feat: add 006

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 5b058863..03a00781 100644
--- a/README.md
+++ b/README.md
@@ -139,7 +139,7 @@
 [002]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/002/README.md
 [003]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/003/README.md
 [005]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/005/README.md
-[005]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/006/README.md
+[006]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/006/README.md
 [008]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/008/README.md
 [015]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/015/README.md
 [017]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/017/README.md

From 05de5754eeacf397331071efd5e3966ffc546dde Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Mon, 11 Dec 2017 21:17:36 +0800
Subject: [PATCH 21/58] update: update 004

---
 note/006/README.md | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/note/006/README.md b/note/006/README.md
index fc1c6ef2..bb83f766 100644
--- a/note/006/README.md
+++ b/note/006/README.md
@@ -27,10 +27,9 @@ string convert(string text, int nRows);
 
 题意是让你把字符串按波浪形排好，然后返回横向读取的字符串。
 
-听不懂的话，看下图应该就明白了：
+听不懂的话，看下面的表示应该就明白了：
 
 ```
-                                                       
 0                           2n-2                        4n-4
 1                    2n-3   2n-1                 4n-5   4n-5
 2              2n-4         2n               4n-6       .
@@ -38,10 +37,9 @@ string convert(string text, int nRows);
 .       n+1                 .          3n-1             .
 n-2   n                     3n-4   3n-2                 5n-6
 n-1                         3n-3                        5n-5
-                                                       
 ```
 
-那么我们可以根据上图找规律，可以看到最波峰和波谷是单顶点的，它们周期是 `2 * (n - 1)`，单独处理即可；中间的部分每个周期会出现两次，规律很好找，留给读者自己想象，不懂的可以结合以下代码。
+那么我们可以根据上面找规律，可以看到波峰和波谷是单顶点的，它们周期是 `2 * (n - 1)`，单独处理即可；中间的部分每个周期会出现两次，规律很好找，留给读者自己想象，不懂的可以结合以下代码。
 
 ```java
 class Solution {
@@ -72,7 +70,7 @@ class Solution {
 
 ## 思路 1
 
-另外一种思路就是开辟相应行数的 `StringBuilder` 对象，然后模拟波浪生成的样子分别插入到相应的 `StringBuilder` 对象，具体代码如下，比较直白简单。
+另外一种思路就是开辟相应行数的 `StringBuilder` 对象，然后模拟波浪生成的样子分别插入到相应的 `StringBuilder` 对象，比较直白简单，具体代码如下。
 
 ```java
 class Solution {

From d54abce27f475ab0ed9a8daf529cde9378baad87 Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Wed, 13 Dec 2017 09:58:54 +0800
Subject: [PATCH 22/58] fix: fix some

---
 note/006/README.md |  4 ++--
 note/009/README.md | 16 +++++++++-------
 note/069/README.md |  2 +-
 3 files changed, 12 insertions(+), 10 deletions(-)

diff --git a/note/006/README.md b/note/006/README.md
index bb83f766..28e382a7 100644
--- a/note/006/README.md
+++ b/note/006/README.md
@@ -1,4 +1,4 @@
-# [Longest Palindromic Substring][title]
+# [ZigZag Conversion][title]
 
 ## Description
 
@@ -106,5 +106,5 @@ class Solution {
 
 
 
-[title]: https://leetcode.com/problems/longest-palindromic-substring
+[title]: https://leetcode.com/problems/zigzag-conversion
 [ajl]: https://github.com/Blankj/awesome-java-leetcode
diff --git a/note/009/README.md b/note/009/README.md
index 59ee7d95..c549c911 100644
--- a/note/009/README.md
+++ b/note/009/README.md
@@ -42,14 +42,16 @@ class Solution {
 好好思考下是否需要计算整个长度，比如 1234321，其实不然，我们只需要计算一半的长度即可，就是在计算过程中的那个逆序数比不断除 10 的数大就结束计算即可，但是这也带来了另一个问题，比如 10 的倍数的数 10010，它也会返回 `true`，所以我们需要对 10 的倍数的数再加个判断即可，代码如下所示。
 
 ```java
-public boolean isPalindrome(int x) {
-    if (x < 0 || (x != 0 && x % 10 == 0)) return false;
-    int halfReverseX = 0;
-    while (x > halfReverseX) {
-        halfReverseX = halfReverseX * 10 + x % 10;
-        x /= 10;
+class Solution {
+    public boolean isPalindrome(int x) {
+        if (x < 0 || (x != 0 && x % 10 == 0)) return false;
+        int halfReverseX = 0;
+        while (x > halfReverseX) {
+            halfReverseX = halfReverseX * 10 + x % 10;
+            x /= 10;
+        }
+        return halfReverseX == x || halfReverseX / 10 == x;
     }
-    return halfReverseX == x || halfReverseX / 10 == x;
 }
 ```
 
diff --git a/note/069/README.md b/note/069/README.md
index 09974689..7b686258 100644
--- a/note/069/README.md
+++ b/note/069/README.md
@@ -28,7 +28,7 @@ Explanation: The square root of 8 is 2.82842..., and since we want to return an
 
 ## 思路
 
-题意是求平方根，参考[牛顿迭代法求平方根](https://wenku.baidu.com/view/6b74c622bcd126fff7050bfe.html)，然后再参考维基百科的[Integer square root](https://en.wikipedia.org/wiki/Integer_square_root#Using_only_integer_division)即可。
+题意是求平方根，参考 [牛顿迭代法求平方根](https://wenku.baidu.com/view/6b74c622bcd126fff7050bfe.html)，然后再参考维基百科的 [Integer square root](https://en.wikipedia.org/wiki/Integer_square_root#Using_only_integer_division) 即可。
 
 ```java
 class Solution {

From 4981f7b0bf067937186bc2679a1856c2e097ce14 Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Wed, 27 Dec 2017 21:26:06 +0800
Subject: [PATCH 23/58] fix: fix 101

---
 note/101/README.md                     | 4 ++--
 src/com/blankj/easy/_101/Solution.java | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/note/101/README.md b/note/101/README.md
index 9ae6063b..8f0e0b05 100644
--- a/note/101/README.md
+++ b/note/101/README.md
@@ -47,13 +47,13 @@ Bonus points if you could solve it both recursively and iteratively.
  */
 class Solution {
     public boolean isSymmetric(TreeNode root) {
-        return root == null || isSymmetricHelper(root.left, root.right);
+        return root == null || helper(root.left, root.right);
     }
 
     public boolean helper(TreeNode left, TreeNode right) {
         if (left == null || right == null) return left == right;
         if (left.val != right.val) return false;
-        return isSymmetricHelper(left.left, right.right) && isSymmetricHelper(left.right, right.left);
+        return helper(left.left, right.right) && helper(left.right, right.left);
     }
 }
 ```
diff --git a/src/com/blankj/easy/_101/Solution.java b/src/com/blankj/easy/_101/Solution.java
index 0c6d58f1..4fd23e88 100644
--- a/src/com/blankj/easy/_101/Solution.java
+++ b/src/com/blankj/easy/_101/Solution.java
@@ -15,13 +15,13 @@
  */
 public class Solution {
 //    public boolean isSymmetric(TreeNode root) {
-//        return root == null || isSymmetricHelper(root.left, root.right);
+//        return root == null || helper(root.left, root.right);
 //    }
 //
 //    private boolean helper(TreeNode left, TreeNode right) {
 //        if (left == null || right == null) return left == right;
 //        if (left.val != right.val) return false;
-//        return isSymmetricHelper(left.left, right.right) && isSymmetricHelper(left.right, right.left);
+//        return helper(left.left, right.right) && helper(left.right, right.left);
 //    }
 
     public boolean isSymmetric(TreeNode root) {

From 9bc3aabf1cf5771db70b3971f9acb082afb912ce Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Thu, 18 Jan 2018 22:38:42 +0800
Subject: [PATCH 24/58] fix: fix 013

---
 src/com/blankj/easy/_013/Solution.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/com/blankj/easy/_013/Solution.java b/src/com/blankj/easy/_013/Solution.java
index 2322a0ed..204d9f4e 100644
--- a/src/com/blankj/easy/_013/Solution.java
+++ b/src/com/blankj/easy/_013/Solution.java
@@ -36,6 +36,6 @@ public int romanToInt(String s) {
     public static void main(String[] args) {
         Solution solution = new Solution();
         System.out.println(solution.romanToInt("DCXXI"));// 621
-        System.out.println(solution.romanToInt("CCCXLVIII"));// 384
+        System.out.println(solution.romanToInt("CCCXLVIII"));// 348
     }
 }

From 31281be2e1122016645edbec0cfadbe49c440d08 Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Fri, 19 Jan 2018 23:37:09 +0800
Subject: [PATCH 25/58] feat: add 011

---
 note/011/README.md | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 note/011/README.md

diff --git a/note/011/README.md b/note/011/README.md
new file mode 100644
index 00000000..a9277670
--- /dev/null
+++ b/note/011/README.md
@@ -0,0 +1,29 @@
+# [Container With Most Water][title]
+
+## Description
+
+Given *n* non-negative integers *a1*, *a2*, ..., *an*, where each represents a point at coordinate (*i*, *ai*). *n* vertical lines are drawn such that the two endpoints of line *i* is at (*i*, *ai*) and (*i*, 0). Find two lines, which together with x-axis forms a container, such that the container contains the most water.
+
+Note: You may not slant the container and *n* is at least 2.
+
+**Tags:** Array, Two Pointers
+
+
+## 思路
+
+
+
+```java
+
+```
+
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
+
+
+
+[title]: https://leetcode.com/problems/container-with-most-water
+[ajl]: https://github.com/Blankj/awesome-java-leetcode

From 1b031f76f2429c7e7eb139e9037ebf4fafd932eb Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Sun, 21 Jan 2018 15:15:23 +0800
Subject: [PATCH 26/58] feat: add 011

---
 README.md                                |   2 ++
 note/011/README.md                       |  22 +++++++++++++++--
 note/011/water.png                       | Bin 0 -> 42200 bytes
 src/com/blankj/medium/_011/Solution.java |  29 +++++++++++++++++++++++
 4 files changed, 51 insertions(+), 2 deletions(-)
 create mode 100644 note/011/water.png
 create mode 100644 src/com/blankj/medium/_011/Solution.java

diff --git a/README.md b/README.md
index 03a00781..c3ad2b1b 100644
--- a/README.md
+++ b/README.md
@@ -72,6 +72,7 @@
 | 5    | [Longest Palindromic Substring][005]     | String                           |
 | 6    | [ZigZag Conversion][006]                 | String                           |
 | 8    | [String to Integer (atoi)][008]          | Math, String                     |
+| 11   | [Container With Most Water][011]         | Array, Two Pointers              |
 | 15   | [3Sum][015]                              | Array, Two Pointers              |
 | 17   | [Letter Combinations of a Phone Number][017] | String, Backtracking             |
 | 19   | [Remove Nth Node From End of List][019]  | Linked List, Two Pointers        |
@@ -141,6 +142,7 @@
 [005]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/005/README.md
 [006]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/006/README.md
 [008]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/008/README.md
+[011]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/011/README.md
 [015]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/015/README.md
 [017]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/017/README.md
 [019]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/019/README.md
diff --git a/note/011/README.md b/note/011/README.md
index a9277670..e7e8dd7e 100644
--- a/note/011/README.md
+++ b/note/011/README.md
@@ -11,12 +11,30 @@ Note: You may not slant the container and *n* is at least 2.
 
 ## 思路
 
+题意是给你 *a1*, *a2*, ..., *an* 这 *n* 个数，代表 (*i*, *ai*) 坐标，让你从中找两个点与 x 轴围成的容器可以容纳最多的水。
 
+不明白的话可以看数据为 `1 8 6 2 5 4 8 3 7` 所示的图。
 
-```java
+![](https://raw.githubusercontent.com/Blankj/awesome-java-leetcode/master/note/011/water.png)
+
+如果用暴力法求每种情况的结果，其时间复杂度为 O(n^2)，相信肯定会超时，我们可以探索下是否有更巧妙的办法呢，题目的标签有双指针，是否就可以想到首尾各放一指针，然后根据条件来收缩。首先计算一次首尾构成的最大面积，然后分析下该移动哪个指针，如果移动大的那个指针的话，那样只会减小面积，所以我们要移动小的那个指针，小的那个指针移动到哪呢？当然是移动到大于之前的值的地方，否则面积不都比之前小么，然后继续更新最大值即可，借助如上分析写出如下代码应该不是什么难事了吧。
 
-```
 
+```java
+class Solution {
+    public int maxArea(int[] height) {
+        int l = 0, r = height.length - 1;
+        int max = 0, h = 0;
+        while (l < r) {
+            h = Math.min(height[l], height[r]);
+            max = Math.max(max, (r - l) * h);
+            while (height[l] <= h && l < r) ++l;
+            while (height[r] <= h && l < r) --r;
+        }
+        return max;
+    }
+}
+```
 
 
 ## 结语
diff --git a/note/011/water.png b/note/011/water.png
new file mode 100644
index 0000000000000000000000000000000000000000..7533029cbd770d806eff8e14cb1c4abe4678c97b
GIT binary patch
literal 42200
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
M|L4m_c>LYJ04}%Q#sB~S

literal 0
HcmV?d00001

diff --git a/src/com/blankj/medium/_011/Solution.java b/src/com/blankj/medium/_011/Solution.java
new file mode 100644
index 00000000..89ee60ca
--- /dev/null
+++ b/src/com/blankj/medium/_011/Solution.java
@@ -0,0 +1,29 @@
+package com.blankj.medium._011;
+
+/**
+ * <pre>
+ *     author: Blankj
+ *     blog  : http://blankj.com
+ *     time  : 2017/04/23
+ *     desc  :
+ * </pre>
+ */
+public class Solution {
+    public int maxArea(int[] height) {
+        int l = 0, r = height.length - 1;
+        int max = 0, h = 0;
+        while (l < r) {
+            h = Math.min(height[l], height[r]);
+            max = Math.max(max, (r - l) * h);
+            while (height[l] <= h && l < r) ++l;
+            while (height[r] <= h && l < r) --r;
+        }
+        return max;
+    }
+
+    public static void main(String[] args) {
+        Solution solution = new Solution();
+        System.out.println(solution.maxArea(new int[]{1, 2, 4, 3})); // 4
+        System.out.println(solution.maxArea(new int[]{1, 8, 6, 2, 5, 4, 8, 3, 7}));// 49
+    }
+}
\ No newline at end of file

From 64ed8f05d133d1edd123fea5fe504ef607070e0b Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Thu, 25 Jan 2018 11:44:44 +0800
Subject: [PATCH 27/58] feat: add 012

---
 README.md                                |  2 ++
 note/012/README.md                       | 44 ++++++++++++++++++++++++
 src/com/blankj/medium/_012/Solution.java | 25 ++++++++++++++
 3 files changed, 71 insertions(+)
 create mode 100644 note/012/README.md
 create mode 100644 src/com/blankj/medium/_012/Solution.java

diff --git a/README.md b/README.md
index c3ad2b1b..578508fb 100644
--- a/README.md
+++ b/README.md
@@ -73,6 +73,7 @@
 | 6    | [ZigZag Conversion][006]                 | String                           |
 | 8    | [String to Integer (atoi)][008]          | Math, String                     |
 | 11   | [Container With Most Water][011]         | Array, Two Pointers              |
+| 12   | [Integer to Roman][012]                  | Math, String                     |
 | 15   | [3Sum][015]                              | Array, Two Pointers              |
 | 17   | [Letter Combinations of a Phone Number][017] | String, Backtracking             |
 | 19   | [Remove Nth Node From End of List][019]  | Linked List, Two Pointers        |
@@ -143,6 +144,7 @@
 [006]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/006/README.md
 [008]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/008/README.md
 [011]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/011/README.md
+[012]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/012/README.md
 [015]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/015/README.md
 [017]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/017/README.md
 [019]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/019/README.md
diff --git a/note/012/README.md b/note/012/README.md
new file mode 100644
index 00000000..99f9d8cc
--- /dev/null
+++ b/note/012/README.md
@@ -0,0 +1,44 @@
+# [Container With Most Water][title]
+
+## Description
+
+Given an integer, convert it to a roman numeral.
+
+Input is guaranteed to be within the range from 1 to 3999.
+
+**Tags:** Math, String
+
+
+## 思路
+
+题意是整型数转罗马数字，范围从 1 到 3999，查看下百度百科的罗马数字介绍如下：
+
+* 相同的数字连写，所表示的数等于这些数字相加得到的数，如 Ⅲ=3；
+
+* 小的数字在大的数字的右边，所表示的数等于这些数字相加得到的数，如 Ⅷ=8、Ⅻ=12；
+
+* 小的数字（限于 Ⅰ、X 和 C）在大的数字的左边，所表示的数等于大数减小数得到的数，如 Ⅳ=4、Ⅸ=9。
+
+那么我们可以把整数的每一位分离出来，让其每一位都用相应的罗马数字位表示，最终拼接完成。比如 `621` 我们可以分离百、十、个分别为 `6`、`2`、`1`，那么 `600` 对应的罗马数字是 `DC`，`20` 对应的罗马数字是 `XX`，`1` 对应的罗马数字是 `I`，所以最终答案便是 `DCXXI`。
+
+```java
+class Solution {
+    public String intToRoman(int num) {
+        String M[] = {"", "M", "MM", "MMM"};
+        String C[] = {"", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"};
+        String X[] = {"", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"};
+        String I[] = {"", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"};
+        return M[num / 1000] + C[(num % 1000) / 100] + X[(num % 100) / 10] + I[num % 10];
+    }
+}
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
+
+
+
+[title]: https://leetcode.com/problems/container-with-most-water
+[ajl]: https://github.com/Blankj/awesome-java-leetcode
diff --git a/src/com/blankj/medium/_012/Solution.java b/src/com/blankj/medium/_012/Solution.java
new file mode 100644
index 00000000..d3f57fff
--- /dev/null
+++ b/src/com/blankj/medium/_012/Solution.java
@@ -0,0 +1,25 @@
+package com.blankj.medium._012;
+
+/**
+ * <pre>
+ *     author: Blankj
+ *     blog  : http://blankj.com
+ *     time  : 2018/01/25
+ *     desc  :
+ * </pre>
+ */
+public class Solution {
+    public String intToRoman(int num) {
+        String M[] = {"", "M", "MM", "MMM"};
+        String C[] = {"", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"};
+        String X[] = {"", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"};
+        String I[] = {"", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"};
+        return M[num / 1000] + C[(num % 1000) / 100] + X[(num % 100) / 10] + I[num % 10];
+    }
+
+    public static void main(String[] args) {
+        Solution solution = new Solution();
+        System.out.println(solution.intToRoman(621));// DCXXI
+        System.out.println(solution.intToRoman(348));// CCCXLVIII
+    }
+}

From 101eca4380ae0576a69f95bc8905e38ee3a38a97 Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Wed, 24 Jan 2018 13:35:43 +0800
Subject: [PATCH 28/58] feat: add 012

---
 note/012/README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/note/012/README.md b/note/012/README.md
index 99f9d8cc..002b22ec 100644
--- a/note/012/README.md
+++ b/note/012/README.md
@@ -1,4 +1,4 @@
-# [Container With Most Water][title]
+# [Integer to Roman][title]
 
 ## Description
 
@@ -40,5 +40,5 @@ class Solution {
 
 
 
-[title]: https://leetcode.com/problems/container-with-most-water
+[title]: https://leetcode.com/problems/integer-to-roman
 [ajl]: https://github.com/Blankj/awesome-java-leetcode

From 178ec5e4217090b8d9b968188e88059221f1aa02 Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Tue, 30 Jan 2018 02:19:39 +0800
Subject: [PATCH 29/58] update: 015

---
 note/015/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/note/015/README.md b/note/015/README.md
index 04b23f6c..fee1414b 100644
--- a/note/015/README.md
+++ b/note/015/README.md
@@ -21,7 +21,7 @@ A solution set is:
 
 ## 思路
 
-题意是让你从数组中找出所有三个和为 0 的元素构成的非重复序列，这样的话我们可以把数组先做下排序，然后遍历这个排序数组，用两个指针分别指向当前元素的下一个和数组尾部，判断三者和与 0 的大小来移动两个指针，其中细节操作就是注意去重。
+题意是让你从数组中找出所有三个和为 0 的元素构成的非重复序列，这样的话我们可以把数组先做下排序，然后遍历这个排序数组，用两个指针分别指向当前元素的下一个和数组尾部，判断三者的和与 0 的大小来移动两个指针，其中细节操作就是注意去重。
 
 ```java
 class Solution {

From 7aa9d889e17ed01d550b2d8ed1f045f7c4232481 Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Tue, 30 Jan 2018 02:19:59 +0800
Subject: [PATCH 30/58] update: 010

---
 note/010/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/note/010/README.md b/note/010/README.md
index f060497a..b52b6a5e 100644
--- a/note/010/README.md
+++ b/note/010/README.md
@@ -28,7 +28,7 @@ isMatch("aab", "c*a*b") → true
 
 ## 思路 0
 
-题意是让让你从判断 `s` 字符串是否正则匹配于 `p`，这道题和[Wildcard Matching][044]很是相似，区别在于 `*`，通配符的 `*` 是可以随意出现的，跟前面字符没有任何关系，其作用是可以表示任意字符串；而正则匹配的 `*` 不能单独存在，前面必须具有一个字符，其意义是表明前面的这个字符个数可以是任意个数，包括 0 个。首先我们用递归的方式来实现，其思路如下：
+题意是让让你从判断 `s` 字符串是否正则匹配于 `p`，这道题和 [Wildcard Matching][044] 很是相似，区别在于 `*`，通配符的 `*` 是可以随意出现的，跟前面字符没有任何关系，其作用是可以表示任意字符串；而正则匹配的 `*` 不能单独存在，前面必须具有一个字符，其意义是表明前面的这个字符个数可以是任意个数，包括 0 个。首先我们用递归的方式来实现，其思路如下：
 
 * 如果 `s` 和 `p` 都为空，那么返回 `true`；
 

From 1fe9056834b617fa71d4cd826646078145536f5a Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Tue, 30 Jan 2018 02:20:21 +0800
Subject: [PATCH 31/58] add: 016

---
 README.md                                |  2 +
 note/016/README.md                       | 54 ++++++++++++++++++++++++
 src/com/blankj/medium/_016/Solution.java | 39 +++++++++++++++++
 3 files changed, 95 insertions(+)
 create mode 100644 note/016/README.md
 create mode 100644 src/com/blankj/medium/_016/Solution.java

diff --git a/README.md b/README.md
index 578508fb..7fb6c0f1 100644
--- a/README.md
+++ b/README.md
@@ -75,6 +75,7 @@
 | 11   | [Container With Most Water][011]         | Array, Two Pointers              |
 | 12   | [Integer to Roman][012]                  | Math, String                     |
 | 15   | [3Sum][015]                              | Array, Two Pointers              |
+| 15   | [3Sum Closest][016]                      | Array, Two Pointers              |
 | 17   | [Letter Combinations of a Phone Number][017] | String, Backtracking             |
 | 19   | [Remove Nth Node From End of List][019]  | Linked List, Two Pointers        |
 | 33   | [Search in Rotated Sorted Array][033]    | Arrays, Binary Search            |
@@ -146,6 +147,7 @@
 [011]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/011/README.md
 [012]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/012/README.md
 [015]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/015/README.md
+[016]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/016/README.md
 [017]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/017/README.md
 [019]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/019/README.md
 [033]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/033/README.md
diff --git a/note/016/README.md b/note/016/README.md
new file mode 100644
index 00000000..35e026ba
--- /dev/null
+++ b/note/016/README.md
@@ -0,0 +1,54 @@
+# [3Sum Closest][title]
+
+## Description
+
+Given an array *S* of *n* integers, find three integers in *S* such that the sum is closest to a given number, target. Return the sum of the three integers. You may assume that each input would have exactly one solution.
+
+```
+    For example, given array S = {-1 2 1 -4}, and target = 1.
+
+    The sum that is closest to the target is 2. (-1 + 2 + 1 = 2).
+```
+
+**Tags:** Array, Two Pointers
+
+
+## 思路
+
+这道题和 [3Sum][015] 的思路基本一样，先对数组进行排序，然后遍历这个排序数组，用两个指针分别指向当前元素的下一个和数组尾部，判断三者的和与 `target` 的差值来移动两个指针，并更新其结果，当然，如果三者的和直接与 `target` 值相同，那么返回 `target` 结果即可。
+
+```java
+public class Solution {
+    public int threeSumClosest(int[] nums, int target) {
+        int delta = 0x7fffffff, res = 0;
+        Arrays.sort(nums);
+        int len = nums.length - 2;
+        for (int i = 0; i < len; i++) {
+            int st = i + 1, end = nums.length - 1;
+            while (st < end) {
+                int sum = nums[i] + nums[st] + nums[end];
+                int curDelta = Math.abs(sum - target);
+                if (curDelta == 0) return sum;
+                if (curDelta < delta) {
+                    delta = curDelta;
+                    res = sum;
+                }
+                if (sum > target) --end;
+                else ++st;
+            }
+        }
+        return res;
+    }
+}
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
+
+
+
+[015]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/015/README.md
+[title]: https://leetcode.com/problems/3sum-closest
+[ajl]: https://github.com/Blankj/awesome-java-leetcode
diff --git a/src/com/blankj/medium/_016/Solution.java b/src/com/blankj/medium/_016/Solution.java
new file mode 100644
index 00000000..8bfce1d2
--- /dev/null
+++ b/src/com/blankj/medium/_016/Solution.java
@@ -0,0 +1,39 @@
+package com.blankj.medium._016;
+
+import java.util.Arrays;
+
+/**
+ * <pre>
+ *     author: Blankj
+ *     blog  : http://blankj.com
+ *     time  : 2018/01/25
+ *     desc  :
+ * </pre>
+ */
+public class Solution {
+    public int threeSumClosest(int[] nums, int target) {
+        int delta = 0x7fffffff, res = 0;
+        Arrays.sort(nums);
+        int len = nums.length - 2;
+        for (int i = 0; i < len; i++) {
+            int st = i + 1, end = nums.length - 1;
+            while (st < end) {
+                int sum = nums[i] + nums[st] + nums[end];
+                int curDelta = Math.abs(sum - target);
+                if (curDelta == 0) return sum;
+                if (curDelta < delta) {
+                    delta = curDelta;
+                    res = sum;
+                }
+                if (sum > target) --end;
+                else ++st;
+            }
+        }
+        return res;
+    }
+
+    public static void main(String[] args) {
+        Solution solution = new Solution();
+        System.out.println(solution.threeSumClosest(new int[]{-1, 2, 1, -4}, 1));
+    }
+}

From 37f50b9358217cf6a2fe0606e475059098f31957 Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Tue, 30 Jan 2018 11:35:45 +0800
Subject: [PATCH 32/58] update: 016

---
 note/016/README.md                       | 10 +++++-----
 src/com/blankj/medium/_016/Solution.java | 10 +++++-----
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/note/016/README.md b/note/016/README.md
index 35e026ba..f559cb6c 100644
--- a/note/016/README.md
+++ b/note/016/README.md
@@ -24,17 +24,17 @@ public class Solution {
         Arrays.sort(nums);
         int len = nums.length - 2;
         for (int i = 0; i < len; i++) {
-            int st = i + 1, end = nums.length - 1;
-            while (st < end) {
-                int sum = nums[i] + nums[st] + nums[end];
+            int left = i + 1, right = nums.length - 1;
+            while (left < right) {
+                int sum = nums[i] + nums[left] + nums[right];
                 int curDelta = Math.abs(sum - target);
                 if (curDelta == 0) return sum;
                 if (curDelta < delta) {
                     delta = curDelta;
                     res = sum;
                 }
-                if (sum > target) --end;
-                else ++st;
+                if (sum > target) --right;
+                else ++left;
             }
         }
         return res;
diff --git a/src/com/blankj/medium/_016/Solution.java b/src/com/blankj/medium/_016/Solution.java
index 8bfce1d2..9d9ce040 100644
--- a/src/com/blankj/medium/_016/Solution.java
+++ b/src/com/blankj/medium/_016/Solution.java
@@ -16,17 +16,17 @@ public int threeSumClosest(int[] nums, int target) {
         Arrays.sort(nums);
         int len = nums.length - 2;
         for (int i = 0; i < len; i++) {
-            int st = i + 1, end = nums.length - 1;
-            while (st < end) {
-                int sum = nums[i] + nums[st] + nums[end];
+            int left = i + 1, right = nums.length - 1;
+            while (left < right) {
+                int sum = nums[i] + nums[left] + nums[right];
                 int curDelta = Math.abs(sum - target);
                 if (curDelta == 0) return sum;
                 if (curDelta < delta) {
                     delta = curDelta;
                     res = sum;
                 }
-                if (sum > target) --end;
-                else ++st;
+                if (sum > target) --right;
+                else ++left;
             }
         }
         return res;

From 00e6bad10865661493fa1139e404ce90d4fd9e73 Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Tue, 30 Jan 2018 15:52:56 +0800
Subject: [PATCH 33/58] update: 015

---
 note/015/README.md                       | 25 +++++++++++++++---------
 src/com/blankj/medium/_015/Solution.java | 23 ++++++++++++++--------
 2 files changed, 31 insertions(+), 17 deletions(-)

diff --git a/note/015/README.md b/note/015/README.md
index fee1414b..a5be6bf3 100644
--- a/note/015/README.md
+++ b/note/015/README.md
@@ -21,27 +21,34 @@ A solution set is:
 
 ## 思路
 
-题意是让你从数组中找出所有三个和为 0 的元素构成的非重复序列，这样的话我们可以把数组先做下排序，然后遍历这个排序数组，用两个指针分别指向当前元素的下一个和数组尾部，判断三者的和与 0 的大小来移动两个指针，其中细节操作就是注意去重。
+题意是让你从数组中找出所有三个和为 0 的元素构成的非重复序列，这样的话我们可以把数组先做下排序，然后遍历这个排序数组，用两个指针分别指向当前元素的下一个和数组尾部，判断三者的和与 0 的大小来移动两个指针，其中细节操作就是优化和去重。
 
 ```java
 class Solution {
     public List<List<Integer>> threeSum(int[] nums) {
-        Arrays.sort(nums);
         List<List<Integer>> list = new ArrayList<>();
-        int i = 0;
-        while (i < nums.length - 2) {
+        int len = nums.length;
+        if (len < 3) return list;
+        Arrays.sort(nums);
+        int max = nums[len - 1];
+        if (max < 0) return list;
+        for (int i = 0; i < len - 2; ) {
             if (nums[i] > 0) break;
-            int left = i + 1, right = nums.length - 1;
+            if (nums[i] + 2 * max < 0) {
+                while (nums[i] == nums[++i] && i < len - 2) ;
+                continue;
+            }
+            int left = i + 1, right = len - 1;
             while (left < right) {
                 int sum = nums[i] + nums[left] + nums[right];
                 if (sum == 0) {
-                    list.add(Arrays.asList(nums[i], nums[left++], nums[right--]));
-                    while (left < right && nums[left] == nums[left - 1]) ++left;
-                    while (left < right && nums[right] == nums[right + 1]) --right;
+                    list.add(Arrays.asList(nums[i], nums[left], nums[right]));
+                    while (nums[left] == nums[++left] && left < right) ;
+                    while (nums[right] == nums[--right] && left < right) ;
                 } else if (sum < 0) ++left;
                 else --right;
             }
-            while (nums[i] == nums[++i] && i < nums.length - 2) ;
+            while (nums[i] == nums[++i] && i < len - 2) ;
         }
         return list;
     }
diff --git a/src/com/blankj/medium/_015/Solution.java b/src/com/blankj/medium/_015/Solution.java
index 33b79a46..b4af0e08 100644
--- a/src/com/blankj/medium/_015/Solution.java
+++ b/src/com/blankj/medium/_015/Solution.java
@@ -14,22 +14,29 @@
  */
 public class Solution {
     public List<List<Integer>> threeSum(int[] nums) {
-        Arrays.sort(nums);
         List<List<Integer>> list = new ArrayList<>();
-        int i = 0;
-        while (i < nums.length - 2) {
+        int len = nums.length;
+        if (len < 3) return list;
+        Arrays.sort(nums);
+        int max = nums[len - 1];
+        if (max < 0) return list;
+        for (int i = 0; i < len - 2; ) {
             if (nums[i] > 0) break;
-            int left = i + 1, right = nums.length - 1;
+            if (nums[i] + 2 * max < 0) {
+                while (nums[i] == nums[++i] && i < len - 2) ;
+                continue;
+            }
+            int left = i + 1, right = len - 1;
             while (left < right) {
                 int sum = nums[i] + nums[left] + nums[right];
                 if (sum == 0) {
-                    list.add(Arrays.asList(nums[i], nums[left++], nums[right--]));
-                    while (left < right && nums[left] == nums[left - 1]) ++left;
-                    while (left < right && nums[right] == nums[right + 1]) --right;
+                    list.add(Arrays.asList(nums[i], nums[left], nums[right]));
+                    while (nums[left] == nums[++left] && left < right) ;
+                    while (nums[right] == nums[--right] && left < right) ;
                 } else if (sum < 0) ++left;
                 else --right;
             }
-            while (nums[i] == nums[++i] && i < nums.length - 2) ;
+            while (nums[i] == nums[++i] && i < len - 2) ;
         }
         return list;
     }

From d818aad682f336c59392c0127b40ddb9f301c3fa Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Wed, 31 Jan 2018 01:56:19 +0800
Subject: [PATCH 34/58] add: 018

---
 README.md                                |   2 +
 note/018/README.md                       | 134 +++++++++++++++++++++++
 src/com/blankj/medium/_018/Solution.java | 105 ++++++++++++++++++
 3 files changed, 241 insertions(+)
 create mode 100644 note/018/README.md
 create mode 100644 src/com/blankj/medium/_018/Solution.java

diff --git a/README.md b/README.md
index 7fb6c0f1..1094cf16 100644
--- a/README.md
+++ b/README.md
@@ -77,6 +77,7 @@
 | 15   | [3Sum][015]                              | Array, Two Pointers              |
 | 15   | [3Sum Closest][016]                      | Array, Two Pointers              |
 | 17   | [Letter Combinations of a Phone Number][017] | String, Backtracking             |
+| 18   | [4Sum][018]                              | Array, Hash Table, Two Pointers  |
 | 19   | [Remove Nth Node From End of List][019]  | Linked List, Two Pointers        |
 | 33   | [Search in Rotated Sorted Array][033]    | Arrays, Binary Search            |
 | 43   | [Multiply Strings][043]                  | Math, String                     |
@@ -149,6 +150,7 @@
 [015]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/015/README.md
 [016]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/016/README.md
 [017]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/017/README.md
+[018]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/018/README.md
 [019]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/019/README.md
 [033]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/033/README.md
 [043]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/043/README.md
diff --git a/note/018/README.md b/note/018/README.md
new file mode 100644
index 00000000..f4d87ff2
--- /dev/null
+++ b/note/018/README.md
@@ -0,0 +1,134 @@
+# [4Sum][title]
+
+## Description
+
+Given an array *S* of *n* integers, are there elements *a*, *b*, *c*, and *d* in *S* such that *a* + *b* + *c* + *d* = target? Find all unique quadruplets in the array which gives the sum of target.
+
+**Note:** The solution set must not contain duplicate quadruplets.
+
+```
+For example, given array S = [1, 0, -1, 0, -2, 2], and target = 0.
+
+A solution set is:
+[
+  [-1,  0, 0, 1],
+  [-2, -1, 1, 2],
+  [-2,  0, 0, 2]
+]
+```
+
+**Tags:** Array, Hash Table, Two Pointers
+
+
+## 思路 0
+
+这道题和 [3Sum][015] 的思路基本一样，先对数组进行排序，然后遍历这个排序数组，因为这次是四个元素的和，所以外层需要两重循环，然后还是用两个指针分别指向当前元素的下一个和数组尾部，判断四者的和与 `target` 的大小来移动两个指针，其中细节操作还是优化和去重。
+
+```java
+class Solution {
+    public List<List<Integer>> fourSum(int[] nums, int target) {
+        List<List<Integer>> res = new ArrayList<>();
+        int len = nums.length;
+        if (len < 4) return res;
+        Arrays.sort(nums);
+        int max = nums[len - 1];
+        if (4 * max < target) return res;
+        for (int i = 0; i < len - 3;) {
+            if (nums[i] * 4 > target) break;
+            if (nums[i] + 3 * max < target) {
+                while (nums[i] == nums[++i] && i < len - 3) ;
+                continue;
+            }
+
+            for (int j = i + 1; j < len - 2;) {
+                int subSum = nums[i] + nums[j];
+                if (nums[i] + nums[j] * 3 > target) break;
+                if (subSum + 2 * max < target) {
+                    while (nums[j] == nums[++j] && j < len - 2) ;
+                    continue;
+                }
+
+                int left = j + 1, right = len - 1;
+                while (left < right) {
+                    int sum = subSum + nums[left] + nums[right];
+                    if (sum == target) {
+                        res.add(Arrays.asList(nums[i], nums[j], nums[left], nums[right]));
+                        while (nums[left] == nums[++left] && left < right);
+                        while (nums[right] == nums[--right] && left < right);
+                    } else if (sum < target) ++left;
+                    else --right;
+                }
+                while (nums[j] == nums[++j] && j < len - 2) ;
+            }
+            while (nums[i] == nums[++i] && i < len - 3) ;
+        }
+        return res;
+    }
+}
+```
+
+
+## 思路 1
+
+从 [Two Sum][001]、[3Sum][015] 到现在的 4Sum，其实都是把高阶降为低阶，那么我们就可以写出 kSum 的函数来对其进行降阶处理，降到 2Sum 后那么我们就可以对其进行最后的判断了，代码如下所示，也终也做了相应的优化和去重。
+
+```java
+class Solution {
+    public List<List<Integer>> fourSum(int[] nums, int target) {
+        Arrays.sort(nums);
+        int len = nums.length;
+        if (len < 4) return Collections.emptyList();
+        int max = nums[len - 1];
+        if (4 * max < target) return Collections.emptyList();
+        return kSum(nums, 0, 4, target);
+    }
+
+    private List<List<Integer>> kSum(int[] nums, int start, int k, int target) {
+        List<List<Integer>> res = new ArrayList<>();
+        if (k == 2) {
+            int left = start, right = nums.length - 1;
+            while (left < right) {
+                int sum = nums[left] + nums[right];
+                if (sum == target) {
+                    List<Integer> twoSum = new LinkedList<>();
+                    twoSum.add(nums[left]);
+                    twoSum.add(nums[right]);
+                    res.add(twoSum);
+                    while (nums[left] == nums[++left] && left < right) ;
+                    while (nums[right] == nums[--right] && left < right) ;
+                } else if (sum < target) ++left;
+                else --right;
+            }
+        } else {
+            int i = start, end = nums.length - (k - 1), max = nums[nums.length - 1];
+            while (i < end) {
+                if (nums[i] * k > target) return res;
+                if (nums[i] + (k - 1) * max < target) {
+                    while (nums[i] == nums[++i] && i < end) ;
+                    continue;
+                }
+                List<List<Integer>> temp = kSum(nums, i + 1, k - 1, target - nums[i]);
+                for (List<Integer> t : temp) {
+                    t.add(0, nums[i]);
+                }
+                res.addAll(temp);
+                while (nums[i] == nums[++i] && i < end) ;
+            }
+        }
+        return res;
+    }
+}
+```
+
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
+
+
+
+[001]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/001/README.md
+[015]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/015/README.md
+[title]: https://leetcode.com/problems/4sum
+[ajl]: https://github.com/Blankj/awesome-java-leetcode
diff --git a/src/com/blankj/medium/_018/Solution.java b/src/com/blankj/medium/_018/Solution.java
new file mode 100644
index 00000000..19886674
--- /dev/null
+++ b/src/com/blankj/medium/_018/Solution.java
@@ -0,0 +1,105 @@
+package com.blankj.medium._018;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * <pre>
+ *     author: Blankj
+ *     blog  : http://blankj.com
+ *     time  : 2018/01/30
+ *     desc  :
+ * </pre>
+ */
+public class Solution {
+//    public List<List<Integer>> fourSum(int[] nums, int target) {
+//        List<List<Integer>> res = new ArrayList<>();
+//        int len = nums.length;
+//        if (len < 4) return res;
+//        Arrays.sort(nums);
+//        int max = nums[len - 1];
+//        if (4 * max < target) return res;
+//        for (int i = 0; i < len - 3;) {
+//            if (nums[i] * 4 > target) break;
+//            if (nums[i] + 3 * max < target) {
+//                while (nums[i] == nums[++i] && i < len - 3) ;
+//                continue;
+//            }
+//
+//            for (int j = i + 1; j < len - 2;) {
+//                int subSum = nums[i] + nums[j];
+//                if (nums[i] + nums[j] * 3 > target) break;
+//                if (subSum + 2 * max < target) {
+//                    while (nums[j] == nums[++j] && j < len - 2) ;
+//                    continue;
+//                }
+//
+//                int left = j + 1, right = len - 1;
+//                while (left < right) {
+//                    int sum = subSum + nums[left] + nums[right];
+//                    if (sum == target) {
+//                        res.add(Arrays.asList(nums[i], nums[j], nums[left], nums[right]));
+//                        while (nums[left] == nums[++left] && left < right);
+//                        while (nums[right] == nums[--right] && left < right);
+//                    } else if (sum < target) ++left;
+//                    else --right;
+//                }
+//                while (nums[j] == nums[++j] && j < len - 2) ;
+//            }
+//            while (nums[i] == nums[++i] && i < len - 3) ;
+//        }
+//        return res;
+//    }
+
+    public List<List<Integer>> fourSum(int[] nums, int target) {
+        Arrays.sort(nums);
+        int len = nums.length;
+        if (len < 4) return Collections.emptyList();
+        int max = nums[len - 1];
+        if (4 * max < target) return Collections.emptyList();
+        return kSum(nums, 0, 4, target);
+    }
+
+    private List<List<Integer>> kSum(int[] nums, int start, int k, int target) {
+        List<List<Integer>> res = new ArrayList<>();
+        if (k == 2) {
+            int left = start, right = nums.length - 1;
+            while (left < right) {
+                int sum = nums[left] + nums[right];
+                if (sum == target) {
+                    List<Integer> twoSum = new LinkedList<>();
+                    twoSum.add(nums[left]);
+                    twoSum.add(nums[right]);
+                    res.add(twoSum);
+                    while (nums[left] == nums[++left] && left < right) ;
+                    while (nums[right] == nums[--right] && left < right) ;
+                } else if (sum < target) ++left;
+                else --right;
+            }
+        } else {
+            int i = start, end = nums.length - (k - 1), max = nums[nums.length - 1];
+            while (i < end) {
+                if (nums[i] * k > target) return res;
+                if (nums[i] + (k - 1) * max < target) {
+                    while (nums[i] == nums[++i] && i < end) ;
+                    continue;
+                }
+                List<List<Integer>> temp = kSum(nums, i + 1, k - 1, target - nums[i]);
+                for (List<Integer> t : temp) {
+                    t.add(0, nums[i]);
+                }
+                res.addAll(temp);
+                while (nums[i] == nums[++i] && i < end) ;
+            }
+        }
+        return res;
+    }
+
+    public static void main(String[] args) {
+        Solution solution = new Solution();
+        System.out.println(solution.fourSum(new int[]{1, 0, -1, 0, -2, 2}, 0));
+    }
+}

From 193374f654f67434ccc15efbbd6fa129989702f8 Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Wed, 31 Jan 2018 01:58:33 +0800
Subject: [PATCH 35/58] add: 018

---
 note/018/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/note/018/README.md b/note/018/README.md
index f4d87ff2..26011d2f 100644
--- a/note/018/README.md
+++ b/note/018/README.md
@@ -70,7 +70,7 @@ class Solution {
 
 ## 思路 1
 
-从 [Two Sum][001]、[3Sum][015] 到现在的 4Sum，其实都是把高阶降为低阶，那么我们就可以写出 kSum 的函数来对其进行降阶处理，降到 2Sum 后那么我们就可以对其进行最后的判断了，代码如下所示，也终也做了相应的优化和去重。
+从 [Two Sum][001]、[3Sum][015] 到现在的 4Sum，其实都是把高阶降为低阶，那么我们就可以写出 kSum 的函数来对其进行降阶处理，降到 2Sum 后那么我们就可以对其进行最后的判断了，代码如下所示，其也做了相应的优化和去重。
 
 ```java
 class Solution {

From 865cc7ee498d6bf1d2c7507031f31241308cd76e Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Wed, 31 Jan 2018 14:18:49 +0800
Subject: [PATCH 36/58] update: 016

---
 note/016/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/note/016/README.md b/note/016/README.md
index f559cb6c..6c6609e3 100644
--- a/note/016/README.md
+++ b/note/016/README.md
@@ -15,7 +15,7 @@ Given an array *S* of *n* integers, find three integers in *S* such that the sum
 
 ## 思路
 
-这道题和 [3Sum][015] 的思路基本一样，先对数组进行排序，然后遍历这个排序数组，用两个指针分别指向当前元素的下一个和数组尾部，判断三者的和与 `target` 的差值来移动两个指针，并更新其结果，当然，如果三者的和直接与 `target` 值相同，那么返回 `target` 结果即可。
+题意是让你从数组中找出最接近 `target` 的三个数的和，该题和 [3Sum][015] 的思路基本一样，先对数组进行排序，然后遍历这个排序数组，用两个指针分别指向当前元素的下一个和数组尾部，判断三者的和与 `target` 的差值来移动两个指针，并更新其结果，当然，如果三者的和直接与 `target` 值相同，那么返回 `target` 结果即可。
 
 ```java
 public class Solution {

From 134eb9b12ffcdc600e0b0dc0e6235bda7b862b3a Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Wed, 31 Jan 2018 14:21:38 +0800
Subject: [PATCH 37/58] update: 018

---
 note/018/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/note/018/README.md b/note/018/README.md
index 26011d2f..6b7c0834 100644
--- a/note/018/README.md
+++ b/note/018/README.md
@@ -22,7 +22,7 @@ A solution set is:
 
 ## 思路 0
 
-这道题和 [3Sum][015] 的思路基本一样，先对数组进行排序，然后遍历这个排序数组，因为这次是四个元素的和，所以外层需要两重循环，然后还是用两个指针分别指向当前元素的下一个和数组尾部，判断四者的和与 `target` 的大小来移动两个指针，其中细节操作还是优化和去重。
+题意是让你从数组中找出所有四个数的和为 `target` 的元素构成的非重复序列，该题和 [3Sum][015] 的思路基本一样，先对数组进行排序，然后遍历这个排序数组，因为这次是四个元素的和，所以外层需要两重循环，然后还是用两个指针分别指向当前元素的下一个和数组尾部，判断四者的和与 `target` 的大小来移动两个指针，其中细节操作还是优化和去重。
 
 ```java
 class Solution {

From 95cba23b727ebda41c98e44a0aaad08d8d438957 Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Wed, 31 Jan 2018 16:17:43 +0800
Subject: [PATCH 38/58] add: 022

---
 README.md                                |  2 +
 note/022/README.md                       | 94 ++++++++++++++++++++++++
 src/com/blankj/medium/_022/Solution.java | 53 +++++++++++++
 3 files changed, 149 insertions(+)
 create mode 100644 note/022/README.md
 create mode 100644 src/com/blankj/medium/_022/Solution.java

diff --git a/README.md b/README.md
index 1094cf16..cee96bb6 100644
--- a/README.md
+++ b/README.md
@@ -79,6 +79,7 @@
 | 17   | [Letter Combinations of a Phone Number][017] | String, Backtracking             |
 | 18   | [4Sum][018]                              | Array, Hash Table, Two Pointers  |
 | 19   | [Remove Nth Node From End of List][019]  | Linked List, Two Pointers        |
+| 22   | [Generate Parentheses][022]              | String, Backtracking             |
 | 33   | [Search in Rotated Sorted Array][033]    | Arrays, Binary Search            |
 | 43   | [Multiply Strings][043]                  | Math, String                     |
 | 49   | [Group Anagrams][049]                    | Hash Table, String               |
@@ -152,6 +153,7 @@
 [017]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/017/README.md
 [018]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/018/README.md
 [019]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/019/README.md
+[022]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/022/README.md
 [033]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/033/README.md
 [043]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/043/README.md
 [049]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/049/README.md
diff --git a/note/022/README.md b/note/022/README.md
new file mode 100644
index 00000000..ea8a8c59
--- /dev/null
+++ b/note/022/README.md
@@ -0,0 +1,94 @@
+# [Generate Parentheses][title]
+
+## Description
+
+Given *n* pairs of parentheses, write a function to generate all combinations of well-formed parentheses.
+
+For example, given *n* = 3, a solution set is:
+
+```
+[
+  "((()))",
+  "(()())",
+  "(())()",
+  "()(())",
+  "()()()"
+]
+```
+
+**Tags:** String, Backtracking
+
+
+## 思路 0
+
+题意是给你 `n` 值，让你找到所有格式正确的圆括号匹配组，题目中已经给出了 `n = 3` 的所有结果。遇到这种问题，第一直觉就是用到递归或者堆栈，我们选取递归来解决，也就是 `helper` 函数的功能，从参数上来看肯定很好理解了，`leftRest` 代表还有几个左括号可以用，`rightNeed` 代表还需要几个右括号才能匹配，初始状态当然是 `rightNeed = 0, leftRest = n`，递归的终止状态就是 `rightNeed == 0 && leftRest == 0`，也就是左右括号都已匹配完毕，然后把 `str` 加入到链表中即可。
+
+```java
+class Solution {
+    public List<String> generateParenthesis(int n) {
+        List<String> list = new ArrayList<>();
+        helper(list, "", 0, n);
+        return list;
+    }
+
+    private void helper(List<String> list, String str, int rightNeed, int leftRest) {
+        if (rightNeed == 0 && leftRest == 0) {
+            list.add(str);
+            return;
+        }
+        if (rightNeed > 0) helper(list, str + ")", rightNeed - 1, leftRest);
+        if (leftRest > 0) helper(list, str + "(", rightNeed + 1, leftRest - 1);
+    }
+}
+```
+
+
+## 思路 1
+
+另一种实现方式就是迭代的思想了，我们来找寻其规律如下所示：
+
+```
+f(0): “”
+
+f(1): “(“f(0)”)”
+
+f(2): "(“f(0)”)"f(1), “(“f(1)”)”
+
+f(3): "(“f(0)”)"f(2), "(“f(1)”)"f(1), “(“f(2)”)”
+...
+```
+
+可以递推出 `f(n) = "(“f(0)”)"f(n-1) , "(“f(1)”)"f(n-2) "(“f(2)”)"f(n-3) … "(“f(i)”)“f(n-1-i) … “(f(n-1)”)”`
+
+根据如上递推式写出如下代码应该不难了吧。
+
+```java
+class Solution {
+    public List<String> generateParenthesis(int n) {
+        HashMap<Integer, List<String>> hashMap = new HashMap<>();
+        hashMap.put(0, Collections.singletonList(""));
+        for (int i = 1; i <= n; i++) {
+            List<String> list = new ArrayList<>();
+            for (int j = 0; j < i; j++) {
+                for (String fj : hashMap.get(j)) {
+                    for (String fi_j_1 : hashMap.get(i - j - 1)) {
+                        list.add("(" + fj + ")" + fi_j_1);// calculate f(i)
+                    }
+                }
+            }
+            hashMap.put(i, list);
+        }
+        return hashMap.get(n);
+    }
+}
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
+
+
+
+[title]: https://leetcode.com/problems/generate-parentheses
+[ajl]: https://github.com/Blankj/awesome-java-leetcode
diff --git a/src/com/blankj/medium/_022/Solution.java b/src/com/blankj/medium/_022/Solution.java
new file mode 100644
index 00000000..fe47c46d
--- /dev/null
+++ b/src/com/blankj/medium/_022/Solution.java
@@ -0,0 +1,53 @@
+package com.blankj.medium._022;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+
+/**
+ * <pre>
+ *     author: Blankj
+ *     blog  : http://blankj.com
+ *     time  : 2018/01/30
+ *     desc  :
+ * </pre>
+ */
+public class Solution {
+//    public List<String> generateParenthesis(int n) {
+//        List<String> list = new ArrayList<>();
+//        helper(list, "", 0, n);
+//        return list;
+//    }
+//
+//    private void helper(List<String> list, String str, int rightNeed, int leftRest) {
+//        if (rightNeed == 0 && leftRest == 0) {
+//            list.add(str);
+//            return;
+//        }
+//        if (rightNeed > 0) helper(list, str + ")", rightNeed - 1, leftRest);
+//        if (leftRest > 0) helper(list, str + "(", rightNeed + 1, leftRest - 1);
+//    }
+
+    public List<String> generateParenthesis(int n) {
+        HashMap<Integer, List<String>> hashMap = new HashMap<>();
+        hashMap.put(0, Collections.singletonList(""));
+        for (int i = 1; i <= n; i++) {
+            List<String> list = new ArrayList<>();
+            for (int j = 0; j < i; j++) {
+                for (String fj : hashMap.get(j)) {
+                    for (String fi_j_1 : hashMap.get(i - j - 1)) {
+                        list.add("(" + fj + ")" + fi_j_1);// calculate f(i)
+                    }
+                }
+            }
+            hashMap.put(i, list);
+        }
+        return hashMap.get(n);
+    }
+
+    public static void main(String[] args) {
+        Solution solution = new Solution();
+        System.out.println(solution.generateParenthesis(3));
+    }
+}

From f70ee470102c7f3b565ecd103338531f1921c74c Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Wed, 31 Jan 2018 17:54:43 +0800
Subject: [PATCH 39/58] add: 024

---
 README.md                                |  2 +
 note/024/README.md                       | 77 ++++++++++++++++++++++++
 src/com/blankj/medium/_024/Solution.java | 39 ++++++++++++
 3 files changed, 118 insertions(+)
 create mode 100644 note/024/README.md
 create mode 100644 src/com/blankj/medium/_024/Solution.java

diff --git a/README.md b/README.md
index cee96bb6..78273a5a 100644
--- a/README.md
+++ b/README.md
@@ -80,6 +80,7 @@
 | 18   | [4Sum][018]                              | Array, Hash Table, Two Pointers  |
 | 19   | [Remove Nth Node From End of List][019]  | Linked List, Two Pointers        |
 | 22   | [Generate Parentheses][022]              | String, Backtracking             |
+| 24   | [Swap Nodes in Pairs][024]               | Linked List                      |
 | 33   | [Search in Rotated Sorted Array][033]    | Arrays, Binary Search            |
 | 43   | [Multiply Strings][043]                  | Math, String                     |
 | 49   | [Group Anagrams][049]                    | Hash Table, String               |
@@ -154,6 +155,7 @@
 [018]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/018/README.md
 [019]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/019/README.md
 [022]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/022/README.md
+[024]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/024/README.md
 [033]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/033/README.md
 [043]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/043/README.md
 [049]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/049/README.md
diff --git a/note/024/README.md b/note/024/README.md
new file mode 100644
index 00000000..330f2276
--- /dev/null
+++ b/note/024/README.md
@@ -0,0 +1,77 @@
+# [Swap Nodes in Pairs][title]
+
+## Description
+
+Given a linked list, swap every two adjacent nodes and return its head.
+
+For example,
+Given `1->2->3->4`, you should return the list as `2->1->4->3`.
+
+Your algorithm should use only constant space. You may **not** modify the values in the list, only nodes itself can be changed.
+
+**Tags:** Linked List
+
+
+## 思路 0
+
+题意是让你交换链表中相邻的两个节点，最终返回交换后链表的头，限定你空间复杂度为 O(1)。我们可以用递归来算出子集合的结果，递归的终点就是指针指到链表末少于两个元素时，如果不是终点，那么我们就对其两节点进行交换，这里我们需要一个临时节点来作为交换桥梁，就不多说了。
+
+```java
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public ListNode swapPairs(ListNode head) {
+        if (head == null || head.next == null) return head;
+        ListNode node = head.next;
+        head.next = swapPairs(node.next);
+        node.next = head;
+        return node;
+    }
+}
+```
+
+
+## 思路 1
+
+另一种实现方式就是用循环来实现了，两两交换节点，也需要一个临时节点来作为交换桥梁，直到当前指针指到链表末少于两个元素时停止，代码很简单，如下所示。
+
+```java
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public ListNode swapPairs(ListNode head) {
+        ListNode preHead = new ListNode(0), cur = preHead;
+        preHead.next = head;
+        while (cur.next != null && cur.next.next != null) {
+            ListNode temp = cur.next.next;
+            cur.next.next = temp.next;
+            temp.next = cur.next;
+            cur.next = temp;
+            cur = cur.next.next;
+        }
+        return preHead.next;
+    }
+}
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
+
+
+
+[title]: https://leetcode.com/problems/swap-nodes-in-pairs
+[ajl]: https://github.com/Blankj/awesome-java-leetcode
diff --git a/src/com/blankj/medium/_024/Solution.java b/src/com/blankj/medium/_024/Solution.java
new file mode 100644
index 00000000..77f7e44c
--- /dev/null
+++ b/src/com/blankj/medium/_024/Solution.java
@@ -0,0 +1,39 @@
+package com.blankj.medium._024;
+
+import com.blankj.structure.ListNode;
+
+/**
+ * <pre>
+ *     author: Blankj
+ *     blog  : http://blankj.com
+ *     time  : 2018/01/31
+ *     desc  :
+ * </pre>
+ */
+public class Solution {
+//    public ListNode swapPairs(ListNode head) {
+//        if (head == null || head.next == null) return head;
+//        ListNode node = head.next;
+//        head.next = swapPairs(node.next);
+//        node.next = head;
+//        return node;
+//    }
+
+    public ListNode swapPairs(ListNode head) {
+        ListNode preHead = new ListNode(0), cur = preHead;
+        preHead.next = head;
+        while (cur.next != null && cur.next.next != null) {
+            ListNode temp = cur.next.next;
+            cur.next.next = temp.next;
+            temp.next = cur.next;
+            cur.next = temp;
+            cur = cur.next.next;
+        }
+        return preHead.next;
+    }
+
+    public static void main(String[] args) {
+        Solution solution = new Solution();
+        ListNode.print(solution.swapPairs(ListNode.createTestData("[1,2,3,4]")));
+    }
+}

From c248a807af48bf3ed8ca5e1f78821c150c3aafce Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Fri, 2 Feb 2018 01:42:07 +0800
Subject: [PATCH 40/58] add: 029

---
 README.md                                |  2 +
 note/029/README.md                       | 51 ++++++++++++++++++++++++
 src/com/blankj/medium/_029/Solution.java | 35 ++++++++++++++++
 3 files changed, 88 insertions(+)
 create mode 100644 note/029/README.md
 create mode 100644 src/com/blankj/medium/_029/Solution.java

diff --git a/README.md b/README.md
index 78273a5a..99999aad 100644
--- a/README.md
+++ b/README.md
@@ -81,6 +81,7 @@
 | 19   | [Remove Nth Node From End of List][019]  | Linked List, Two Pointers        |
 | 22   | [Generate Parentheses][022]              | String, Backtracking             |
 | 24   | [Swap Nodes in Pairs][024]               | Linked List                      |
+| 29   | [Divide Two Integers][029]               | Math, Binary Search              |
 | 33   | [Search in Rotated Sorted Array][033]    | Arrays, Binary Search            |
 | 43   | [Multiply Strings][043]                  | Math, String                     |
 | 49   | [Group Anagrams][049]                    | Hash Table, String               |
@@ -156,6 +157,7 @@
 [019]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/019/README.md
 [022]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/022/README.md
 [024]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/024/README.md
+[029]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/029/README.md
 [033]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/033/README.md
 [043]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/043/README.md
 [049]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/049/README.md
diff --git a/note/029/README.md b/note/029/README.md
new file mode 100644
index 00000000..a6c6c8c0
--- /dev/null
+++ b/note/029/README.md
@@ -0,0 +1,51 @@
+# [Divide Two Integers][title]
+
+## Description
+
+Divide two integers without using multiplication, division and mod operator.
+
+If it is overflow, return MAX_INT.
+
+**Tags:** Math, Binary Search
+
+
+## 思路
+
+题意是让你算两个整型数相除后的结果，如果结果溢出就返回 `MAX_INT`，但不能使用乘、除、余的操作符，如果是用加减操作符的话肯定会超时哈，这样的话我们就只能想到位操作符了。
+
+首先，我们分析下溢出的情况，也就是当被除数为 `Integer.MIN_VALUE`，除数为 `-1` 时会溢出，因为 `|Integer.MIN_VALUE| = Integer.MAX_VALUE + 1`。
+
+然后，我们把除数和被除数都转为 `long` 类型的正数去做下一步操作，我这里以 `22` 和 `3` 相除为例子，因为 `22 >= 3`，我们对 `3` 进行左移一位，也就是乘 2，结果为 `6`，比 `22` 小，我们继续对 `6` 左移一位结果为 `12`，还是比 `22` 小，我们继续对 `12` 左移一位为 `24`，比 `22` 大，这时我们可以分析出，`22` 肯定比 `3` 的 `4` 倍要大，`4` 是怎么来的？因为我们左移了两次，也就是 `1 << 2 = 4`，此时我们记下这个 `4`，然后让 `22 - 3 * 4 = 10`，因为 `10 >= 3`，对 `10` 和 `3` 进行同样的操作，我们可以得到 `2`，此时加上上次的 `4`，和为 `6`，也就是 `22` 比 `3` 的 `6` 倍要大，此时还剩余 `10 - 6 = 4`，因为 `4 >= 3`，所以对 `4` 和 `3` 进行同样的操作，我们发现并不能对 `3` 进行左移了，因为 `4 >= 3`，所以 `1` 倍还是有的，所以加上最后的 `1`，结果为 `6 + 1 = 7`，也就是 `22` 整除 `3` 结果为 `7`，根据以上思路来书写如下代码应该不是难事了吧。
+
+```java
+class Solution {
+    public int divide(int dividend, int divisor) {
+        if (dividend == Integer.MIN_VALUE && divisor == -1) {
+            return Integer.MAX_VALUE;
+        }
+        long dvd = Math.abs((long) dividend);
+        long dvr = Math.abs((long) divisor);
+        int res = 0;
+        while (dvd >= dvr) {
+            long temp = dvr, multiple = 1;
+            while (dvd >= temp << 1) {
+                temp <<= 1;
+                multiple <<= 1;
+            }
+            dvd -= temp;
+            res += multiple;
+        }
+        return (dividend < 0) ^ (divisor < 0) ? -res : res;
+    }
+}
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
+
+
+
+[title]: https://leetcode.com/problems/divide-two-integers
+[ajl]: https://github.com/Blankj/awesome-java-leetcode
diff --git a/src/com/blankj/medium/_029/Solution.java b/src/com/blankj/medium/_029/Solution.java
new file mode 100644
index 00000000..2802ace9
--- /dev/null
+++ b/src/com/blankj/medium/_029/Solution.java
@@ -0,0 +1,35 @@
+package com.blankj.medium._029;
+
+/**
+ * <pre>
+ *     author: Blankj
+ *     blog  : http://blankj.com
+ *     time  : 2018/01/31
+ *     desc  :
+ * </pre>
+ */
+public class Solution {
+    public int divide(int dividend, int divisor) {
+        if (dividend == Integer.MIN_VALUE && divisor == -1) {
+            return Integer.MAX_VALUE;
+        }
+        long dvd = Math.abs((long) dividend);
+        long dvr = Math.abs((long) divisor);
+        int res = 0;
+        while (dvd >= dvr) {
+            long temp = dvr, multiple = 1;
+            while (dvd >= temp << 1) {
+                temp <<= 1;
+                multiple <<= 1;
+            }
+            dvd -= temp;
+            res += multiple;
+        }
+        return (dividend < 0) ^ (divisor < 0) ? -res : res;
+    }
+
+    public static void main(String[] args) {
+        Solution solution = new Solution();
+        System.out.println(solution.divide(-2147483648, 1));
+    }
+}

From 0f8c08cfc64acb80484fb0d10f2d4d19ac26075a Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Fri, 2 Feb 2018 01:47:57 +0800
Subject: [PATCH 41/58] add: 029

---
 note/029/README.md | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/note/029/README.md b/note/029/README.md
index a6c6c8c0..d402cd0d 100644
--- a/note/029/README.md
+++ b/note/029/README.md
@@ -15,7 +15,9 @@ If it is overflow, return MAX_INT.
 
 首先，我们分析下溢出的情况，也就是当被除数为 `Integer.MIN_VALUE`，除数为 `-1` 时会溢出，因为 `|Integer.MIN_VALUE| = Integer.MAX_VALUE + 1`。
 
-然后，我们把除数和被除数都转为 `long` 类型的正数去做下一步操作，我这里以 `22` 和 `3` 相除为例子，因为 `22 >= 3`，我们对 `3` 进行左移一位，也就是乘 2，结果为 `6`，比 `22` 小，我们继续对 `6` 左移一位结果为 `12`，还是比 `22` 小，我们继续对 `12` 左移一位为 `24`，比 `22` 大，这时我们可以分析出，`22` 肯定比 `3` 的 `4` 倍要大，`4` 是怎么来的？因为我们左移了两次，也就是 `1 << 2 = 4`，此时我们记下这个 `4`，然后让 `22 - 3 * 4 = 10`，因为 `10 >= 3`，对 `10` 和 `3` 进行同样的操作，我们可以得到 `2`，此时加上上次的 `4`，和为 `6`，也就是 `22` 比 `3` 的 `6` 倍要大，此时还剩余 `10 - 6 = 4`，因为 `4 >= 3`，所以对 `4` 和 `3` 进行同样的操作，我们发现并不能对 `3` 进行左移了，因为 `4 >= 3`，所以 `1` 倍还是有的，所以加上最后的 `1`，结果为 `6 + 1 = 7`，也就是 `22` 整除 `3` 结果为 `7`，根据以上思路来书写如下代码应该不是难事了吧。
+然后，我们把除数和被除数都转为 `long` 类型的正数去做下一步操作，我这里以 `22` 和 `3` 相除为例子，因为 `22 >= 3`，我们对 `3` 进行左移一位，也就是乘 2，结果为 `6`，比 `22` 小，我们继续对 `6` 左移一位结果为 `12`，还是比 `22` 小，我们继续对 `12` 左移一位为 `24`，比 `22` 大，这时我们可以分析出，`22` 肯定比 `3` 的 `4` 倍要大，`4` 是怎么来的？因为我们左移了两次，也就是 `1 << 2 = 4`，此时我们记下这个 `4`，然后让 `22 - 3 * 4 = 10`，因为 `10 >= 3`，对 `10` 和 `3` 进行同样的操作，我们可以得到 `2`，此时加上上次的 `4`，和为 `6`，也就是 `22` 比 `3` 的 `6` 倍要大，此时还剩余 `10 - 6 = 4`，因为 `4 >= 3`，所以对 `4` 和 `3` 进行同样的操作，我们发现并不能对 `3` 进行左移了，因为 `4 >= 3`，所以 `1` 倍还是有的，所以加上最后的 `1`，结果为 `6 + 1 = 7`，也就是 `22` 整除 `3` 结果为 `7`。
+
+最终，我们对结果赋予符号位即可，根据以上思路来书写如下代码应该不是难事了吧。
 
 ```java
 class Solution {

From 8a4378d3418fa24731186fee50a97e310de1b551 Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Tue, 6 Mar 2018 11:48:41 +0800
Subject: [PATCH 42/58] update: 028

---
 note/028/README.md                     | 4 ++--
 src/com/blankj/easy/_028/Solution.java | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/note/028/README.md b/note/028/README.md
index 8cfa67bc..aedd11eb 100644
--- a/note/028/README.md
+++ b/note/028/README.md
@@ -25,7 +25,7 @@ Tags:** Two Pointers, String
 
 ## 思路
 
-题意是从主串中找到子串的索引，如果找不到则返回-1，当字串长度大于主串，直接返回-1，然后我们只需要遍历比较即可。
+题意是从主串中找到子串的索引，如果找不到则返回-1，当子串长度大于主串，直接返回-1，然后我们只需要遍历比较即可。
 
 ```java
 class Solution {
@@ -33,9 +33,9 @@ class Solution {
         int l1 = haystack.length(), l2 = needle.length();
         if (l1 < l2) return -1;
         for (int i = 0; ; i++) {
+            if (i + l2 > l1) return -1;
             for (int j = 0; ; j++) {
                 if (j == l2) return i;
-                if (i + j == l1) return -1;
                 if (haystack.charAt(i + j) != needle.charAt(j)) break;
             }
         }
diff --git a/src/com/blankj/easy/_028/Solution.java b/src/com/blankj/easy/_028/Solution.java
index 25699215..246ba868 100644
--- a/src/com/blankj/easy/_028/Solution.java
+++ b/src/com/blankj/easy/_028/Solution.java
@@ -13,9 +13,9 @@ public int strStr(String haystack, String needle) {
         int l1 = haystack.length(), l2 = needle.length();
         if (l1 < l2) return -1;
         for (int i = 0; ; i++) {
+            if (i + l2 > l1) return -1;
             for (int j = 0; ; j++) {
                 if (j == l2) return i;
-                if (i + j == l1) return -1;
                 if (haystack.charAt(i + j) != needle.charAt(j)) break;
             }
         }

From 7100e36c6edc4fbce1147e52e74743c84414298d Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Thu, 15 Mar 2018 17:39:07 +0800
Subject: [PATCH 43/58] add: 030

---
 README.md                              |  20 +++--
 note/030/README.md                     |  37 ++++++++
 src/com/blankj/hard/_030/Solution.java | 118 +++++++++++++++++++++++++
 3 files changed, 166 insertions(+), 9 deletions(-)
 create mode 100644 note/030/README.md
 create mode 100644 src/com/blankj/hard/_030/Solution.java

diff --git a/README.md b/README.md
index 99999aad..abcf3514 100644
--- a/README.md
+++ b/README.md
@@ -92,15 +92,16 @@
 
 ## Hard
 
-| #    | Title                              | Tag                                      |
-| :--- | :--------------------------------- | :--------------------------------------- |
-| 4    | [Median of Two Sorted Arrays][004] | Array, Binary Search, Divide and Conquer |
-| 10   | [Regular Expression Matching][010] | String, Dynamic Programming, Backtracking |
-| 23   | [Merge k Sorted Lists][023]        | Linked List, Divide and Conquer, Heap    |
-| 25   | [Reverse Nodes in k-Group][025]    | Linked List                              |
-| 44   | [Wildcard Matching][044]           | String, Dynamic Programming, Backtracking, Greedy |
-| 57   | [Insert Interval][057]             | Array, Sort                              |
-| 68   | [Text Justification][068]          | String                                   |
+| #    | Title                                    | Tag                                      |
+| :--- | :--------------------------------------- | :--------------------------------------- |
+| 4    | [Median of Two Sorted Arrays][004]       | Array, Binary Search, Divide and Conquer |
+| 10   | [Regular Expression Matching][010]       | String, Dynamic Programming, Backtracking |
+| 23   | [Merge k Sorted Lists][023]              | Linked List, Divide and Conquer, Heap    |
+| 25   | [Reverse Nodes in k-Group][025]          | Linked List                              |
+| 30   | [Substring with Concatenation of All Words][030] | Hash Table, Two Pointers, String         |
+| 44   | [Wildcard Matching][044]                 | String, Dynamic Programming, Backtracking, Greedy |
+| 57   | [Insert Interval][057]                   | Array, Sort                              |
+| 68   | [Text Justification][068]                | String                                   |
 
 
 
@@ -169,6 +170,7 @@
 [010]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/010/README.md
 [023]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/023/README.md
 [025]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/025/README.md
+[030]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/030/README.md
 [044]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/044/README.md
 [057]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/057/README.md
 [068]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/068/README.md
diff --git a/note/030/README.md b/note/030/README.md
new file mode 100644
index 00000000..e18c1b0f
--- /dev/null
+++ b/note/030/README.md
@@ -0,0 +1,37 @@
+# [Substring with Concatenation of All Words][title]
+
+## Description
+
+You are given a string, **s**, and a list of words, **words**, that are all of the same length. Find all starting indices of substring(s) in **s** that is a concatenation of each word in **words** exactly once and without any intervening characters.
+
+
+For example, given:
+
+**s**: `"barfoothefoobarman"`
+
+**words**: `["foo", "bar"]`
+
+You should return the indices: `[0,9]`.
+
+(order does not matter).
+
+**Tags:** Hash Table, Two Pointers, String
+
+
+## 思路
+
+题意是
+
+```java
+
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
+
+
+
+[title]: https://leetcode.com/problems/substring-with-concatenation-of-all-words
+[ajl]: https://github.com/Blankj/awesome-java-leetcode
diff --git a/src/com/blankj/hard/_030/Solution.java b/src/com/blankj/hard/_030/Solution.java
new file mode 100644
index 00000000..faa50379
--- /dev/null
+++ b/src/com/blankj/hard/_030/Solution.java
@@ -0,0 +1,118 @@
+package com.blankj.hard._030;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * <pre>
+ *     author: Blankj
+ *     blog  : http://blankj.com
+ *     time  : 2018/02/01
+ *     desc  :
+ * </pre>
+ */
+public class Solution {
+    public List<Integer> findSubstring(String s, String[] words) {
+        int wordsSize = words.length, wordLen = words[0].length(), end = s.length() - wordsSize * wordLen;
+        if (end < 0) return Collections.emptyList();
+        Map<String, Integer> countMap = new HashMap<>();
+        for (String word : words) {
+            countMap.put(word, countMap.getOrDefault(word, 0) + 1);
+        }
+        List<Integer> res = new ArrayList<>();
+        Set<Integer> ignores = new HashSet<>();
+        for (int i = 0; i <= end; ++i) {
+            if (ignores.contains(i)) continue;
+            Map<String, Integer> findMap = new HashMap<>();
+            int st = i, count = 0;
+            List<Integer> ignore = new ArrayList<>();
+            for (int j = 0; ; ++j) {
+                int cur = i + j * wordLen;
+                if (cur + wordLen > s.length()) break;
+                String word = s.substring(cur, cur + wordLen);
+                if (countMap.containsKey(word)) {
+                    findMap.put(word, findMap.getOrDefault(word, 0) + 1);
+                    ++count;
+                    while (findMap.get(word) > countMap.get(word)) {
+                        ignore.add(st);
+                        String tmp = s.substring(st, st += wordLen);
+                        findMap.put(tmp, findMap.get(tmp) - 1);
+                        --count;
+                    }
+                    if (count == wordsSize) {
+                        ignore.add(st);
+                        res.add(st);
+                        String tmp = s.substring(st, st += wordLen);
+                        findMap.put(tmp, findMap.get(tmp) - 1);
+                        --count;
+                    }
+                } else {
+                    for (int k = i; k <= cur; k += wordLen) {
+                        ignore.add(k);
+                    }
+                    break;
+                }
+            }
+            ignores.addAll(ignore);
+        }
+        return res;
+    }
+
+//    public List<Integer> findSubstring(String S, String[] L) {
+//        List<Integer> res = new LinkedList<>();
+//        int N = S.length();
+//        int M = L.length; // *** length
+//        int wl = L[0].length();
+//        Map<String, Integer> map = new HashMap<>(), curMap = new HashMap<>();
+//        for (String s : L) {
+//            if (map.containsKey(s)) map.put(s, map.get(s) + 1);
+//            else map.put(s, 1);
+//        }
+//        String str = null, tmp = null;
+//        for (int i = 0; i < wl; i++) {
+//            int count = 0;  // remark: reset count
+//            int start = i;
+//            for (int r = i; r + wl <= N; r += wl) {
+//                str = S.substring(r, r + wl);
+//                if (map.containsKey(str)) {
+//                    if (curMap.containsKey(str)) curMap.put(str, curMap.get(str) + 1);
+//                    else curMap.put(str, 1);
+//
+//                    if (curMap.get(str) <= map.get(str)) count++;
+//                    if (count == M) {
+//                        res.add(start);
+//                        tmp = S.substring(start, start + wl);
+//                        curMap.put(tmp, curMap.get(tmp) - 1);
+//                        start += wl;
+//                        count--;
+//                    }
+//                    while (curMap.get(str) > map.get(str)) {
+//                        tmp = S.substring(start, start + wl);
+//                        curMap.put(tmp, curMap.get(tmp) - 1);
+//                        start += wl;
+//                        if (curMap.get(tmp) < map.get(tmp)) count--;
+//
+//                    }
+//                } else {
+//                    curMap.clear();
+//                    count = 0;
+//                    start = r + wl;
+//                }
+//            }
+//            curMap.clear();
+//        }
+//        return res;
+//    }
+
+    public static void main(String[] args) {
+        Solution solution = new Solution();
+        System.out.println(solution.findSubstring("wordgoodgoodgoodbestword", new String[]{"word", "good", "best", "good"}));
+        System.out.println(solution.findSubstring("barfoothefoobarman", new String[]{"foo", "bar"}));
+        System.out.println(solution.findSubstring("barfoofoobarthefoobarman", new String[]{"bar", "foo", "the"}));
+    }
+}

From ce9f06b66cc12ac1855813864e85afa1982a8eea Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Thu, 17 May 2018 11:40:08 +0800
Subject: [PATCH 44/58] =?UTF-8?q?fix:=20=E6=9B=B4=E6=96=B0=E9=A2=98?=
 =?UTF-8?q?=E7=9B=AE?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 README.md                                |  2 +-
 note/005/README.md                       |  6 +--
 note/006/README.md                       | 22 +++++++-
 note/008/README.md                       | 66 +++++++++++++++++++-----
 note/009/README.md                       | 29 ++++++++---
 note/010/README.md                       | 66 +++++++++++++++++++-----
 note/012/README.md                       | 60 ++++++++++++++++++++-
 note/013/README.md                       | 60 ++++++++++++++++++++-
 note/014/README.md                       | 21 ++++++++
 note/015/README.md                       | 10 ++--
 note/016/README.md                       |  8 +--
 note/017/README.md                       |  4 +-
 note/018/README.md                       | 10 ++--
 note/019/README.md                       | 12 +++--
 note/020/README.md                       | 42 ++++++++++++++-
 note/023/README.md                       | 12 +++++
 note/024/README.md                       | 12 +++--
 note/025/README.md                       | 10 ++--
 note/026/README.md                       | 38 ++++++++++++--
 note/027/README.md                       | 39 ++++++++++++--
 note/028/README.md                       |  6 +++
 note/029/README.md                       | 26 +++++++++-
 note/030/README.md                       | 23 ++++++---
 note/033/README.md                       | 20 ++++++-
 note/043/README.md                       | 23 ++++++---
 note/044/README.md                       | 66 +++++++++++++++++++-----
 note/049/README.md                       | 13 +++--
 note/050/README.md                       | 15 +++++-
 note/053/README.md                       | 12 +++--
 note/056/README.md                       | 16 ++++--
 note/057/README.md                       | 13 +++--
 note/066/README.md                       | 22 ++++++--
 note/067/README.md                       | 16 ++++--
 note/068/README.md                       | 56 +++++++++++++++-----
 note/069/README.md                       |  7 +--
 note/070/README.md                       | 10 ++--
 note/083/README.md                       | 14 +++--
 note/088/README.md                       | 13 ++++-
 note/104/README.md                       | 16 ++++++
 note/110/README.md                       | 33 +++++++++++-
 note/111/README.md                       | 16 ++++++
 note/112/README.md                       | 18 ++++---
 note/118/README.md                       |  9 ++--
 note/119/README.md                       | 16 ++++--
 note/121/README.md                       | 15 +++---
 note/122/README.md                       | 31 ++++++++++-
 note/543/README.md                       |  4 +-
 src/com/blankj/medium/_008/Solution.java | 12 +++--
 48 files changed, 888 insertions(+), 182 deletions(-)

diff --git a/README.md b/README.md
index abcf3514..d7110968 100644
--- a/README.md
+++ b/README.md
@@ -69,7 +69,7 @@
 | :--- | :--------------------------------------- | :------------------------------- |
 | 2    | [Add Two Numbers][002]                   | Linked List, Math                |
 | 3    | [Longest Substring Without Repeating Characters][003] | Hash Table, Two Pointers, String |
-| 5    | [Longest Palindromic Substring][005]     | String                           |
+| 5    | [Longest Palindromic Substring][005]     | String, Dynamic Programming      |
 | 6    | [ZigZag Conversion][006]                 | String                           |
 | 8    | [String to Integer (atoi)][008]          | Math, String                     |
 | 11   | [Container With Most Water][011]         | Array, Two Pointers              |
diff --git a/note/005/README.md b/note/005/README.md
index cd3bc6c3..fb74d65b 100644
--- a/note/005/README.md
+++ b/note/005/README.md
@@ -4,7 +4,7 @@
 
 Given a string **s**, find the longest palindromic substring in **s**. You may assume that the maximum length of **s** is 1000.
 
-**Example:**
+**Example 1:**
 
 ```
 Input: "babad"
@@ -14,7 +14,7 @@ Output: "bab"
 Note: "aba" is also a valid answer.
 ```
 
-**Example:**
+**Example 2:**
 
 ```
 Input: "cbbd"
@@ -22,7 +22,7 @@ Input: "cbbd"
 Output: "bb"
 ```
 
-**Tags:** String
+**Tags:** String, Dynamic Programming
 
 
 ## 思路 0
diff --git a/note/006/README.md b/note/006/README.md
index 28e382a7..a5ec493e 100644
--- a/note/006/README.md
+++ b/note/006/README.md
@@ -15,10 +15,28 @@ And then read line by line: `"PAHNAPLSIIGYIR"`
 Write the code that will take a string and make this conversion given a number of rows:
 
 ```
-string convert(string text, int nRows);
+string convert(string s, int numRows);
 ```
 
-`convert("PAYPALISHIRING", 3)` should return `"PAHNAPLSIIGYIR"`.
+**Example 1:**
+
+```
+Input: s = "PAYPALISHIRING", numRows = 3
+Output: "PAHNAPLSIIGYIR"
+```
+
+**Example 2:**
+
+```
+Input: s = "PAYPALISHIRING", numRows = 4
+Output: "PINALSIGYAHRPI"
+Explanation:
+
+P     I    N
+A   L S  I G
+Y A   H R
+P     I
+```
 
 **Tags:** String
 
diff --git a/note/008/README.md b/note/008/README.md
index 4d0991f9..257e7df7 100644
--- a/note/008/README.md
+++ b/note/008/README.md
@@ -2,23 +2,62 @@
 
 ## Description
 
-Implement atoi to convert a string to an integer.
+Implement `atoi` which converts a string to an integer.
 
-**Hint:** Carefully consider all possible input cases. If you want a challenge, please do not see below and ask yourself what are the possible input cases.
+The function first discards as many whitespace characters as necessary until the first non-whitespace character is found. Then, starting from this character, takes an optional initial plus or minus sign followed by as many numerical digits as possible, and interprets them as a numerical value.
 
-**Notes:** It is intended for this problem to be specified vaguely (ie, no given input specs). You are responsible to gather all the input requirements up front.
+The string can contain additional characters after those that form the integral number, which are ignored and have no effect on the behavior of this function.
 
-**Spoilers:**
+If the first sequence of non-whitespace characters in str is not a valid integral number, or if no such sequence exists because either str is empty or it contains only whitespace characters, no conversion is performed.
 
-**Requirements for atoi:**
+If no valid conversion could be performed, a zero value is returned.
 
-The function first discards as many whitespace characters as necessary until the first non-whitespace character is found. Then, starting from this character, takes an optional initial plus or minus sign followed by as many numerical digits as possible, and interprets them as a numerical value.
+**Note:**
 
-The string can contain additional characters after those that form the integral number, which are ignored and have no effect on the behavior of this function.
+- Only the space character `' '` is considered as whitespace character.
+- Assume we are dealing with an environment which could only store integers within the 32-bit signed integer range: [−2<sup>31</sup>,  2<sup>31</sup> − 1]. If the numerical value is out of the range of representable values, INT_MAX (2<sup>31</sup> − 1) or INT_MIN (−2<sup>31</sup>) is returned.
 
-If the first sequence of non-whitespace characters in str is not a valid integral number, or if no such sequence exists because either str is empty or it contains only whitespace characters, no conversion is performed.
+**Example 1:**
+
+```
+Input: "42"
+Output: 42
+```
+
+**Example 2:**
+
+```
+Input: "   -42"
+Output: -42
+Explanation: The first non-whitespace character is '-', which is the minus sign.
+             Then take as many numerical digits as possible, which gets 42.
+```
+
+**Example 3:**
+
+```
+Input: "4193 with words"
+Output: 4193
+Explanation: Conversion stops at digit '3' as the next character is not a numerical digit.
+```
+
+**Example 4:**
 
-If no valid conversion could be performed, a zero value is returned. If the correct value is out of the range of representable values, INT_MAX (2147483647) or INT_MIN (-2147483648) is returned.
+```
+Input: "words and 987"
+Output: 0
+Explanation: The first non-whitespace character is 'w', which is not a numerical 
+             digit or a +/- sign. Therefore no valid conversion could be performed.
+```
+
+**Example 5:**
+
+```
+Input: "-91283472332"
+Output: -2147483648
+Explanation: The number "-91283472332" is out of the range of a 32-bit signed integer.
+             Thefore INT_MIN (−2^31) is returned.
+```
 
 **Tags:** Math, String
 
@@ -37,12 +76,13 @@ class Solution {
         }
         for (; i < len; ++i) {
             int tmp = str.charAt(i) - '0';
-            if (tmp < 0 || tmp > 9)
-                break;
-            if (ans > Integer.MAX_VALUE / 10 || ans == Integer.MAX_VALUE / 10 && Integer.MAX_VALUE % 10 < tmp)
+            if (tmp < 0 || tmp > 9) break;
+            if (ans > Integer.MAX_VALUE / 10
+                    || (ans == Integer.MAX_VALUE / 10 && (sign == 1 && tmp > 7 || sign == -1 && tmp > 8))) {
                 return sign == 1 ? Integer.MAX_VALUE : Integer.MIN_VALUE;
-            else
+            } else {
                 ans = ans * 10 + tmp;
+            }
         }
         return sign * ans;
     }
diff --git a/note/009/README.md b/note/009/README.md
index c549c911..9571fa0f 100644
--- a/note/009/README.md
+++ b/note/009/README.md
@@ -2,19 +2,34 @@
 
 ## Description
 
-Determine whether an integer is a palindrome. Do this without extra space.
+Determine whether an integer is a palindrome. An integer is a palindrome when it reads the same backward as forward.
 
-**Spoilers:**
+**Example 1:**
 
-**Some hints:**
+```
+Input: 121
+Output: true
+```
+
+**Example 2:**
+
+```
+Input: -121
+Output: false
+Explanation: From left to right, it reads -121. From right to left, it becomes 121-. Therefore it is not a palindrome.
+```
 
-Could negative integers be palindromes? (ie, -1)
+**Example 3:**
 
-If you are thinking of converting the integer to string, note the restriction of using extra space.
+```
+Input: 10
+Output: false
+Explanation: Reads 01 from right to left. Therefore it is not a palindrome.
+```
 
-You could also try reversing an integer. However, if you have solved the problem "Reverse Integer", you know that the reversed integer might overflow. How would you handle such case?
+**Follow up:**
 
-There is a more generic way of solving this problem.
+Coud you solve it without converting the integer to a string?
 
 **Tags:** Math
 
diff --git a/note/010/README.md b/note/010/README.md
index b52b6a5e..61421646 100644
--- a/note/010/README.md
+++ b/note/010/README.md
@@ -2,25 +2,67 @@
 
 ## Description
 
-Implement regular expression matching with support for `'.'` and `'*'`.
+Given an input string (`s`) and a pattern (`p`), implement regular expression matching with support for `'.'` and `'*'`.
 
 ```
 '.' Matches any single character.
 '*' Matches zero or more of the preceding element.
+```
+
+The matching should cover the **entire** input string (not partial).
+
+**Note:**
+
+- `s` could be empty and contains only lowercase letters `a-z`.
+- `p` could be empty and contains only lowercase letters `a-z`, and characters like `.` or `*`.
+
+**Example 1:**
+
+```
+Input:
+s = "aa"
+p = "a"
+Output: false
+Explanation: "a" does not match the entire string "aa".
+```
+
+**Example 2:**
+
+```
+Input:
+s = "aa"
+p = "a*"
+Output: true
+Explanation: '*' means zero or more of the precedeng element, 'a'. Therefore, by repeating 'a' once, it becomes "aa".
+```
+
+**Example 3:**
+
+```
+Input:
+s = "ab"
+p = ".*"
+Output: true
+Explanation: ".*" means "zero or more (*) of any character (.)".
+```
 
-The matching should cover the entire input string (not partial).
+**Example 4:**
 
-The function prototype should be:
-bool isMatch(const char *s, const char *p)
+```
+Input:
+s = "aab"
+p = "c*a*b"
+Output: true
+Explanation: c can be repeated 0 times, a can be repeated 1 time. Therefore it matches "aab".
+```
 
-Some examples:
-isMatch("aa", "a") → false
-isMatch("aa", "aa") → true
-isMatch("aaa", "aa") → false
-isMatch("aa", "a*") → true
-isMatch("aa", ".*") → true
-isMatch("ab", ".*") → true
-isMatch("aab", "c*a*b") → true
+**Example 5:**
+
+```
+Input:
+s = "mississippi"
+p = "mis*is*p*."
+Output: false
 ```
 
 **Tags:** String, Dynamic Programming, Backtracking
diff --git a/note/012/README.md b/note/012/README.md
index 002b22ec..b5f19663 100644
--- a/note/012/README.md
+++ b/note/012/README.md
@@ -2,9 +2,65 @@
 
 ## Description
 
-Given an integer, convert it to a roman numeral.
+Roman numerals are represented by seven different symbols: `I`, `V`, `X`, `L`, `C`, `D` and `M`.
 
-Input is guaranteed to be within the range from 1 to 3999.
+```
+Symbol       Value
+I             1
+V             5
+X             10
+L             50
+C             100
+D             500
+M             1000
+```
+
+For example, two is written as `II` in Roman numeral, just two one's added together. Twelve is written as, `XII`, which is simply `X` + `II`. The number twenty seven is written as `XXVII`, which is `XX` + `V` + `II`.
+
+Roman numerals are usually written largest to smallest from left to right. However, the numeral for four is not `IIII`. Instead, the number four is written as `IV`. Because the one is before the five we subtract it making four. The same principle applies to the number nine, which is written as `IX`. There are six instances where subtraction is used:
+
+- `I` can be placed before `V` (5) and `X` (10) to make 4 and 9. 
+- `X` can be placed before `L` (50) and `C` (100) to make 40 and 90. 
+- `C` can be placed before `D` (500) and `M` (1000) to make 400 and 900.
+
+Given an integer, convert it to a roman numeral. Input is guaranteed to be within the range from 1 to 3999.
+
+**Example 1:**
+
+```
+Input: 3
+Output: "III"
+```
+
+**Example 2:**
+
+```
+Input: 4
+Output: "IV"
+```
+
+**Example 3:**
+
+```
+Input: 9
+Output: "IX"
+```
+
+**Example 4:**
+
+```
+Input: 58
+Output: "LVIII"
+Explanation: C = 100, L = 50, XXX = 30 and III = 3.
+```
+
+**Example 5:**
+
+```
+Input: 1994
+Output: "MCMXCIV"
+Explanation: M = 1000, CM = 900, XC = 90 and IV = 4.
+```
 
 **Tags:** Math, String
 
diff --git a/note/013/README.md b/note/013/README.md
index 5916ab9b..43c78400 100644
--- a/note/013/README.md
+++ b/note/013/README.md
@@ -2,9 +2,65 @@
 
 ## Description
 
-Given a roman numeral, convert it to an integer.
+Roman numerals are represented by seven different symbols: `I`, `V`, `X`, `L`, `C`, `D` and `M`.
 
-Input is guaranteed to be within the range from 1 to 3999.
+```
+Symbol       Value
+I             1
+V             5
+X             10
+L             50
+C             100
+D             500
+M             1000
+```
+
+For example, two is written as `II` in Roman numeral, just two one's added together. Twelve is written as, `XII`, which is simply `X` + `II`. The number twenty seven is written as `XXVII`, which is `XX` + `V` + `II`.
+
+Roman numerals are usually written largest to smallest from left to right. However, the numeral for four is not `IIII`. Instead, the number four is written as `IV`. Because the one is before the five we subtract it making four. The same principle applies to the number nine, which is written as `IX`. There are six instances where subtraction is used:
+
+- `I` can be placed before `V` (5) and `X` (10) to make 4 and 9. 
+- `X` can be placed before `L` (50) and `C` (100) to make 40 and 90. 
+- `C` can be placed before `D` (500) and `M` (1000) to make 400 and 900.
+
+Given a roman numeral, convert it to an integer. Input is guaranteed to be within the range from 1 to 3999.
+
+**Example 1:**
+
+```
+Input: "III"
+Output: 3
+```
+
+**Example 2:**
+
+```
+Input: "IV"
+Output: 4
+```
+
+**Example 3:**
+
+```
+Input: "IX"
+Output: 9
+```
+
+**Example 4:**
+
+```
+Input: "LVIII"
+Output: 58
+Explanation: C = 100, L = 50, XXX = 30 and III = 3.
+```
+
+**Example 5:**
+
+```
+Input: "MCMXCIV"
+Output: 1994
+Explanation: M = 1000, CM = 900, XC = 90 and IV = 4.
+```
 
 **Tags:** Math, String
 
diff --git a/note/014/README.md b/note/014/README.md
index fa6617d6..03e70e4a 100644
--- a/note/014/README.md
+++ b/note/014/README.md
@@ -4,6 +4,27 @@
 
 Write a function to find the longest common prefix string amongst an array of strings.
 
+If there is no common prefix, return an empty string `""`.
+
+**Example 1:**
+
+```
+Input: ["flower","flow","flight"]
+Output: "fl"
+```
+
+**Example 2:**
+
+```
+Input: ["dog","racecar","car"]
+Output: ""
+Explanation: There is no common prefix among the input strings.
+```
+
+**Note:**
+
+All given inputs are in lowercase letters `a-z`.
+
 **Tags:** String
 
 
diff --git a/note/015/README.md b/note/015/README.md
index a5be6bf3..b127a623 100644
--- a/note/015/README.md
+++ b/note/015/README.md
@@ -2,12 +2,16 @@
 
 ## Description
 
-Given an array *S* of *n* integers, are there elements *a*, *b*, *c* in *S* such that *a* + *b* + *c* = 0? Find all unique triplets in the array which gives the sum of zero.
+Given an array `nums` of *n* integers, are there elements *a*, *b*, *c* in `nums` such that *a* + *b* + *c* = 0? Find all unique triplets in the array which gives the sum of zero.
 
-**Note:** The solution set must not contain duplicate triplets.
+**Note:**
+
+The solution set must not contain duplicate triplets.
+
+**Example:**
 
 ```
-For example, given array S = [-1, 0, 1, 2, -1, -4],
+Given array nums = [-1, 0, 1, 2, -1, -4],
 
 A solution set is:
 [
diff --git a/note/016/README.md b/note/016/README.md
index 6c6609e3..fb5a00d0 100644
--- a/note/016/README.md
+++ b/note/016/README.md
@@ -2,12 +2,14 @@
 
 ## Description
 
-Given an array *S* of *n* integers, find three integers in *S* such that the sum is closest to a given number, target. Return the sum of the three integers. You may assume that each input would have exactly one solution.
+Given an array `nums` of *n* integers and an integer `target`, find three integers in `nums` such that the sum is closest to `target`. Return the sum of the three integers. You may assume that each input would have exactly one solution.
+
+**Example:**
 
 ```
-    For example, given array S = {-1 2 1 -4}, and target = 1.
+Given array nums = [-1, 2, 1, -4], and target = 1.
 
-    The sum that is closest to the target is 2. (-1 + 2 + 1 = 2).
+The sum that is closest to the target is 2. (-1 + 2 + 1 = 2).
 ```
 
 **Tags:** Array, Two Pointers
diff --git a/note/017/README.md b/note/017/README.md
index ebf0bd5c..2849bfc6 100644
--- a/note/017/README.md
+++ b/note/017/README.md
@@ -8,8 +8,10 @@ A mapping of digit to letters (just like on the telephone buttons) is given belo
 
 ![img](https://upload.wikimedia.org/wikipedia/commons/thumb/7/73/Telephone-keypad2.svg/200px-Telephone-keypad2.svg.png)
 
+**Example:**
+
 ```
-Input:Digit string "23"
+Input: "23"
 Output: ["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].
 ```
 
diff --git a/note/018/README.md b/note/018/README.md
index 6b7c0834..4685eeb4 100644
--- a/note/018/README.md
+++ b/note/018/README.md
@@ -2,12 +2,16 @@
 
 ## Description
 
-Given an array *S* of *n* integers, are there elements *a*, *b*, *c*, and *d* in *S* such that *a* + *b* + *c* + *d* = target? Find all unique quadruplets in the array which gives the sum of target.
+Given an array `nums` of *n* integers and an integer `target`, are there elements *a*, *b*, *c*, and *d* in `nums` such that *a* + *b* + *c* + *d* = `target`? Find all unique quadruplets in the array which gives the sum of `target`.
 
-**Note:** The solution set must not contain duplicate quadruplets.
+**Note:**
+
+The solution set must not contain duplicate quadruplets.
+
+**Example:**
 
 ```
-For example, given array S = [1, 0, -1, 0, -2, 2], and target = 0.
+Given array nums = [1, 0, -1, 0, -2, 2], and target = 0.
 
 A solution set is:
 [
diff --git a/note/019/README.md b/note/019/README.md
index 1035c2a8..935113e4 100644
--- a/note/019/README.md
+++ b/note/019/README.md
@@ -2,21 +2,23 @@
 
 ## Description
 
-Given a linked list, remove the *n*<sup>th</sup> node from the end of list and return its head.
+Given a linked list, remove the *n*-th node from the end of list and return its head.
 
-For example,
+**Example:**
 
 ```
-   Given linked list: 1->2->3->4->5, and n = 2.
+Given linked list: 1->2->3->4->5, and n = 2.
 
-   After removing the second node from the end, the linked list becomes 1->2->3->5.
+After removing the second node from the end, the linked list becomes 1->2->3->5.
 ```
 
 **Note:**
 
 Given *n* will always be valid.
 
-Try to do this in one pass.
+**Follow up:**
+
+Could you do this in one pass?
 
 **Tags:** Linked List, Two Pointers
 
diff --git a/note/020/README.md b/note/020/README.md
index 78837723..410d983a 100644
--- a/note/020/README.md
+++ b/note/020/README.md
@@ -4,7 +4,47 @@
 
 Given a string containing just the characters `'('`, `')'`, `'{'`, `'}'`, `'['` and `']'`, determine if the input string is valid.
 
-The brackets must close in the correct order, `"()"` and `"()[]{}"` are all valid but `"(]"` and `"([)]"` are not.
+An input string is valid if:
+
+1. Open brackets must be closed by the same type of brackets.
+2. Open brackets must be closed in the correct order.
+
+Note that an empty string is also considered valid.
+
+**Example 1:**
+
+```
+Input: "()"
+Output: true
+```
+
+**Example 2:**
+
+```
+Input: "()[]{}"
+Output: true
+```
+
+**Example 3:**
+
+```
+Input: "(]"
+Output: false
+```
+
+**Example 4:**
+
+```
+Input: "([)]"
+Output: false
+```
+
+**Example 5:**
+
+```
+Input: "{[]}"
+Output: true
+```
 
 **Tags:** Stack, String
 
diff --git a/note/023/README.md b/note/023/README.md
index 262a7d56..3de0690a 100644
--- a/note/023/README.md
+++ b/note/023/README.md
@@ -4,6 +4,18 @@
 
 Merge *k* sorted linked lists and return it as one sorted list. Analyze and describe its complexity.
 
+**Example:**
+
+```
+Input:
+[
+  1->4->5,
+  1->3->4,
+  2->6
+]
+Output: 1->1->2->3->4->4->5->6
+```
+
 **Tags:** Linked List, Divide and Conquer, Heap
 
 
diff --git a/note/024/README.md b/note/024/README.md
index 330f2276..8667b5c1 100644
--- a/note/024/README.md
+++ b/note/024/README.md
@@ -4,10 +4,16 @@
 
 Given a linked list, swap every two adjacent nodes and return its head.
 
-For example,
-Given `1->2->3->4`, you should return the list as `2->1->4->3`.
+**Example:**
 
-Your algorithm should use only constant space. You may **not** modify the values in the list, only nodes itself can be changed.
+```
+Given 1->2->3->4, you should return the list as 2->1->4->3.
+```
+
+**Note:**
+
+- Your algorithm should use only constant extra space.
+- You may **not** modify the values in the list's nodes, only nodes itself may be changed.
 
 **Tags:** Linked List
 
diff --git a/note/025/README.md b/note/025/README.md
index 7bdeeab7..fd042a9e 100644
--- a/note/025/README.md
+++ b/note/025/README.md
@@ -6,11 +6,8 @@ Given a linked list, reverse the nodes of a linked list *k* at a time and return
 
 *k* is a positive integer and is less than or equal to the length of the linked list. If the number of nodes is not a multiple of *k* then left-out nodes in the end should remain as it is.
 
-You may not alter the values in the nodes, only nodes itself may be changed.
 
-Only constant memory is allowed.
-
-For example,
+**Example:**
 
 Given this linked list: `1->2->3->4->5`
 
@@ -18,6 +15,11 @@ For *k* = 2, you should return: `2->1->4->3->5`
 
 For *k* = 3, you should return: `3->2->1->4->5`
 
+**Note:**
+
+- Only constant extra memory is allowed.
+- You may not alter the values in the list's nodes, only nodes itself may be changed.
+
 **Tags:** Linked List
 
 
diff --git a/note/026/README.md b/note/026/README.md
index 53daaf2a..58340c4b 100644
--- a/note/026/README.md
+++ b/note/026/README.md
@@ -2,17 +2,47 @@
 
 ## Description
 
-Given a sorted array, remove the duplicates [**in-place**](https://en.wikipedia.org/wiki/In-place_algorithm) such that each element appear only *once* and return the new length.
+Given a sorted array *nums*, remove the duplicates [**in-place**](https://en.wikipedia.org/wiki/In-place_algorithm) such that each element appear only *once* and return the new length.
 
-Do not allocate extra space for another array, you must do this by **modifying the input array in-place** with O(1) extra memory.
+Do not allocate extra space for another array, you must do this by **modifying the input array [in-place](https://en.wikipedia.org/wiki/In-place_algorithm)** with O(1) extra memory.
 
-**Example:**
+**Example 1:**
 
 ```
 Given nums = [1,1,2],
 
 Your function should return length = 2, with the first two elements of nums being 1 and 2 respectively.
-It doesn't matter what you leave beyond the new length.
+
+It doesn't matter what you leave beyond the returned length.
+```
+
+**Example 2:**
+
+```
+Given nums = [0,0,1,1,1,2,2,3,3,4],
+
+Your function should return length = 5, with the first five elements of nums being modified to 0, 1, 2, 3, and 4 respectively.
+
+It doesn't matter what values are set beyond the returned length.
+```
+
+**Clarification:**
+
+Confused why the returned value is an integer but your answer is an array?
+
+Note that the input array is passed in by **reference**, which means modification to the input array will be known to the caller as well.
+
+Internally you can think of this:
+
+```
+// nums is passed in by reference. (i.e., without making a copy)
+int len = removeDuplicates(nums);
+
+// any modification to nums in your function would be known by the caller.
+// using the length returned by your function, it prints the first len elements.
+for (int i = 0; i < len; i++) {
+    print(nums[i]);
+}
 ```
 
 **Tags:** Array, Two Pointers
diff --git a/note/027/README.md b/note/027/README.md
index f17349af..4cfd4983 100644
--- a/note/027/README.md
+++ b/note/027/README.md
@@ -2,18 +2,51 @@
 
 ## Description
 
-Given an array and a value, remove all instances of that value [**in-place**](https://en.wikipedia.org/wiki/In-place_algorithm) and return the new length.
+Given an array *nums* and a value *val*, remove all instances of that value [**in-place**](https://en.wikipedia.org/wiki/In-place_algorithm) and return the new length.
 
-Do not allocate extra space for another array, you must do this by **modifying the input array [in-place](https://en.wikipedia.org/wiki/In-place_algorithm)** with O(1) extra memory.
+Do not allocate extra space for another array, you must do this by **modifying the input array [in-place](https://en.wikipedia.org/wiki/In-place_algorithm) ** with O(1) extra memory.
 
 The order of elements can be changed. It doesn't matter what you leave beyond the new length.
 
-**Example:**
+**Example 1:**
 
 ```
 Given nums = [3,2,2,3], val = 3,
 
 Your function should return length = 2, with the first two elements of nums being 2.
+
+It doesn't matter what you leave beyond the returned length.
+```
+
+**Example 2:**
+
+```
+Given nums = [0,1,2,2,3,0,4,2], val = 2,
+
+Your function should return length = 5, with the first five elements of nums containing 0, 1, 3, 0, and 4.
+
+Note that the order of those five elements can be arbitrary.
+
+It doesn't matter what values are set beyond the returned length.
+```
+
+**Clarification:**
+
+Confused why the returned value is an integer but your answer is an array?
+
+Note that the input array is passed in by **reference**, which means modification to the input array will be known to the caller as well.
+
+Internally you can think of this:
+
+```
+// nums is passed in by reference. (i.e., without making a copy)
+int len = removeElement(nums, val);
+
+// any modification to nums in your function would be known by the caller.
+// using the length returned by your function, it prints the first len elements.
+for (int i = 0; i < len; i++) {
+    print(nums[i]);
+}
 ```
 
 **Tags:** Array, Two Pointers
diff --git a/note/028/README.md b/note/028/README.md
index aedd11eb..7ee16a3d 100644
--- a/note/028/README.md
+++ b/note/028/README.md
@@ -20,6 +20,12 @@ Input: haystack = "aaaaa", needle = "bba"
 Output: -1
 ```
 
+**Clarification:**
+
+What should we return when `needle` is an empty string? This is a great question to ask during an interview.
+
+For the purpose of this problem, we will return 0 when `needle` is an empty string. This is consistent to C's [strstr()](http://www.cplusplus.com/reference/cstring/strstr/) and Java's [indexOf()](https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#indexOf(java.lang.String)).
+
 Tags:** Two Pointers, String
 
 
diff --git a/note/029/README.md b/note/029/README.md
index d402cd0d..6018b268 100644
--- a/note/029/README.md
+++ b/note/029/README.md
@@ -2,9 +2,31 @@
 
 ## Description
 
-Divide two integers without using multiplication, division and mod operator.
+Given two integers `dividend` and `divisor`, divide two integers without using multiplication, division and mod operator.
 
-If it is overflow, return MAX_INT.
+Return the quotient after dividing `dividend` by `divisor`.
+
+The integer division should truncate toward zero.
+
+**Example 1:**
+
+```
+Input: dividend = 10, divisor = 3
+Output: 3
+```
+
+**Example 2:**
+
+```
+Input: dividend = 7, divisor = -3
+Output: -2
+```
+
+**Note:**
+
+- Both dividend and divisor will be 32-bit signed integers.
+- The divisor will never be 0.
+- Assume we are dealing with an environment which could only store integers within the 32-bit signed integer range: [−2<sup>31</sup>,  2<sup>31</sup> − 1]. For the purpose of this problem, assume that your function returns 2<sup>31</sup> − 1 when the division result overflows.
 
 **Tags:** Math, Binary Search
 
diff --git a/note/030/README.md b/note/030/README.md
index e18c1b0f..7d5eaa2e 100644
--- a/note/030/README.md
+++ b/note/030/README.md
@@ -4,16 +4,25 @@
 
 You are given a string, **s**, and a list of words, **words**, that are all of the same length. Find all starting indices of substring(s) in **s** that is a concatenation of each word in **words** exactly once and without any intervening characters.
 
+**Example 1:**
 
-For example, given:
-
-**s**: `"barfoothefoobarman"`
-
-**words**: `["foo", "bar"]`
+```
+Input:
+  s = "barfoothefoobarman",
+  words = ["foo","bar"]
+Output: [0,9]
+Explanation: Substrings starting at index 0 and 9 are "barfoor" and "foobar" respectively.
+The output order does not matter, returning [9,0] is fine too.
+```
 
-You should return the indices: `[0,9]`.
+**Example 2:**
 
-(order does not matter).
+```
+Input:
+  s = "wordgoodstudentgoodword",
+  words = ["word","student"]
+Output: []
+```
 
 **Tags:** Hash Table, Two Pointers, String
 
diff --git a/note/033/README.md b/note/033/README.md
index 821640f7..f096a1aa 100644
--- a/note/033/README.md
+++ b/note/033/README.md
@@ -4,12 +4,28 @@
 
 Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.
 
-(i.e., `0 1 2 4 5 6 7` might become `4 5 6 7 0 1 2`).
+(i.e., `[0,1,2,4,5,6,7]` might become `[4,5,6,7,0,1,2]`).
 
-You are given a target value to search. If found in the array return its index, otherwise return -1.
+You are given a target value to search. If found in the array return its index, otherwise return `-1`.
 
 You may assume no duplicate exists in the array.
 
+Your algorithm's runtime complexity must be in the order of *O*(log *n*).
+
+**Example 1:**
+
+```
+Input: nums = [4,5,6,7,0,1,2], target = 0
+Output: 4
+```
+
+**Example 2:**
+
+```
+Input: nums = [4,5,6,7,0,1,2], target = 3
+Output: -1
+```
+
 **Tags:** Arrays, Binary Search
 
 
diff --git a/note/043/README.md b/note/043/README.md
index 48b955f1..7349e208 100644
--- a/note/043/README.md
+++ b/note/043/README.md
@@ -2,17 +2,28 @@
 
 ## Description
 
-Given two non-negative integers `num1` and `num2` represented as strings, return the product of `num1` and `num2`.
+1. Given two non-negative integers `num1` and `num2` represented as strings, return the product of `num1` and `num2`, also represented as a string.
 
-**Note:**
+   **Example 1:**
 
-1. The length of both `num1` and `num2` is < 110.
+   ```
+   Input: num1 = "2", num2 = "3"
+   Output: "6"
+   ```
 
-2. Both `num1` and `num2` contains only digits `0-9`.
+   **Example 2:**
 
-3. Both `num1` and `num2` does not contain any leading zero.
+   ```
+   Input: num1 = "123", num2 = "456"
+   Output: "56088"
+   ```
 
-4. You **must not use any built-in BigInteger library** or **convert the inputs to integer** directly.
+   **Note:**
+
+   1. The length of both `num1` and `num2` is < 110.
+   2. Both `num1` and `num2` contain only digits `0-9`.
+   3. Both `num1` and `num2` do not contain any leading zero, except the number 0 itself.
+   4. You **must not use any built-in BigInteger library** or **convert the inputs to integer** directly.
 
 **Tags:** Math, String
 
diff --git a/note/044/README.md b/note/044/README.md
index 2798d17f..34f7ae0f 100644
--- a/note/044/README.md
+++ b/note/044/README.md
@@ -2,25 +2,67 @@
 
 ## Description
 
-Implement wildcard pattern matching with support for `'?'` and `'*'`.
+Given an input string (`s`) and a pattern (`p`), implement wildcard pattern matching with support for `'?'` and `'*'`.
 
 ```
 '?' Matches any single character.
 '*' Matches any sequence of characters (including the empty sequence).
+```
+
+The matching should cover the **entire** input string (not partial).
+
+**Note:**
+
+- `s` could be empty and contains only lowercase letters `a-z`.
+- `p` could be empty and contains only lowercase letters `a-z`, and characters like `?` or `*`.
+
+**Example 1:**
+
+```
+Input:
+s = "aa"
+p = "a"
+Output: false
+Explanation: "a" does not match the entire string "aa".
+```
+
+**Example 2:**
+
+```
+Input:
+s = "aa"
+p = "*"
+Output: true
+Explanation: '*' matches any sequence.
+```
+
+**Example 3:**
+
+```
+Input:
+s = "cb"
+p = "?a"
+Output: false
+Explanation: '?' matches 'c', but the second letter is 'a', which does not match 'b'.
+```
 
-The matching should cover the entire input string (not partial).
+**Example 4:**
 
-The function prototype should be:
-bool isMatch(const char *s, const char *p)
+```
+Input:
+s = "adceb"
+p = "*a*b"
+Output: true
+Explanation: The first '*' matches the empty sequence, while the second '*' matches the substring "dce".
+```
 
-Some examples:
-isMatch("aa","a") → false
-isMatch("aa","aa") → true
-isMatch("aaa","aa") → false
-isMatch("aa", "*") → true
-isMatch("aa", "a*") → true
-isMatch("ab", "?*") → true
-isMatch("aab", "c*a*b") → false
+**Example 5:**
+
+```
+Input:
+s = "acdcb"
+p = "a*c?b"
+Output: false
 ```
 
 **Tags:** String, Dynamic Programming, Backtracking, Greedy
diff --git a/note/049/README.md b/note/049/README.md
index cc2ebbaa..9832535a 100644
--- a/note/049/README.md
+++ b/note/049/README.md
@@ -4,19 +4,22 @@
 
 Given an array of strings, group anagrams together.
 
-For example, given: `["eat", "tea", "tan", "ate", "nat", "bat"]`,
-
-Return:
+**Example:**
 
 ```
+Input: ["eat", "tea", "tan", "ate", "nat", "bat"],
+Output:
 [
-  ["ate", "eat","tea"],
+  ["ate","eat","tea"],
   ["nat","tan"],
   ["bat"]
 ]
 ```
 
-**Note:** All inputs will be in lower-case.
+**Note:**
+
+- All inputs will be in lowercase.
+- The order of your output does not matter.
 
 **Tags:** Hash Table, String
 
diff --git a/note/050/README.md b/note/050/README.md
index a4140f5c..84c125fe 100644
--- a/note/050/README.md
+++ b/note/050/README.md
@@ -2,7 +2,7 @@
 
 ## Description
 
-Implement [pow(*x*, *n*)](http://www.cplusplus.com/reference/valarray/pow/).
+Implement [pow(*x*, *n*)](http://www.cplusplus.com/reference/valarray/pow/), which calculates *x* raised to the power *n* (xn).
 
 **Example 1:**
 
@@ -18,6 +18,19 @@ Input: 2.10000, 3
 Output: 9.26100
 ```
 
+**Example 3:**
+
+```
+Input: 2.00000, -2
+Output: 0.25000
+Explanation: 2^-2 = 1/2^2 = 1/4 = 0.25
+```
+
+**Note:**
+
+- -100.0 < *x* < 100.0
+- *n* is a 32-bit signed integer, within the range [−2<sup>31</sup>, 2<sup>31</sup> − 1]
+
 **Tags:** Math, Binary Search
 
 
diff --git a/note/053/README.md b/note/053/README.md
index 816a3d93..43cf6f50 100644
--- a/note/053/README.md
+++ b/note/053/README.md
@@ -2,13 +2,17 @@
 
 ## Description
 
-Find the contiguous subarray within an array (containing at least one number) which has the largest sum.
+Given an integer array `nums`, find the contiguous subarray (containing at least one number) which has the largest sum and return its sum.
 
-For example, given the array `[-2,1,-3,4,-1,2,1,-5,4]`,
+**Example:**
 
-the contiguous subarray `[4,-1,2,1]` has the largest sum = `6`.
+```
+Input: [-2,1,-3,4,-1,2,1,-5,4],
+Output: 6
+Explanation: [4,-1,2,1] has the largest sum = 6.
+```
 
-**More practice:**
+**Follow up:**
 
 If you have figured out the O(*n*) solution, try coding another solution using the divide and conquer approach, which is more subtle.
 
diff --git a/note/056/README.md b/note/056/README.md
index 70d8e5bd..48621d1a 100644
--- a/note/056/README.md
+++ b/note/056/README.md
@@ -4,11 +4,21 @@
 
 Given a collection of intervals, merge all overlapping intervals.
 
-For example,
+**Example 1:**
 
-Given `[1,3],[2,6],[8,10],[15,18]`,
+```
+Input: [[1,3],[2,6],[8,10],[15,18]]
+Output: [[1,6],[8,10],[15,18]]
+Explanation: Since intervals [1,3] and [2,6] overlaps, merge them into [1,6].
+```
+
+**Example 2:**
 
-return `[1,6],[8,10],[15,18]`.
+```
+Input: [[1,4],[4,5]]
+Output: [[1,5]]
+Explanation: Intervals [1,4] and [4,5] are considerred overlapping.
+```
 
 **Tags:** Array, Sort
 
diff --git a/note/057/README.md b/note/057/README.md
index fcf217cd..f9b82a84 100644
--- a/note/057/README.md
+++ b/note/057/README.md
@@ -8,13 +8,18 @@ You may assume that the intervals were initially sorted according to their start
 
 **Example 1:**
 
-Given intervals `[1,3],[6,9]`, insert and merge `[2,5]` in as `[1,5],[6,9]`.
+```
+Input: intervals = [[1,3],[6,9]], newInterval = [2,5]
+Output: [[1,5],[6,9]]
+```
 
 **Example 2:**
 
-Given `[1,2],[3,5],[6,7],[8,10],[12,16]`, insert and merge `[4,9]` in as `[1,2],[3,10],[12,16]`.
-
-This is because the new interval `[4,9]` overlaps with `[3,5],[6,7],[8,10]`.
+```
+Input: intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8]
+Output: [[1,2],[3,10],[12,16]]
+Explanation: Because the new interval [4,8] overlaps with [3,5],[6,7],[8,10].
+```
 
 **Tags:** Array, Sort
 
diff --git a/note/066/README.md b/note/066/README.md
index aaacdb4f..03b2ddda 100644
--- a/note/066/README.md
+++ b/note/066/README.md
@@ -2,11 +2,27 @@
 
 ## Description
 
-Given a non-negative integer represented as a **non-empty** array of digits, plus one to the integer.
+Given a **non-empty** array of digits representing a non-negative integer, plus one to the integer.
 
-You may assume the integer do not contain any leading zero, except the number 0 itself.
+The digits are stored such that the most significant digit is at the head of the list, and each element in the array contain a single digit.
 
-The digits are stored such that the most significant digit is at the head of the list.
+You may assume the integer does not contain any leading zero, except the number 0 itself.
+
+**Example 1:**
+
+```
+Input: [1,2,3]
+Output: [1,2,4]
+Explanation: The array represents the integer 123.
+```
+
+**Example 2:**
+
+```
+Input: [4,3,2,1]
+Output: [4,3,2,2]
+Explanation: The array represents the integer 4321.
+```
 
 **Tags:** Array, Math
 
diff --git a/note/067/README.md b/note/067/README.md
index 28bcab99..5620814f 100644
--- a/note/067/README.md
+++ b/note/067/README.md
@@ -4,13 +4,21 @@
 
 Given two binary strings, return their sum (also a binary string).
 
-For example,
+The input strings are both **non-empty** and contains only characters `1` or `0`.
 
-a = `"11"`
+**Example 1:**
 
-b = `"1"`
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+**Example 2:**
 
-Return `"100"`.
+```
+Input: a = "1010", b = "1011"
+Output: "10101"
+```
 
 **Tags:** Math, String
 
diff --git a/note/068/README.md b/note/068/README.md
index 70aa778a..0d3d6f91 100644
--- a/note/068/README.md
+++ b/note/068/README.md
@@ -2,38 +2,68 @@
 
 ## Description
 
-Given an array of words and a length *L*, format the text such that each line has exactly *L* characters and is fully (left and right) justified.
+Given an array of words and a width *maxWidth*, format the text such that each line has exactly *maxWidth* characters and is fully (left and right) justified.
 
-You should pack your words in a greedy approach; that is, pack as many words as you can in each line. Pad extra spaces `' '` when necessary so that each line has exactly *L* characters.
+You should pack your words in a greedy approach; that is, pack as many words as you can in each line. Pad extra spaces `' '` when necessary so that each line has exactly *maxWidth* characters.
 
 Extra spaces between words should be distributed as evenly as possible. If the number of spaces on a line do not divide evenly between words, the empty slots on the left will be assigned more spaces than the slots on the right.
 
-For the last line of text, it should be left justified and no extra space is inserted between words.
+For the last line of text, it should be left justified and no **extra** space is inserted between words.
 
-For example,
+**Note:**
 
-**words**: `["This", "is", "an", "example", "of", "text", "justification."]`
+- A word is defined as a character sequence consisting of non-space characters only.
+- Each word's length is guaranteed to be greater than 0 and not exceed *maxWidth*.
+- The input array `words` contains at least one word.
 
-**L**: `16`.
-
-Return the formatted lines as:
+**Example 1:**
 
 ```
+Input:
+words = ["This", "is", "an", "example", "of", "text", "justification."]
+maxWidth = 16
+Output:
 [
    "This    is    an",
    "example  of text",
    "justification.  "
 ]
-
 ```
 
-**Note:** Each word is guaranteed not to exceed *L* in length.
+**Example 2:**
 
-**Corner Cases:**
+```
+Input:
+words = ["What","must","be","acknowledgment","shall","be"]
+maxWidth = 16
+Output:
+[
+  "What   must   be",
+  "acknowledgment  ",
+  "shall be        "
+]
+Explanation: Note that the last line is "shall be    " instead of "shall     be",
+             because the last line must be left-justified instead of fully-justified.
+             Note that the second line is also left-justified becase it contains only one word.
+```
 
-- A line other than the last line might contain only one word. What should you do in this case?
+**Example 3:**
 
-  In this case, that line should be left-justified.
+```
+Input:
+words = ["Science","is","what","we","understand","well","enough","to","explain",
+         "to","a","computer.","Art","is","everything","else","we","do"]
+maxWidth = 20
+Output:
+[
+  "Science  is  what we",
+  "understand      well",
+  "enough to explain to",
+  "a  computer.  Art is",
+  "everything  else  we",
+  "do                  "
+]
+```
 
 **Tags:** String
 
diff --git a/note/069/README.md b/note/069/README.md
index 7b686258..6497b335 100644
--- a/note/069/README.md
+++ b/note/069/README.md
@@ -4,9 +4,9 @@
 
 Implement `int sqrt(int x)`.
 
-Compute and return the square root of *x*.
+Compute and return the square root of *x*, where *x* is guaranteed to be a non-negative integer.
 
-**x** is guaranteed to be a non-negative integer.
+Since the return type is an integer, the decimal digits are truncated and only the integer part of the result is returned.
 
 **Example 1:**
 
@@ -20,7 +20,8 @@ Output: 2
 ```
 Input: 8
 Output: 2
-Explanation: The square root of 8 is 2.82842..., and since we want to return an integer, the decimal part will be truncated.
+Explanation: The square root of 8 is 2.82842..., and since 
+             the decimal part is truncated, 2 is returned.
 ```
 
 **Tags:** Binary Search, Math
diff --git a/note/070/README.md b/note/070/README.md
index 30f8bcef..193e12e0 100644
--- a/note/070/README.md
+++ b/note/070/README.md
@@ -12,9 +12,8 @@ Each time you can either climb 1 or 2 steps. In how many distinct ways can you c
 
 ```
 Input: 2
-Output:  2
-Explanation:  There are two ways to climb to the top.
-
+Output: 2
+Explanation: There are two ways to climb to the top.
 1. 1 step + 1 step
 2. 2 steps
 ```
@@ -23,9 +22,8 @@ Explanation:  There are two ways to climb to the top.
 
 ```
 Input: 3
-Output:  3
-Explanation:  There are three ways to climb to the top.
-
+Output: 3
+Explanation: There are three ways to climb to the top.
 1. 1 step + 1 step + 1 step
 2. 1 step + 2 steps
 3. 2 steps + 1 step
diff --git a/note/083/README.md b/note/083/README.md
index 305b3fa7..ebc155ab 100644
--- a/note/083/README.md
+++ b/note/083/README.md
@@ -4,11 +4,19 @@
 
 Given a sorted linked list, delete all duplicates such that each element appear only *once*.
 
-For example,
+**Example 1:**
 
-Given `1->1->2`, return `1->2`.
+```
+Input: 1->1->2
+Output: 1->2
+```
+
+**Example 2:**
 
-Given `1->1->2->3->3`, return `1->2->3`.
+```
+Input: 1->1->2->3->3
+Output: 1->2->3
+```
 
 **Tags:** Linked List
 
diff --git a/note/088/README.md b/note/088/README.md
index 44708357..ba64df12 100644
--- a/note/088/README.md
+++ b/note/088/README.md
@@ -6,7 +6,18 @@ Given two sorted integer arrays *nums1* and *nums2*, merge *nums2* into *nums1*
 
 **Note:**
 
-You may assume that *nums1* has enough space (size that is greater or equal to *m* + *n*) to hold additional elements from *nums2*. The number of elements initialized in *nums1* and *nums2* are *m* and *n* respectively.
+- The number of elements initialized in *nums1* and *nums2* are *m* and *n* respectively.
+- You may assume that *nums1* has enough space (size that is greater or equal to *m* + *n*) to hold additional elements from *nums2*.
+
+**Example:**
+
+```
+Input:
+nums1 = [1,2,3,0,0,0], m = 3
+nums2 = [2,5,6],       n = 3
+
+Output: [1,2,2,3,5,6]
+```
 
 **Tags:** Array, Two Pointers
 
diff --git a/note/104/README.md b/note/104/README.md
index 676c55cc..f1545304 100644
--- a/note/104/README.md
+++ b/note/104/README.md
@@ -6,6 +6,22 @@ Given a binary tree, find its maximum depth.
 
 The maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.
 
+**Note:** A leaf is a node with no children.
+
+**Example:**
+
+Given binary tree `[3,9,20,null,null,15,7]`,
+
+```
+    3
+   / \
+  9  20
+    /  \
+   15   7
+```
+
+return its depth = 3.
+
 **Tags:** Tree, Depth-first Search
 
 
diff --git a/note/110/README.md b/note/110/README.md
index 70c9d8c0..823ea493 100644
--- a/note/110/README.md
+++ b/note/110/README.md
@@ -4,7 +4,38 @@
 
 Given a binary tree, determine if it is height-balanced.
 
-For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of every node never differ by more than 1.
+For this problem, a height-balanced binary tree is defined as:
+
+> a binary tree in which the depth of the two subtrees of *every* node never differ by more than 1.
+
+**Example 1:**
+
+Given the following tree `[3,9,20,null,null,15,7]`:
+
+```
+    3
+   / \
+  9  20
+    /  \
+   15   7
+```
+
+Return true.
+**Example 2:**
+
+Given the following tree `[1,2,2,3,3,null,null,4,4]`:
+
+```
+       1
+      / \
+     2   2
+    / \
+   3   3
+  / \
+ 4   4
+```
+
+Return false.
 
 **Tags:** Tree, Depth-first Search
 
diff --git a/note/111/README.md b/note/111/README.md
index f6ea8cdf..5c4e2b8a 100644
--- a/note/111/README.md
+++ b/note/111/README.md
@@ -6,6 +6,22 @@ Given a binary tree, find its minimum depth.
 
 The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node.
 
+**Note:** A leaf is a node with no children.
+
+**Example:**
+
+Given binary tree `[3,9,20,null,null,15,7]`,
+
+```
+    3
+   / \
+  9  20
+    /  \
+   15   7
+```
+
+return its minimum depth = 2.
+
 **Tags:** Tree, Depth-first Search, Breadth-first Search
 
 
diff --git a/note/112/README.md b/note/112/README.md
index abf1975c..a287dd09 100644
--- a/note/112/README.md
+++ b/note/112/README.md
@@ -4,18 +4,20 @@
 
 Given a binary tree and a sum, determine if the tree has a root-to-leaf path such that adding up all the values along the path equals the given sum.
 
-For example:
+**Note:** A leaf is a node with no children.
+
+**Example:**
 
 Given the below binary tree and `sum = 22`,
 
 ```
-              5
-             / \
-            4   8
-           /   / \
-          11  13  4
-         /  \      \
-        7    2      1
+      5
+     / \
+    4   8
+   /   / \
+  11  13  4
+ /  \      \
+7    2      1
 ```
 
 return true, as there exist a root-to-leaf path `5->4->11->2` which sum is 22.
diff --git a/note/118/README.md b/note/118/README.md
index dd1a60b6..6e268aa3 100644
--- a/note/118/README.md
+++ b/note/118/README.md
@@ -2,13 +2,16 @@
 
 ## Description
 
-Given *numRows*, generate the first *numRows* of Pascal's triangle.
+Given a non-negative integer *numRows*, generate the first *numRows* of Pascal's triangle.
 
-For example, given *numRows* = 5,
+![img](https://upload.wikimedia.org/wikipedia/commons/0/0d/PascalTriangleAnimated2.gif)
+In Pascal's triangle, each number is the sum of the two numbers directly above it.
 
-Return
+**Example:**
 
 ```
+Input: 5
+Output:
 [
      [1],
     [1,1],
diff --git a/note/119/README.md b/note/119/README.md
index 7967f72c..65b792e5 100644
--- a/note/119/README.md
+++ b/note/119/README.md
@@ -2,13 +2,21 @@
 
 ## Description
 
-Given an index *k*, return the *k*<sup>th</sup> row of the Pascal's triangle.
+Given a non-negative index *k* where *k* ≤ 33, return the *k*th index row of the Pascal's triangle.
 
-For example, given *k* = 3,
+Note that the row index starts from 0.
 
-Return `[1,3,3,1]`.
+![img](https://upload.wikimedia.org/wikipedia/commons/0/0d/PascalTriangleAnimated2.gif)
+In Pascal's triangle, each number is the sum of the two numbers directly above it.
 
-**Note:**
+**Example:**
+
+```
+Input: 3
+Output: [1,3,3,1]
+```
+
+**Follow up:**
 
 Could you optimize your algorithm to use only *O*(*k*) extra space?
 
diff --git a/note/121/README.md b/note/121/README.md
index 648606f5..5699ece1 100644
--- a/note/121/README.md
+++ b/note/121/README.md
@@ -4,24 +4,25 @@
 
 Say you have an array for which the *i*<sup>th</sup> element is the price of a given stock on day *i*.
 
-If you were only permitted to complete at most one transaction (ie, buy one and sell one share of the stock), design an algorithm to find the maximum profit.
+If you were only permitted to complete at most one transaction (i.e., buy one and sell one share of the stock), design an algorithm to find the maximum profit.
+
+Note that you cannot sell a stock before you buy one.
 
 **Example 1:**
 
 ```
-Input: [7, 1, 5, 3, 6, 4]
+Input: [7,1,5,3,6,4]
 Output: 5
-
-max. difference = 6-1 = 5 (not 7-1 = 6, as selling price needs to be larger than buying price)
+Explanation: Buy on day 2 (price = 1) and sell on day 5 (price = 6), profit = 6-1 = 5.
+             Not 7-1 = 6, as selling price needs to be larger than buying price.
 ```
 
 **Example 2:**
 
 ```
-Input: [7, 6, 4, 3, 1]
+Input: [7,6,4,3,1]
 Output: 0
-
-In this case, no transaction is done, i.e. max profit = 0.
+Explanation: In this case, no transaction is done, i.e. max profit = 0.
 ```
 
 **Tags:** Array, Dynamic Programmin
diff --git a/note/122/README.md b/note/122/README.md
index b1c18ed6..a4a3aaa9 100644
--- a/note/122/README.md
+++ b/note/122/README.md
@@ -4,7 +4,36 @@
 
 Say you have an array for which the *i*<sup>th</sup> element is the price of a given stock on day *i*.
 
-Design an algorithm to find the maximum profit. You may complete as many transactions as you like (ie, buy one and sell one share of the stock multiple times). However, you may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again).
+Design an algorithm to find the maximum profit. You may complete as many transactions as you like (i.e., buy one and sell one share of the stock multiple times).
+
+**Note:** You may not engage in multiple transactions at the same time (i.e., you must sell the stock before you buy again).
+
+**Example 1:**
+
+```
+Input: [7,1,5,3,6,4]
+Output: 7
+Explanation: Buy on day 2 (price = 1) and sell on day 3 (price = 5), profit = 5-1 = 4.
+             Then buy on day 4 (price = 3) and sell on day 5 (price = 6), profit = 6-3 = 3.
+```
+
+**Example 2:**
+
+```
+Input: [1,2,3,4,5]
+Output: 4
+Explanation: Buy on day 1 (price = 1) and sell on day 5 (price = 5), profit = 5-1 = 4.
+             Note that you cannot buy on day 1, buy on day 2 and sell them later, as you are
+             engaging multiple transactions at the same time. You must sell before buying again.
+```
+
+**Example 3:**
+
+```
+Input: [7,6,4,3,1]
+Output: 0
+Explanation: In this case, no transaction is done, i.e. max profit = 0.
+```
 
 **Tags:** Array, Greedy
 
diff --git a/note/543/README.md b/note/543/README.md
index 16e0c303..1a28f9ba 100644
--- a/note/543/README.md
+++ b/note/543/README.md
@@ -5,8 +5,7 @@
 Given a binary tree, you need to compute the length of the diameter of the tree. The diameter of a binary tree is the length of the **longest** path between any two nodes in a tree. This path may or may not pass through the root.
 
 **Example:**
-
-Given a binary tree
+Given a binary tree 
 
 ```
           1
@@ -14,7 +13,6 @@ Given a binary tree
         2   3
        / \     
       4   5    
-
 ```
 
 Return **3**, which is the length of the path [4,2,1,3] or [5,2,1,3].
diff --git a/src/com/blankj/medium/_008/Solution.java b/src/com/blankj/medium/_008/Solution.java
index 2e4effb2..725e1c96 100644
--- a/src/com/blankj/medium/_008/Solution.java
+++ b/src/com/blankj/medium/_008/Solution.java
@@ -17,12 +17,13 @@ public int myAtoi(String str) {
         }
         for (; i < len; ++i) {
             int tmp = str.charAt(i) - '0';
-            if (tmp < 0 || tmp > 9)
-                break;
-            if (ans > Integer.MAX_VALUE / 10 || ans == Integer.MAX_VALUE / 10 && Integer.MAX_VALUE % 10 < tmp)
+            if (tmp < 0 || tmp > 9) break;
+            if (ans > Integer.MAX_VALUE / 10
+                    || (ans == Integer.MAX_VALUE / 10 && (sign == 1 && tmp > 7 || sign == -1 && tmp > 8))) {
                 return sign == 1 ? Integer.MAX_VALUE : Integer.MIN_VALUE;
-            else
+            } else {
                 ans = ans * 10 + tmp;
+            }
         }
         return sign * ans;
     }
@@ -35,5 +36,8 @@ public static void main(String[] args) {
         System.out.println(solution.myAtoi("a1"));
         System.out.println(solution.myAtoi("100000000000000000000"));
         System.out.println(solution.myAtoi("-100000000000000000000"));
+        System.out.println(solution.myAtoi("-3924x8fc"));
+        System.out.println(solution.myAtoi(String.valueOf(Integer.MIN_VALUE)));
+        System.out.println(solution.myAtoi(String.valueOf(Integer.MAX_VALUE)));
     }
 }
\ No newline at end of file

From 2d53c020511d9b5e58ac9523a98044d1d5e57f9a Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Tue, 23 Oct 2018 19:46:20 +0800
Subject: [PATCH 45/58] update: 067

---
 note/067/README.md                     | 8 ++++----
 src/com/blankj/easy/_067/Solution.java | 4 ++--
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/note/067/README.md b/note/067/README.md
index 5620814f..e000dd25 100644
--- a/note/067/README.md
+++ b/note/067/README.md
@@ -33,18 +33,18 @@ class Solution {
         StringBuilder sb = new StringBuilder();
         int carry = 0, p1 = a.length() - 1, p2 = b.length() - 1;
         while (p1 >= 0 && p2 >= 0) {
-            carry += p1 >= 0 ? a.charAt(p1--) - '0' : 0;
-            carry += p2 >= 0 ? b.charAt(p2--) - '0' : 0;
+            carry += a.charAt(p1--) - '0';
+            carry += b.charAt(p2--) - '0';
             sb.insert(0, (char) (carry % 2 + '0'));
             carry >>= 1;
         }
         while (p1 >= 0) {
-            carry += p1 >= 0 ? a.charAt(p1--) - '0' : 0;
+            carry += a.charAt(p1--) - '0';
             sb.insert(0, (char) (carry % 2 + '0'));
             carry >>= 1;
         }
         while (p2 >= 0) {
-            carry += p2 >= 0 ? b.charAt(p2--) - '0' : 0;
+            carry += b.charAt(p2--) - '0';
             sb.insert(0, (char) (carry % 2 + '0'));
             carry >>= 1;
         }
diff --git a/src/com/blankj/easy/_067/Solution.java b/src/com/blankj/easy/_067/Solution.java
index 614cdc76..71e953b9 100644
--- a/src/com/blankj/easy/_067/Solution.java
+++ b/src/com/blankj/easy/_067/Solution.java
@@ -13,8 +13,8 @@ public String addBinary(String a, String b) {
         StringBuilder sb = new StringBuilder();
         int carry = 0, p1 = a.length() - 1, p2 = b.length() - 1;
         while (p1 >= 0 && p2 >= 0) {
-            carry += a.charAt(p1--);
-            carry += b.charAt(p2--);
+            carry += a.charAt(p1--) - '0';
+            carry += b.charAt(p2--) - '0';
             sb.insert(0, (char) (carry % 2 + '0'));
             carry >>= 1;
         }

From a5505e17f8e3a28afdc6047bddfc43b22af8d244 Mon Sep 17 00:00:00 2001
From: SCBoyChina <aidkzwm@gmail.com>
Date: Wed, 31 Oct 2018 18:01:33 +0800
Subject: [PATCH 46/58] update: 001

---
 note/001/README.md | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/note/001/README.md b/note/001/README.md
index f0224222..a93e6bc6 100644
--- a/note/001/README.md
+++ b/note/001/README.md
@@ -44,11 +44,12 @@ class Solution {
 ```java
 class Solution {
     public int[] twoSum(int[] nums, int target) {
-        int len = nums.length;
+        final int len = nums.length;
         HashMap<Integer, Integer> map = new HashMap<>();
         for (int i = 0; i < len; ++i) {
-            if (map.containsKey(nums[i])) {
-                return new int[]{map.get(nums[i]), i};
+            final Integer value = map.get(nums[i]);
+            if (value != null) {
+                return new int[] { value, i };
             }
             map.put(target - nums[i], i);
         }

From dc95795358b92f726274b8ce03c316fccaf95fcb Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Fri, 1 Feb 2019 02:12:15 +0800
Subject: [PATCH 47/58] add 030

---
 note/030/README.md                     | 61 ++++++++++++++++++++++++--
 note/031/README.md                     | 36 +++++++++++++++
 note/043/README.md                     |  6 +--
 src/com/blankj/hard/_030/Solution.java | 55 +++--------------------
 4 files changed, 103 insertions(+), 55 deletions(-)
 create mode 100644 note/031/README.md

diff --git a/note/030/README.md b/note/030/README.md
index 7d5eaa2e..d9690bce 100644
--- a/note/030/README.md
+++ b/note/030/README.md
@@ -19,8 +19,8 @@ The output order does not matter, returning [9,0] is fine too.
 
 ```
 Input:
-  s = "wordgoodstudentgoodword",
-  words = ["word","student"]
+  s = "wordgoodgoodgoodbestword",
+  words = ["word","good","best","word"]
 Output: []
 ```
 
@@ -29,10 +29,63 @@ Output: []
 
 ## 思路
 
-题意是
+题意是给自个字符串 `s` 和等长度的单词数组 `words`，我们要找到的就是在 `s` 串中由所有单词组成的子串的索引（不要求顺序），不明白的话看下例子也就理解了，比如例子 1 的结果 [0, 9]：[`barfoo`,`foobar`] 就是符合的子串。
 
-```java
+我们把 `words` 每个单词出现的次数都存入到一个 `map` 中，然后遍历 `s` 串，依次截取单词长度的子串做比较，如果都符合那就加入结果，如果不符合，我们要把和它相关联的不符合的都剔除掉，这样在之后遍历我们就可以跳过了达到优化的目的。
 
+```java
+public class Solution {
+    public List<Integer> findSubstring(String s, String[] words) {
+        if (s == null) return Collections.emptyList();
+        int len = s.length();
+        if (len == 0) return Collections.emptyList();
+        int wordsSize = words.length;
+        if (wordsSize == 0) return Collections.emptyList();
+        int wordLen = words[0].length(), end = len - wordsSize * wordLen;
+        if (end < 0) return Collections.emptyList();
+        Map<String, Integer> countMap = new HashMap<>();
+        for (String word : words) {
+            countMap.put(word, countMap.getOrDefault(word, 0) + 1);
+        }
+        List<Integer> res = new ArrayList<>();
+        Set<Integer> ignores = new HashSet<>();
+        for (int i = 0; i <= end; ++i) {
+            if (ignores.contains(i)) continue;
+            Map<String, Integer> findMap = new HashMap<>();
+            int st = i, count = 0;
+            List<Integer> ignore = new ArrayList<>();
+            for (int j = 0; ; ++j) {
+                int cur = i + j * wordLen;
+                if (cur + wordLen > len) break;
+                String word = s.substring(cur, cur + wordLen);
+                if (countMap.containsKey(word)) {
+                    findMap.put(word, findMap.getOrDefault(word, 0) + 1);
+                    ++count;
+                    while (findMap.get(word) > countMap.get(word)) {
+                        ignore.add(st);
+                        String tmp = s.substring(st, st += wordLen);
+                        findMap.put(tmp, findMap.get(tmp) - 1);
+                        --count;
+                    }
+                    if (count == wordsSize) {
+                        ignore.add(st);
+                        res.add(st);
+                        String tmp = s.substring(st, st += wordLen);
+                        findMap.put(tmp, findMap.get(tmp) - 1);
+                        --count;
+                    }
+                } else {
+                    for (int k = i; k <= cur; k += wordLen) {
+                        ignore.add(k);
+                    }
+                    break;
+                }
+            }
+            ignores.addAll(ignore);
+        }
+        return res;
+    }
+}
 ```
 
 
diff --git a/note/031/README.md b/note/031/README.md
new file mode 100644
index 00000000..f85d5f3c
--- /dev/null
+++ b/note/031/README.md
@@ -0,0 +1,36 @@
+# [Next Permutation][title]
+
+## Description
+
+Implement **next permutation**, which rearranges numbers into the lexicographically next greater permutation of numbers.
+
+If such arrangement is not possible, it must rearrange it as the lowest possible order (ie, sorted in ascending order).
+
+The replacement must be **in-place** and use only constant extra memory.
+
+Here are some examples. Inputs are in the left-hand column and its corresponding outputs are in the right-hand column.
+
+`1,2,3` → `1,3,2`
+`3,2,1` → `1,2,3`
+`1,1,5` → `1,5,1`
+
+**Tags:** Array
+
+
+## 思路
+
+题意是
+
+```java
+
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
+
+
+
+[title]: https://leetcode.com/problems/next-permutation
+[ajl]: https://github.com/Blankj/awesome-java-leetcode
diff --git a/note/043/README.md b/note/043/README.md
index 7349e208..2f40b99b 100644
--- a/note/043/README.md
+++ b/note/043/README.md
@@ -46,12 +46,12 @@ class Solution {
                 ans[i + j + 1] +=  c * (c2[j] - '0');
             }
         }
-        for (int i = l - 1; i > 0; ++i) {
+        for (int i = l - 1; i > 0; --i) {
             if (ans[i] > 9) {
                 ans[i - 1] += ans[i] / 10;
-                ans[i] %= 10;        
+                ans[i] %= 10;
             }
-         }
+        }
         StringBuilder sb = new StringBuilder();
         int i = 0;
         for (; ; ++i) if (ans[i] != 0) break;
diff --git a/src/com/blankj/hard/_030/Solution.java b/src/com/blankj/hard/_030/Solution.java
index faa50379..750652ec 100644
--- a/src/com/blankj/hard/_030/Solution.java
+++ b/src/com/blankj/hard/_030/Solution.java
@@ -18,7 +18,12 @@
  */
 public class Solution {
     public List<Integer> findSubstring(String s, String[] words) {
-        int wordsSize = words.length, wordLen = words[0].length(), end = s.length() - wordsSize * wordLen;
+        if (s == null) return Collections.emptyList();
+        int len = s.length();
+        if (len == 0) return Collections.emptyList();
+        int wordsSize = words.length;
+        if (wordsSize == 0) return Collections.emptyList();
+        int wordLen = words[0].length(), end = len - wordsSize * wordLen;
         if (end < 0) return Collections.emptyList();
         Map<String, Integer> countMap = new HashMap<>();
         for (String word : words) {
@@ -33,7 +38,7 @@ public List<Integer> findSubstring(String s, String[] words) {
             List<Integer> ignore = new ArrayList<>();
             for (int j = 0; ; ++j) {
                 int cur = i + j * wordLen;
-                if (cur + wordLen > s.length()) break;
+                if (cur + wordLen > len) break;
                 String word = s.substring(cur, cur + wordLen);
                 if (countMap.containsKey(word)) {
                     findMap.put(word, findMap.getOrDefault(word, 0) + 1);
@@ -63,52 +68,6 @@ public List<Integer> findSubstring(String s, String[] words) {
         return res;
     }
 
-//    public List<Integer> findSubstring(String S, String[] L) {
-//        List<Integer> res = new LinkedList<>();
-//        int N = S.length();
-//        int M = L.length; // *** length
-//        int wl = L[0].length();
-//        Map<String, Integer> map = new HashMap<>(), curMap = new HashMap<>();
-//        for (String s : L) {
-//            if (map.containsKey(s)) map.put(s, map.get(s) + 1);
-//            else map.put(s, 1);
-//        }
-//        String str = null, tmp = null;
-//        for (int i = 0; i < wl; i++) {
-//            int count = 0;  // remark: reset count
-//            int start = i;
-//            for (int r = i; r + wl <= N; r += wl) {
-//                str = S.substring(r, r + wl);
-//                if (map.containsKey(str)) {
-//                    if (curMap.containsKey(str)) curMap.put(str, curMap.get(str) + 1);
-//                    else curMap.put(str, 1);
-//
-//                    if (curMap.get(str) <= map.get(str)) count++;
-//                    if (count == M) {
-//                        res.add(start);
-//                        tmp = S.substring(start, start + wl);
-//                        curMap.put(tmp, curMap.get(tmp) - 1);
-//                        start += wl;
-//                        count--;
-//                    }
-//                    while (curMap.get(str) > map.get(str)) {
-//                        tmp = S.substring(start, start + wl);
-//                        curMap.put(tmp, curMap.get(tmp) - 1);
-//                        start += wl;
-//                        if (curMap.get(tmp) < map.get(tmp)) count--;
-//
-//                    }
-//                } else {
-//                    curMap.clear();
-//                    count = 0;
-//                    start = r + wl;
-//                }
-//            }
-//            curMap.clear();
-//        }
-//        return res;
-//    }
-
     public static void main(String[] args) {
         Solution solution = new Solution();
         System.out.println(solution.findSubstring("wordgoodgoodgoodbestword", new String[]{"word", "good", "best", "good"}));

From a1f6cd5a3cc60bff95187b8aff33f8e4b6af24f9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=B8=83=E5=85=B0=E6=9F=AF=E5=9F=BA?= <625783482@qq.com>
Date: Fri, 1 Feb 2019 02:19:50 +0800
Subject: [PATCH 48/58] Update README.md

upd 030
---
 note/030/README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/note/030/README.md b/note/030/README.md
index d9690bce..52e7677d 100644
--- a/note/030/README.md
+++ b/note/030/README.md
@@ -29,9 +29,9 @@ Output: []
 
 ## 思路
 
-题意是给自个字符串 `s` 和等长度的单词数组 `words`，我们要找到的就是在 `s` 串中由所有单词组成的子串的索引（不要求顺序），不明白的话看下例子也就理解了，比如例子 1 的结果 [0, 9]：[`barfoo`,`foobar`] 就是符合的子串。
+题意是给一个字符串 `s` 和等长度的单词数组 `words`，我们要找到的就是在 `s` 串中由所有单词组成的子串的索引（不要求顺序），不明白的话看下例子也就理解了，比如例子 1 的结果 [0, 9]：[`barfoo`,`foobar`] 就是符合的子串。
 
-我们把 `words` 每个单词出现的次数都存入到一个 `map` 中，然后遍历 `s` 串，依次截取单词长度的子串做比较，如果都符合那就加入结果，如果不符合，我们要把和它相关联的不符合的都剔除掉，这样在之后遍历我们就可以跳过了达到优化的目的。
+我们把 `words` 每个单词出现的次数都存入到一个 `map` 中，然后遍历 `s` 串，依次截取单词长度的子串做比较，如果都符合那就加入结果，如果不符合，我们要把和它相关联的不符合的都剔除掉，这样在之后的遍历就可以跳过该位置从而达到优化的目的。
 
 ```java
 public class Solution {

From 1a47041423b25645390e4393214234da2e648fa6 Mon Sep 17 00:00:00 2001
From: Blankj <625783482@qq.com>
Date: Thu, 25 Apr 2019 17:12:22 +0800
Subject: [PATCH 49/58] update: 001

---
 note/001/README.md                     | 2 +-
 src/com/blankj/easy/_001/Solution.java | 5 +++--
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/note/001/README.md b/note/001/README.md
index a93e6bc6..d7e9f7a8 100644
--- a/note/001/README.md
+++ b/note/001/README.md
@@ -44,7 +44,7 @@ class Solution {
 ```java
 class Solution {
     public int[] twoSum(int[] nums, int target) {
-        final int len = nums.length;
+        int len = nums.length;
         HashMap<Integer, Integer> map = new HashMap<>();
         for (int i = 0; i < len; ++i) {
             final Integer value = map.get(nums[i]);
diff --git a/src/com/blankj/easy/_001/Solution.java b/src/com/blankj/easy/_001/Solution.java
index ff0af5f4..4b0fb6cb 100644
--- a/src/com/blankj/easy/_001/Solution.java
+++ b/src/com/blankj/easy/_001/Solution.java
@@ -27,8 +27,9 @@ public int[] twoSum(int[] nums, int target) {
         int len = nums.length;
         HashMap<Integer, Integer> map = new HashMap<>();
         for (int i = 0; i < len; ++i) {
-            if (map.containsKey(nums[i])) {
-                return new int[]{map.get(nums[i]), i};
+            final Integer value = map.get(nums[i]);
+            if (value != null) {
+                return new int[] { value, i };
             }
             map.put(target - nums[i], i);
         }

From f05e6f91a18508847ffdce5f094b476714969913 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=B8=83=E5=85=B0=E6=9F=AF=E5=9F=BA?= <625783482@qq.com>
Date: Sat, 29 Jun 2019 20:30:11 +0800
Subject: [PATCH 50/58] Create FUNDING.yml

---
 .github/FUNDING.yml | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 .github/FUNDING.yml

diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
new file mode 100644
index 00000000..750e8ac8
--- /dev/null
+++ b/.github/FUNDING.yml
@@ -0,0 +1,12 @@
+# These are supported funding model platforms
+
+github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+custom: https://raw.githubusercontent.com/Blankj/AndroidUtilCode/master/art/donate.png

From 657138bfc54cc97e7dfe20ee90943ce37e7f88d0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=B8=83=E5=85=B0=E6=9F=AF=E5=9F=BA?= <625783482@qq.com>
Date: Thu, 15 Aug 2019 22:06:23 +0800
Subject: [PATCH 51/58] Update README.md

---
 README.md | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/README.md b/README.md
index d7110968..4c341669 100644
--- a/README.md
+++ b/README.md
@@ -104,6 +104,11 @@
 | 68   | [Text Justification][068]                | String                                   |
 
 
+## 打个小广告
+
+欢迎加入我的知识星球「**[基你太美](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)**」进行体验，加入后优先观看星球中精华的部分，如果觉得星球的内容对自身没有收益，你可以自行申请退款退出星球，也没必要加我好友；**如果你已确定要留在我的星球，可以通过扫描如下二维码（备注：基你太美）加我个人微信，发送给我你的星球 ID，方便我后续拉你进群(PS：进得越早价格越便宜)。**
+
+![我的二维码](https://raw.githubusercontent.com/Blankj/AndroidUtilCode/master/art/wechat.png)
 
 
 [src]: https://github.com/Blankj/awesome-java-leetcode/tree/master/src

From 0d73c0e4b88e74879ccc4be3bf6e462206711c8f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=B8=83=E5=85=B0=E6=9F=AF=E5=9F=BA?= <625783482@qq.com>
Date: Sat, 12 Oct 2019 15:16:18 +0800
Subject: [PATCH 52/58] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 4c341669..1920efdd 100644
--- a/README.md
+++ b/README.md
@@ -106,7 +106,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)**」进行体验，加入后优先观看星球中精华的部分，如果觉得星球的内容对自身没有收益，你可以自行申请退款退出星球，也没必要加我好友；**如果你已确定要留在我的星球，可以通过扫描如下二维码（备注：基你太美）加我个人微信，发送给我你的星球 ID，方便我后续拉你进群(PS：进得越早价格越便宜)。**
+欢迎加入我的知识星球「**[基你太美](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://raw.githubusercontent.com/Blankj/AndroidUtilCode/master/art/wechat.png)
 

From 867dc3136eb0d3c92812519cec8ec2a66231d088 Mon Sep 17 00:00:00 2001
From: Blankj <blankj@qq.com>
Date: Thu, 18 Jun 2020 11:39:06 +0800
Subject: [PATCH 53/58] add 1014

---
 README.md                                 |  2 +
 note/1014/README.md                       | 60 +++++++++++++++++++++++
 src/com/blankj/medium/_1014/Solution.java | 27 ++++++++++
 3 files changed, 89 insertions(+)
 create mode 100644 note/1014/README.md
 create mode 100644 src/com/blankj/medium/_1014/Solution.java

diff --git a/README.md b/README.md
index 1920efdd..83306127 100644
--- a/README.md
+++ b/README.md
@@ -88,6 +88,7 @@
 | 50   | [Pow(x, n)][050]                         | Math, Binary Search              |
 | 56   | [Merge Intervals][056]                   | Array, Sort                      |
 | 554  | [Brick Wall][554]                        | Hash Table                       |
+| 1014 | [最佳观光组合][1014]                       | 数组                              |
 
 
 ## Hard
@@ -170,6 +171,7 @@
 [050]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/050/README.md
 [056]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/056/README.md
 [554]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/554/README.md
+[1014]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/1014/README.md
 
 [004]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/004/README.md
 [010]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/010/README.md
diff --git a/note/1014/README.md b/note/1014/README.md
new file mode 100644
index 00000000..61a05d0a
--- /dev/null
+++ b/note/1014/README.md
@@ -0,0 +1,60 @@
+# [最佳观光组合][title]
+
+## 题目描述
+
+给定正整数数组 `A`，`A[i]` 表示第 `i` 个观光景点的评分，并且两个景点 `i` 和 `j` 之间的距离为 `j - i`。
+
+一对景点（`i < j`）组成的观光组合的得分为（`A[i] + A[j] + i - j`）：景点的评分之和**减去**它们两者之间的距离。
+
+返回一对观光景点能取得的最高分。
+
+**示例：**
+
+```
+输入：[8,1,5,2,6]
+输出：11
+解释：i = 0, j = 2, A[i] + A[j] + i - j = 8 + 5 + 0 - 2 = 11
+```
+
+**提示：**
+
+1.  `2 <= A.length <= 50000`
+2.  `1 <= A[i] <= 1000`
+
+**标签：** 数组
+
+
+## 思路
+
+直接暴力两层 for 循环肯定过不了关，我们把公式变化为 `(A[i] + i) + (A[j] - j)`，看到此应该就可以想到在每次遍历 `j` 时，只需要知道 `max(A[i] + i)` 即可。
+
+```java
+class Solution {
+
+    public int maxScoreSightseeingPair(int[] A) {
+        int ans = 0, cur = A[0] + 0;
+        for (int j = 1; j < A.length; j++) {
+            ans = Math.max(ans, cur + A[j] - j); // 计算当前最大得分
+            cur = Math.max(cur, A[j] + j);       // 更新最大的 A[i] + i
+        }
+        return ans;
+    }
+
+    public static void main(String[] args) {
+        Solution solution = new Solution();
+        int[] A = new int[]{8, 1, 5, 2, 6};
+        System.out.println(solution.maxScoreSightseeingPair(A));
+    }
+}
+
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
+
+
+
+[title]: https://leetcode-cn.com/problems/best-sightseeing-pair/
+[ajl]: https://github.com/Blankj/awesome-java-leetcode
diff --git a/src/com/blankj/medium/_1014/Solution.java b/src/com/blankj/medium/_1014/Solution.java
new file mode 100644
index 00000000..fa0ece30
--- /dev/null
+++ b/src/com/blankj/medium/_1014/Solution.java
@@ -0,0 +1,27 @@
+package com.blankj.medium._1014;
+
+/**
+ * <pre>
+ *     author: Blankj
+ *     blog  : http://blankj.com
+ *     time  : 2020/06/18
+ *     desc  :
+ * </pre>
+ */
+public class Solution {
+
+    public int maxScoreSightseeingPair(int[] A) {
+        int ans = 0, cur = A[0] + 0;
+        for (int j = 1; j < A.length; j++) {
+            ans = Math.max(ans, cur + A[j] - j); // 计算当前最大得分
+            cur = Math.max(cur, A[j] + j);       // 更新最大的 A[i] + i
+        }
+        return ans;
+    }
+
+    public static void main(String[] args) {
+        Solution solution = new Solution();
+        int[] A = new int[]{8, 1, 5, 2, 6};
+        System.out.println(solution.maxScoreSightseeingPair(A));
+    }
+}

From dbe51e8172d48df200076af2ff003f2a8a04f366 Mon Sep 17 00:00:00 2001
From: Blankj <blankj@qq.com>
Date: Mon, 29 Jun 2020 21:24:51 +0800
Subject: [PATCH 54/58] add 1028

---
 README.md                                     | 273 +++++++++---------
 note/{001 => 0001}/README.md                  |   0
 note/{002 => 0002}/README.md                  |   0
 note/{003 => 0003}/README.md                  |   0
 note/{004 => 0004}/README.md                  |   0
 note/{004 => 0004}/my_draw.jpg                | Bin
 note/{005 => 0005}/README.md                  |   0
 note/{006 => 0006}/README.md                  |   0
 note/{007 => 0007}/README.md                  |   0
 note/{008 => 0008}/README.md                  |   0
 note/{009 => 0009}/README.md                  |   0
 note/{010 => 0010}/README.md                  |   0
 note/{011 => 0011}/README.md                  |   0
 note/{011 => 0011}/water.png                  | Bin
 note/{012 => 0012}/README.md                  |   0
 note/{013 => 0013}/README.md                  |   0
 note/{014 => 0014}/README.md                  |   0
 note/{015 => 0015}/README.md                  |   0
 note/{016 => 0016}/README.md                  |   0
 note/{017 => 0017}/README.md                  |   0
 note/{018 => 0018}/README.md                  |   0
 note/{019 => 0019}/README.md                  |   0
 note/{020 => 0020}/README.md                  |   0
 note/{021 => 0021}/README.md                  |   0
 note/{022 => 0022}/README.md                  |   0
 note/{023 => 0023}/README.md                  |   0
 note/{024 => 0024}/README.md                  |   0
 note/{025 => 0025}/README.md                  |   0
 note/{026 => 0026}/README.md                  |   0
 note/{027 => 0027}/README.md                  |   0
 note/{028 => 0028}/README.md                  |   0
 note/{029 => 0029}/README.md                  |   0
 note/{030 => 0030}/README.md                  |   0
 note/{031 => 0031}/README.md                  |   0
 note/{033 => 0033}/README.md                  |   0
 note/{035 => 0035}/README.md                  |   0
 note/{038 => 0038}/README.md                  |   0
 note/{043 => 0043}/README.md                  |   0
 note/{044 => 0044}/README.md                  |   0
 note/{049 => 0049}/README.md                  |   0
 note/{050 => 0050}/README.md                  |   0
 note/{053 => 0053}/README.md                  |   0
 note/{056 => 0056}/README.md                  |   0
 note/{057 => 0057}/README.md                  |   0
 note/{058 => 0058}/README.md                  |   0
 note/{066 => 0066}/README.md                  |   0
 note/{067 => 0067}/README.md                  |   0
 note/{068 => 0068}/README.md                  |   0
 note/{069 => 0069}/README.md                  |   0
 note/{070 => 0070}/README.md                  |   0
 note/{083 => 0083}/README.md                  |   0
 note/{088 => 0088}/README.md                  |   0
 note/{100 => 0100}/README.md                  |   0
 note/{101 => 0101}/README.md                  |   0
 note/{104 => 0104}/README.md                  |   0
 note/{107 => 0107}/README.md                  |   0
 note/{108 => 0108}/README.md                  |   0
 note/{110 => 0110}/README.md                  |   0
 note/{111 => 0111}/README.md                  |   0
 note/{112 => 0112}/README.md                  |   0
 note/{118 => 0118}/README.md                  |   0
 note/{119 => 0119}/README.md                  |   0
 note/{121 => 0121}/README.md                  |   0
 note/{122 => 0122}/README.md                  |   0
 note/0209/README.md                           |  81 ++++++
 note/{543 => 0543}/README.md                  |   0
 note/{554 => 0554}/README.md                  |   0
 note/1014/README.md                           |   4 +-
 note/1028/README.md                           | 148 ++++++++++
 .../blankj/easy/{_001 => _0001}/Solution.java |   0
 .../blankj/easy/{_007 => _0007}/Solution.java |   0
 .../blankj/easy/{_009 => _0009}/Solution.java |   0
 .../blankj/easy/{_013 => _0013}/Solution.java |   0
 .../blankj/easy/{_014 => _0014}/Solution.java |   0
 .../blankj/easy/{_020 => _0020}/Solution.java |   0
 .../blankj/easy/{_021 => _0021}/Solution.java |   0
 .../blankj/easy/{_026 => _0026}/Solution.java |   0
 .../blankj/easy/{_027 => _0027}/Solution.java |   0
 .../blankj/easy/{_028 => _0028}/Solution.java |   0
 .../blankj/easy/{_035 => _0035}/Solution.java |   0
 .../blankj/easy/{_038 => _0038}/Solution.java |   0
 .../blankj/easy/{_053 => _0053}/Solution.java |   0
 .../blankj/easy/{_058 => _0058}/Solution.java |   0
 .../blankj/easy/{_066 => _0066}/Solution.java |   0
 .../blankj/easy/{_067 => _0067}/Solution.java |   0
 .../blankj/easy/{_069 => _0069}/Solution.java |   0
 .../blankj/easy/{_070 => _0070}/Solution.java |   0
 .../blankj/easy/{_083 => _0083}/Solution.java |   0
 .../blankj/easy/{_088 => _0088}/Solution.java |   0
 .../blankj/easy/{_100 => _0100}/Solution.java |   0
 .../blankj/easy/{_101 => _0101}/Solution.java |   0
 .../blankj/easy/{_104 => _0104}/Solution.java |   0
 .../blankj/easy/{_107 => _0107}/Solution.java |   0
 .../blankj/easy/{_108 => _0108}/Solution.java |   0
 .../blankj/easy/{_110 => _0110}/Solution.java |   0
 .../blankj/easy/{_111 => _0111}/Solution.java |   0
 .../blankj/easy/{_112 => _0112}/Solution.java |   0
 .../blankj/easy/{_118 => _0118}/Solution.java |   0
 .../blankj/easy/{_119 => _0119}/Solution.java |   0
 .../blankj/easy/{_121 => _0121}/Solution.java |   0
 .../blankj/easy/{_122 => _0122}/Solution.java |   0
 .../blankj/easy/{_543 => _0543}/Solution.java |   0
 .../blankj/hard/{_004 => _0004}/Solution.java |   0
 .../blankj/hard/{_010 => _0010}/Solution.java |   0
 .../blankj/hard/{_023 => _0023}/Solution.java |   0
 .../blankj/hard/{_025 => _0025}/Solution.java |   0
 .../blankj/hard/{_030 => _0030}/Solution.java |   0
 .../blankj/hard/{_044 => _0044}/Solution.java |   0
 .../blankj/hard/{_068 => _0068}/Solution.java |   0
 src/com/blankj/hard/_1028/Solution.java       |  80 +++++
 .../medium/{_002 => _0002}/Solution.java      |   0
 .../medium/{_003 => _0003}/Solution.java      |   0
 .../medium/{_005 => _0005}/Solution.java      |   0
 .../medium/{_006 => _0006}/Solution.java      |   0
 .../medium/{_008 => _0008}/Solution.java      |   0
 .../medium/{_011 => _0011}/Solution.java      |   0
 .../medium/{_012 => _0012}/Solution.java      |   0
 .../medium/{_015 => _0015}/Solution.java      |   0
 .../medium/{_016 => _0016}/Solution.java      |   0
 .../medium/{_017 => _0017}/Solution.java      |   0
 .../medium/{_018 => _0018}/Solution.java      |   0
 .../medium/{_019 => _0019}/Solution.java      |   0
 .../medium/{_022 => _0022}/Solution.java      |   0
 .../medium/{_024 => _0024}/Solution.java      |   0
 .../medium/{_029 => _0029}/Solution.java      |   0
 .../medium/{_033 => _0033}/Solution.java      |   0
 .../medium/{_043 => _0043}/Solution.java      |   0
 .../medium/{_049 => _0049}/Solution.java      |   0
 .../medium/{_050 => _0050}/Solution.java      |   0
 .../medium/{_056 => _0056}/Solution.java      |   0
 .../medium/{_057 => _0057}/Solution.java      |   0
 .../medium/{_554 => _0554}/Solution.java      |   0
 132 files changed, 447 insertions(+), 139 deletions(-)
 rename note/{001 => 0001}/README.md (100%)
 rename note/{002 => 0002}/README.md (100%)
 rename note/{003 => 0003}/README.md (100%)
 rename note/{004 => 0004}/README.md (100%)
 rename note/{004 => 0004}/my_draw.jpg (100%)
 rename note/{005 => 0005}/README.md (100%)
 rename note/{006 => 0006}/README.md (100%)
 rename note/{007 => 0007}/README.md (100%)
 rename note/{008 => 0008}/README.md (100%)
 rename note/{009 => 0009}/README.md (100%)
 rename note/{010 => 0010}/README.md (100%)
 rename note/{011 => 0011}/README.md (100%)
 rename note/{011 => 0011}/water.png (100%)
 rename note/{012 => 0012}/README.md (100%)
 rename note/{013 => 0013}/README.md (100%)
 rename note/{014 => 0014}/README.md (100%)
 rename note/{015 => 0015}/README.md (100%)
 rename note/{016 => 0016}/README.md (100%)
 rename note/{017 => 0017}/README.md (100%)
 rename note/{018 => 0018}/README.md (100%)
 rename note/{019 => 0019}/README.md (100%)
 rename note/{020 => 0020}/README.md (100%)
 rename note/{021 => 0021}/README.md (100%)
 rename note/{022 => 0022}/README.md (100%)
 rename note/{023 => 0023}/README.md (100%)
 rename note/{024 => 0024}/README.md (100%)
 rename note/{025 => 0025}/README.md (100%)
 rename note/{026 => 0026}/README.md (100%)
 rename note/{027 => 0027}/README.md (100%)
 rename note/{028 => 0028}/README.md (100%)
 rename note/{029 => 0029}/README.md (100%)
 rename note/{030 => 0030}/README.md (100%)
 rename note/{031 => 0031}/README.md (100%)
 rename note/{033 => 0033}/README.md (100%)
 rename note/{035 => 0035}/README.md (100%)
 rename note/{038 => 0038}/README.md (100%)
 rename note/{043 => 0043}/README.md (100%)
 rename note/{044 => 0044}/README.md (100%)
 rename note/{049 => 0049}/README.md (100%)
 rename note/{050 => 0050}/README.md (100%)
 rename note/{053 => 0053}/README.md (100%)
 rename note/{056 => 0056}/README.md (100%)
 rename note/{057 => 0057}/README.md (100%)
 rename note/{058 => 0058}/README.md (100%)
 rename note/{066 => 0066}/README.md (100%)
 rename note/{067 => 0067}/README.md (100%)
 rename note/{068 => 0068}/README.md (100%)
 rename note/{069 => 0069}/README.md (100%)
 rename note/{070 => 0070}/README.md (100%)
 rename note/{083 => 0083}/README.md (100%)
 rename note/{088 => 0088}/README.md (100%)
 rename note/{100 => 0100}/README.md (100%)
 rename note/{101 => 0101}/README.md (100%)
 rename note/{104 => 0104}/README.md (100%)
 rename note/{107 => 0107}/README.md (100%)
 rename note/{108 => 0108}/README.md (100%)
 rename note/{110 => 0110}/README.md (100%)
 rename note/{111 => 0111}/README.md (100%)
 rename note/{112 => 0112}/README.md (100%)
 rename note/{118 => 0118}/README.md (100%)
 rename note/{119 => 0119}/README.md (100%)
 rename note/{121 => 0121}/README.md (100%)
 rename note/{122 => 0122}/README.md (100%)
 create mode 100644 note/0209/README.md
 rename note/{543 => 0543}/README.md (100%)
 rename note/{554 => 0554}/README.md (100%)
 create mode 100644 note/1028/README.md
 rename src/com/blankj/easy/{_001 => _0001}/Solution.java (100%)
 rename src/com/blankj/easy/{_007 => _0007}/Solution.java (100%)
 rename src/com/blankj/easy/{_009 => _0009}/Solution.java (100%)
 rename src/com/blankj/easy/{_013 => _0013}/Solution.java (100%)
 rename src/com/blankj/easy/{_014 => _0014}/Solution.java (100%)
 rename src/com/blankj/easy/{_020 => _0020}/Solution.java (100%)
 rename src/com/blankj/easy/{_021 => _0021}/Solution.java (100%)
 rename src/com/blankj/easy/{_026 => _0026}/Solution.java (100%)
 rename src/com/blankj/easy/{_027 => _0027}/Solution.java (100%)
 rename src/com/blankj/easy/{_028 => _0028}/Solution.java (100%)
 rename src/com/blankj/easy/{_035 => _0035}/Solution.java (100%)
 rename src/com/blankj/easy/{_038 => _0038}/Solution.java (100%)
 rename src/com/blankj/easy/{_053 => _0053}/Solution.java (100%)
 rename src/com/blankj/easy/{_058 => _0058}/Solution.java (100%)
 rename src/com/blankj/easy/{_066 => _0066}/Solution.java (100%)
 rename src/com/blankj/easy/{_067 => _0067}/Solution.java (100%)
 rename src/com/blankj/easy/{_069 => _0069}/Solution.java (100%)
 rename src/com/blankj/easy/{_070 => _0070}/Solution.java (100%)
 rename src/com/blankj/easy/{_083 => _0083}/Solution.java (100%)
 rename src/com/blankj/easy/{_088 => _0088}/Solution.java (100%)
 rename src/com/blankj/easy/{_100 => _0100}/Solution.java (100%)
 rename src/com/blankj/easy/{_101 => _0101}/Solution.java (100%)
 rename src/com/blankj/easy/{_104 => _0104}/Solution.java (100%)
 rename src/com/blankj/easy/{_107 => _0107}/Solution.java (100%)
 rename src/com/blankj/easy/{_108 => _0108}/Solution.java (100%)
 rename src/com/blankj/easy/{_110 => _0110}/Solution.java (100%)
 rename src/com/blankj/easy/{_111 => _0111}/Solution.java (100%)
 rename src/com/blankj/easy/{_112 => _0112}/Solution.java (100%)
 rename src/com/blankj/easy/{_118 => _0118}/Solution.java (100%)
 rename src/com/blankj/easy/{_119 => _0119}/Solution.java (100%)
 rename src/com/blankj/easy/{_121 => _0121}/Solution.java (100%)
 rename src/com/blankj/easy/{_122 => _0122}/Solution.java (100%)
 rename src/com/blankj/easy/{_543 => _0543}/Solution.java (100%)
 rename src/com/blankj/hard/{_004 => _0004}/Solution.java (100%)
 rename src/com/blankj/hard/{_010 => _0010}/Solution.java (100%)
 rename src/com/blankj/hard/{_023 => _0023}/Solution.java (100%)
 rename src/com/blankj/hard/{_025 => _0025}/Solution.java (100%)
 rename src/com/blankj/hard/{_030 => _0030}/Solution.java (100%)
 rename src/com/blankj/hard/{_044 => _0044}/Solution.java (100%)
 rename src/com/blankj/hard/{_068 => _0068}/Solution.java (100%)
 create mode 100644 src/com/blankj/hard/_1028/Solution.java
 rename src/com/blankj/medium/{_002 => _0002}/Solution.java (100%)
 rename src/com/blankj/medium/{_003 => _0003}/Solution.java (100%)
 rename src/com/blankj/medium/{_005 => _0005}/Solution.java (100%)
 rename src/com/blankj/medium/{_006 => _0006}/Solution.java (100%)
 rename src/com/blankj/medium/{_008 => _0008}/Solution.java (100%)
 rename src/com/blankj/medium/{_011 => _0011}/Solution.java (100%)
 rename src/com/blankj/medium/{_012 => _0012}/Solution.java (100%)
 rename src/com/blankj/medium/{_015 => _0015}/Solution.java (100%)
 rename src/com/blankj/medium/{_016 => _0016}/Solution.java (100%)
 rename src/com/blankj/medium/{_017 => _0017}/Solution.java (100%)
 rename src/com/blankj/medium/{_018 => _0018}/Solution.java (100%)
 rename src/com/blankj/medium/{_019 => _0019}/Solution.java (100%)
 rename src/com/blankj/medium/{_022 => _0022}/Solution.java (100%)
 rename src/com/blankj/medium/{_024 => _0024}/Solution.java (100%)
 rename src/com/blankj/medium/{_029 => _0029}/Solution.java (100%)
 rename src/com/blankj/medium/{_033 => _0033}/Solution.java (100%)
 rename src/com/blankj/medium/{_043 => _0043}/Solution.java (100%)
 rename src/com/blankj/medium/{_049 => _0049}/Solution.java (100%)
 rename src/com/blankj/medium/{_050 => _0050}/Solution.java (100%)
 rename src/com/blankj/medium/{_056 => _0056}/Solution.java (100%)
 rename src/com/blankj/medium/{_057 => _0057}/Solution.java (100%)
 rename src/com/blankj/medium/{_554 => _0554}/Solution.java (100%)

diff --git a/README.md b/README.md
index 83306127..b47c19ac 100644
--- a/README.md
+++ b/README.md
@@ -23,87 +23,85 @@
 > 非也非也，  
 > 科举为国取士，LeetCode 为 Google 筛码工，各取所需也。  
 
-
 ## Easy
 
-| #    | Title                                    | Tag                                      |
-| :--- | :--------------------------------------- | :--------------------------------------- |
-| 1    | [Two Sum][001]                           | Array, Hash Table                        |
-| 7    | [Reverse Integer][007]                   | Math                                     |
-| 9    | [Palindrome Number][009]                 | Math                                     |
-| 13   | [Roman to Integer][013]                  | Math, String                             |
-| 14   | [Longest Common Prefix][014]             | String                                   |
-| 20   | [Valid Parentheses][020]                 | Stack, String                            |
-| 21   | [Merge Two Sorted Lists][021]            | Linked List                              |
-| 26   | [Remove Duplicates from Sorted Array][026] | Array, Two Pointers                      |
-| 27   | [Remove Element][027]                    | Array, Two Pointers                      |
-| 28   | [Implement strStr()][028]                | Two Pointers, String                     |
-| 35   | [Search Insert Position][035]            | String                                   |
-| 38   | [Count and Say][038]                     | String                                   |
-| 53   | [Maximum Subarray][053]                  | Array, Divide and Conquer, Dynamic Programming |
-| 58   | [Length of Last Word][058]               | String                                   |
-| 66   | [Plus One][066]                          | Array, Math                              |
-| 67   | [Add Binary][067]                        | Math, String                             |
-| 69   | [Sqrt(x)][069]                           | Binary Search, Math                      |
-| 70   | [Climbing Stairs][070]                   | Dynamic Programming                      |
-| 83   | [Remove Duplicates from Sorted List][083] | Linked List                              |
-| 88   | [Merge Sorted Array][088]                | Array, Two Pointers                      |
-| 100  | [Same Tree][100]                         | Tree, Depth-first Search                 |
-| 101  | [Symmetric Tree][101]                    | Tree, Depth-first Search, Breadth-first Search |
-| 104  | [Maximum Depth of Binary Tree][104]      | Tree, Depth-first Search                 |
-| 107  | [Binary Tree Level Order Traversal II][107] | Tree, Breadth-first Search               |
-| 108  | [Convert Sorted Array to Binary Search Tree][108] | Tree, Depth-first Search                 |
-| 110  | [Balanced Binary Tree][110]              | Tree, Depth-first Search                 |
-| 111  | [Minimum Depth of Binary Tree][111]      | Tree, Depth-first Search, Breadth-first Search |
-| 112  | [Path Sum][112]                          | Tree, Depth-first Search                 |
-| 118  | [Pascal's Triangle][118]                 | Array                                    |
-| 119  | [Pascal's Triangle II][119]              | Array                                    |
-| 121  | [Best Time to Buy and Sell Stock][121]   | Array, Dynamic Programmin                |
-| 122  | [Best Time to Buy and Sell Stock II][122] | Array, Greedy                            |
-| 543  | [Diameter of Binary Tree][543]           | Tree                                     |
-
+| #    | Title                                                             | Tag                                               |
+| :--- | :---------------------------------------------------------------- | :------------------------------------------------ |
+| 1    | [Two Sum][0001]                                                   | Array, Hash Table                                 |
+| 7    | [Reverse Integer][0007]                                           | Math                                              |
+| 9    | [Palindrome Number][0009]                                         | Math                                              |
+| 13   | [Roman to Integer][0013]                                          | Math, String                                      |
+| 14   | [Longest Common Prefix][0014]                                     | String                                            |
+| 20   | [Valid Parentheses][0020]                                         | Stack, String                                     |
+| 21   | [Merge Two Sorted Lists][0021]                                    | Linked List                                       |
+| 26   | [Remove Duplicates from Sorted Array][0026]                       | Array, Two Pointers                               |
+| 27   | [Remove Element][0027]                                            | Array, Two Pointers                               |
+| 28   | [Implement strStr()][0028]                                        | Two Pointers, String                              |
+| 35   | [Search Insert Position][0035]                                    | String                                            |
+| 38   | [Count and Say][0038]                                             | String                                            |
+| 53   | [Maximum Subarray][0053]                                          | Array, Divide and Conquer, Dynamic Programming    |
+| 58   | [Length of Last Word][0058]                                       | String                                            |
+| 66   | [Plus One][0066]                                                  | Array, Math                                       |
+| 67   | [Add Binary][0067]                                                | Math, String                                      |
+| 69   | [Sqrt(x)][0069]                                                   | Binary Search, Math                               |
+| 70   | [Climbing Stairs][0070]                                           | Dynamic Programming                               |
+| 83   | [Remove Duplicates from Sorted List][0083]                        | Linked List                                       |
+| 88   | [Merge Sorted Array][0088]                                        | Array, Two Pointers                               |
+| 100  | [Same Tree][0100]                                                 | Tree, Depth-first Search                          |
+| 101  | [Symmetric Tree][0101]                                            | Tree, Depth-first Search, Breadth-first Search    |
+| 104  | [Maximum Depth of Binary Tree][0104]                              | Tree, Depth-first Search                          |
+| 107  | [Binary Tree Level Order Traversal II][107]                       | Tree, Breadth-first Search                        |
+| 108  | [Convert Sorted Array to Binary Search Tree][0108]                | Tree, Depth-first Search                          |
+| 110  | [Balanced Binary Tree][0110]                                      | Tree, Depth-first Search                          |
+| 111  | [Minimum Depth of Binary Tree][0111]                              | Tree, Depth-first Search, Breadth-first Search    |
+| 112  | [Path Sum][0112]                                                  | Tree, Depth-first Search                          |
+| 118  | [Pascal's Triangle][0118]                                         | Array                                             |
+| 119  | [Pascal's Triangle II][0119]                                      | Array                                             |
+| 121  | [Best Time to Buy and Sell Stock][0121]                           | Array, Dynamic Programmin                         |
+| 122  | [Best Time to Buy and Sell Stock II][0122]                        | Array, Greedy                                     |
+| 543  | [Diameter of Binary Tree][0543]                                   | Tree                                              |
 
 ## Medium
 
-| #    | Title                                    | Tag                              |
-| :--- | :--------------------------------------- | :------------------------------- |
-| 2    | [Add Two Numbers][002]                   | Linked List, Math                |
-| 3    | [Longest Substring Without Repeating Characters][003] | Hash Table, Two Pointers, String |
-| 5    | [Longest Palindromic Substring][005]     | String, Dynamic Programming      |
-| 6    | [ZigZag Conversion][006]                 | String                           |
-| 8    | [String to Integer (atoi)][008]          | Math, String                     |
-| 11   | [Container With Most Water][011]         | Array, Two Pointers              |
-| 12   | [Integer to Roman][012]                  | Math, String                     |
-| 15   | [3Sum][015]                              | Array, Two Pointers              |
-| 15   | [3Sum Closest][016]                      | Array, Two Pointers              |
-| 17   | [Letter Combinations of a Phone Number][017] | String, Backtracking             |
-| 18   | [4Sum][018]                              | Array, Hash Table, Two Pointers  |
-| 19   | [Remove Nth Node From End of List][019]  | Linked List, Two Pointers        |
-| 22   | [Generate Parentheses][022]              | String, Backtracking             |
-| 24   | [Swap Nodes in Pairs][024]               | Linked List                      |
-| 29   | [Divide Two Integers][029]               | Math, Binary Search              |
-| 33   | [Search in Rotated Sorted Array][033]    | Arrays, Binary Search            |
-| 43   | [Multiply Strings][043]                  | Math, String                     |
-| 49   | [Group Anagrams][049]                    | Hash Table, String               |
-| 50   | [Pow(x, n)][050]                         | Math, Binary Search              |
-| 56   | [Merge Intervals][056]                   | Array, Sort                      |
-| 554  | [Brick Wall][554]                        | Hash Table                       |
-| 1014 | [最佳观光组合][1014]                       | 数组                              |
-
+| #    | Title                                                             | Tag                                               |
+| :--- | :---------------------------------------------------------------- | :------------------------------------------------ |
+| 2    | [Add Two Numbers][0002]                                           | Linked List, Math                                 |
+| 3    | [Longest Substring Without Repeating Characters][0003]            | Hash Table, Two Pointers, String                  |
+| 5    | [Longest Palindromic Substring][0005]                             | String, Dynamic Programming                       |
+| 6    | [ZigZag Conversion][0006]                                         | String                                            |
+| 8    | [String to Integer (atoi)][0008]                                  | Math, String                                      |
+| 11   | [Container With Most Water][0011]                                 | Array, Two Pointers                               |
+| 12   | [Integer to Roman][0012]                                          | Math, String                                      |
+| 15   | [3Sum][0015]                                                      | Array, Two Pointers                               |
+| 15   | [3Sum Closest][0016]                                              | Array, Two Pointers                               |
+| 17   | [Letter Combinations of a Phone Number][0017]                     | String, Backtracking                              |
+| 18   | [4Sum][0018]                                                      | Array, Hash Table, Two Pointers                   |
+| 19   | [Remove Nth Node From End of List][0019]                          | Linked List, Two Pointers                         |
+| 22   | [Generate Parentheses][0022]                                      | String, Backtracking                              |
+| 24   | [Swap Nodes in Pairs][0024]                                       | Linked List                                       |
+| 29   | [Divide Two Integers][0029]                                       | Math, Binary Search                               |
+| 33   | [Search in Rotated Sorted Array][0033]                            | Arrays, Binary Search                             |
+| 43   | [Multiply Strings][0043]                                          | Math, String                                      |
+| 49   | [Group Anagrams][0049]                                            | Hash Table, String                                |
+| 50   | [Pow(x, n)][0050]                                                 | Math, Binary Search                               |
+| 56   | [Merge Intervals][0056]                                           | Array, Sort                                       |
+| 209  | [长度最小的子数组(Minimum Size Subarray Sum)][0209]                 | Array, Sort                                       |
+| 554  | [Brick Wall][0554]                                                | Hash Table                                        |
+| 1014 | [最佳观光组合(Best Sightseeing Pair)][1014]                         | 数组                                              |
 
 ## Hard
 
-| #    | Title                                    | Tag                                      |
-| :--- | :--------------------------------------- | :--------------------------------------- |
-| 4    | [Median of Two Sorted Arrays][004]       | Array, Binary Search, Divide and Conquer |
-| 10   | [Regular Expression Matching][010]       | String, Dynamic Programming, Backtracking |
-| 23   | [Merge k Sorted Lists][023]              | Linked List, Divide and Conquer, Heap    |
-| 25   | [Reverse Nodes in k-Group][025]          | Linked List                              |
-| 30   | [Substring with Concatenation of All Words][030] | Hash Table, Two Pointers, String         |
-| 44   | [Wildcard Matching][044]                 | String, Dynamic Programming, Backtracking, Greedy |
-| 57   | [Insert Interval][057]                   | Array, Sort                              |
-| 68   | [Text Justification][068]                | String                                   |
-
+| #    | Title                                                             | Tag                                               |
+| :--- | :---------------------------------------------------------------- | :------------------------------------------------ |
+| 4    | [Median of Two Sorted Arrays][0004]                               | Array, Binary Search, Divide and Conquer          |
+| 10   | [Regular Expression Matching][0010]                               | String, Dynamic Programming, Backtracking         |
+| 23   | [Merge k Sorted Lists][0023]                                      | Linked List, Divide and Conquer, Heap             |
+| 25   | [Reverse Nodes in k-Group][0025]                                  | Linked List                                       |
+| 30   | [Substring with Concatenation of All Words][0030]                 | Hash Table, Two Pointers, String                  |
+| 44   | [Wildcard Matching][0044]                                         | String, Dynamic Programming, Backtracking, Greedy |
+| 57   | [Insert Interval][0057]                                           | Array, Sort                                       |
+| 68   | [Text Justification][0068]                                        | String                                            |
+| 1028 | [从先序遍历还原二叉树(Recover a Tree From Preorder Traversal)][1028] | 树、深度优先搜索                                    |
 
 ## 打个小广告
 
@@ -116,68 +114,69 @@
 [note]: https://github.com/Blankj/awesome-java-leetcode/tree/master/note
 [companies]: https://github.com/Blankj/awesome-java-leetcode/blob/master/Companies.md
 
-[001]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/001/README.md
-[007]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/007/README.md
-[009]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/009/README.md
-[013]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/013/README.md
-[014]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/014/README.md
-[020]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/020/README.md
-[021]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/021/README.md
-[026]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/026/README.md
-[027]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/027/README.md
-[028]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/028/README.md
-[035]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/035/README.md
-[038]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/038/README.md
-[053]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/053/README.md
-[058]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/058/README.md
-[066]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/066/README.md
-[067]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/067/README.md
-[069]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/069/README.md
-[070]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/070/README.md
-[083]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/083/README.md
-[088]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/088/README.md
-[100]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/100/README.md
-[101]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/101/README.md
-[104]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/104/README.md
-[107]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/107/README.md
-[108]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/108/README.md
-[110]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/110/README.md
-[111]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/111/README.md
-[112]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/112/README.md
-[118]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/118/README.md
-[119]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/119/README.md
-[121]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/121/README.md
-[122]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/122/README.md
-[543]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/543/README.md
-
-[002]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/002/README.md
-[003]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/003/README.md
-[005]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/005/README.md
-[006]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/006/README.md
-[008]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/008/README.md
-[011]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/011/README.md
-[012]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/012/README.md
-[015]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/015/README.md
-[016]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/016/README.md
-[017]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/017/README.md
-[018]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/018/README.md
-[019]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/019/README.md
-[022]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/022/README.md
-[024]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/024/README.md
-[029]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/029/README.md
-[033]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/033/README.md
-[043]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/043/README.md
-[049]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/049/README.md
-[050]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/050/README.md
-[056]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/056/README.md
-[554]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/554/README.md
+[0001]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0001/README.md
+[0007]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0007/README.md
+[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
+[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
+[0027]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0027/README.md
+[0028]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0028/README.md
+[0035]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0035/README.md
+[0038]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0038/README.md
+[0053]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0053/README.md
+[0058]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0058/README.md
+[0066]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0066/README.md
+[0067]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0067/README.md
+[0069]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0069/README.md
+[0070]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0070/README.md
+[0083]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0083/README.md
+[0088]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0088/README.md
+[0100]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0100/README.md
+[0101]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0101/README.md
+[0104]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0104/README.md
+[0107]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0107/README.md
+[0108]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0108/README.md
+[0110]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0110/README.md
+[0111]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0111/README.md
+[0112]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0112/README.md
+[0118]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0118/README.md
+[0119]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0119/README.md
+[0121]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0121/README.md
+[0122]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0122/README.md
+[0543]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0543/README.md
+
+[0002]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0002/README.md
+[0003]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0003/README.md
+[0005]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0005/README.md
+[0006]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0006/README.md
+[0008]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0008/README.md
+[0011]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0011/README.md
+[0012]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0012/README.md
+[0015]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0015/README.md
+[0016]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0016/README.md
+[0017]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0017/README.md
+[0018]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0018/README.md
+[0019]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0019/README.md
+[0022]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0022/README.md
+[0024]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0024/README.md
+[0029]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0029/README.md
+[0033]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0033/README.md
+[0043]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0043/README.md
+[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
+[0554]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0554/README.md
 [1014]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/1014/README.md
-
-[004]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/004/README.md
-[010]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/010/README.md
-[023]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/023/README.md
-[025]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/025/README.md
-[030]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/030/README.md
-[044]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/044/README.md
-[057]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/057/README.md
-[068]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/068/README.md
+[0004]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0004/README.md
+[0010]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0010/README.md
+
+[0023]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0023/README.md
+[0025]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0025/README.md
+[0030]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0030/README.md
+[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
diff --git a/note/001/README.md b/note/0001/README.md
similarity index 100%
rename from note/001/README.md
rename to note/0001/README.md
diff --git a/note/002/README.md b/note/0002/README.md
similarity index 100%
rename from note/002/README.md
rename to note/0002/README.md
diff --git a/note/003/README.md b/note/0003/README.md
similarity index 100%
rename from note/003/README.md
rename to note/0003/README.md
diff --git a/note/004/README.md b/note/0004/README.md
similarity index 100%
rename from note/004/README.md
rename to note/0004/README.md
diff --git a/note/004/my_draw.jpg b/note/0004/my_draw.jpg
similarity index 100%
rename from note/004/my_draw.jpg
rename to note/0004/my_draw.jpg
diff --git a/note/005/README.md b/note/0005/README.md
similarity index 100%
rename from note/005/README.md
rename to note/0005/README.md
diff --git a/note/006/README.md b/note/0006/README.md
similarity index 100%
rename from note/006/README.md
rename to note/0006/README.md
diff --git a/note/007/README.md b/note/0007/README.md
similarity index 100%
rename from note/007/README.md
rename to note/0007/README.md
diff --git a/note/008/README.md b/note/0008/README.md
similarity index 100%
rename from note/008/README.md
rename to note/0008/README.md
diff --git a/note/009/README.md b/note/0009/README.md
similarity index 100%
rename from note/009/README.md
rename to note/0009/README.md
diff --git a/note/010/README.md b/note/0010/README.md
similarity index 100%
rename from note/010/README.md
rename to note/0010/README.md
diff --git a/note/011/README.md b/note/0011/README.md
similarity index 100%
rename from note/011/README.md
rename to note/0011/README.md
diff --git a/note/011/water.png b/note/0011/water.png
similarity index 100%
rename from note/011/water.png
rename to note/0011/water.png
diff --git a/note/012/README.md b/note/0012/README.md
similarity index 100%
rename from note/012/README.md
rename to note/0012/README.md
diff --git a/note/013/README.md b/note/0013/README.md
similarity index 100%
rename from note/013/README.md
rename to note/0013/README.md
diff --git a/note/014/README.md b/note/0014/README.md
similarity index 100%
rename from note/014/README.md
rename to note/0014/README.md
diff --git a/note/015/README.md b/note/0015/README.md
similarity index 100%
rename from note/015/README.md
rename to note/0015/README.md
diff --git a/note/016/README.md b/note/0016/README.md
similarity index 100%
rename from note/016/README.md
rename to note/0016/README.md
diff --git a/note/017/README.md b/note/0017/README.md
similarity index 100%
rename from note/017/README.md
rename to note/0017/README.md
diff --git a/note/018/README.md b/note/0018/README.md
similarity index 100%
rename from note/018/README.md
rename to note/0018/README.md
diff --git a/note/019/README.md b/note/0019/README.md
similarity index 100%
rename from note/019/README.md
rename to note/0019/README.md
diff --git a/note/020/README.md b/note/0020/README.md
similarity index 100%
rename from note/020/README.md
rename to note/0020/README.md
diff --git a/note/021/README.md b/note/0021/README.md
similarity index 100%
rename from note/021/README.md
rename to note/0021/README.md
diff --git a/note/022/README.md b/note/0022/README.md
similarity index 100%
rename from note/022/README.md
rename to note/0022/README.md
diff --git a/note/023/README.md b/note/0023/README.md
similarity index 100%
rename from note/023/README.md
rename to note/0023/README.md
diff --git a/note/024/README.md b/note/0024/README.md
similarity index 100%
rename from note/024/README.md
rename to note/0024/README.md
diff --git a/note/025/README.md b/note/0025/README.md
similarity index 100%
rename from note/025/README.md
rename to note/0025/README.md
diff --git a/note/026/README.md b/note/0026/README.md
similarity index 100%
rename from note/026/README.md
rename to note/0026/README.md
diff --git a/note/027/README.md b/note/0027/README.md
similarity index 100%
rename from note/027/README.md
rename to note/0027/README.md
diff --git a/note/028/README.md b/note/0028/README.md
similarity index 100%
rename from note/028/README.md
rename to note/0028/README.md
diff --git a/note/029/README.md b/note/0029/README.md
similarity index 100%
rename from note/029/README.md
rename to note/0029/README.md
diff --git a/note/030/README.md b/note/0030/README.md
similarity index 100%
rename from note/030/README.md
rename to note/0030/README.md
diff --git a/note/031/README.md b/note/0031/README.md
similarity index 100%
rename from note/031/README.md
rename to note/0031/README.md
diff --git a/note/033/README.md b/note/0033/README.md
similarity index 100%
rename from note/033/README.md
rename to note/0033/README.md
diff --git a/note/035/README.md b/note/0035/README.md
similarity index 100%
rename from note/035/README.md
rename to note/0035/README.md
diff --git a/note/038/README.md b/note/0038/README.md
similarity index 100%
rename from note/038/README.md
rename to note/0038/README.md
diff --git a/note/043/README.md b/note/0043/README.md
similarity index 100%
rename from note/043/README.md
rename to note/0043/README.md
diff --git a/note/044/README.md b/note/0044/README.md
similarity index 100%
rename from note/044/README.md
rename to note/0044/README.md
diff --git a/note/049/README.md b/note/0049/README.md
similarity index 100%
rename from note/049/README.md
rename to note/0049/README.md
diff --git a/note/050/README.md b/note/0050/README.md
similarity index 100%
rename from note/050/README.md
rename to note/0050/README.md
diff --git a/note/053/README.md b/note/0053/README.md
similarity index 100%
rename from note/053/README.md
rename to note/0053/README.md
diff --git a/note/056/README.md b/note/0056/README.md
similarity index 100%
rename from note/056/README.md
rename to note/0056/README.md
diff --git a/note/057/README.md b/note/0057/README.md
similarity index 100%
rename from note/057/README.md
rename to note/0057/README.md
diff --git a/note/058/README.md b/note/0058/README.md
similarity index 100%
rename from note/058/README.md
rename to note/0058/README.md
diff --git a/note/066/README.md b/note/0066/README.md
similarity index 100%
rename from note/066/README.md
rename to note/0066/README.md
diff --git a/note/067/README.md b/note/0067/README.md
similarity index 100%
rename from note/067/README.md
rename to note/0067/README.md
diff --git a/note/068/README.md b/note/0068/README.md
similarity index 100%
rename from note/068/README.md
rename to note/0068/README.md
diff --git a/note/069/README.md b/note/0069/README.md
similarity index 100%
rename from note/069/README.md
rename to note/0069/README.md
diff --git a/note/070/README.md b/note/0070/README.md
similarity index 100%
rename from note/070/README.md
rename to note/0070/README.md
diff --git a/note/083/README.md b/note/0083/README.md
similarity index 100%
rename from note/083/README.md
rename to note/0083/README.md
diff --git a/note/088/README.md b/note/0088/README.md
similarity index 100%
rename from note/088/README.md
rename to note/0088/README.md
diff --git a/note/100/README.md b/note/0100/README.md
similarity index 100%
rename from note/100/README.md
rename to note/0100/README.md
diff --git a/note/101/README.md b/note/0101/README.md
similarity index 100%
rename from note/101/README.md
rename to note/0101/README.md
diff --git a/note/104/README.md b/note/0104/README.md
similarity index 100%
rename from note/104/README.md
rename to note/0104/README.md
diff --git a/note/107/README.md b/note/0107/README.md
similarity index 100%
rename from note/107/README.md
rename to note/0107/README.md
diff --git a/note/108/README.md b/note/0108/README.md
similarity index 100%
rename from note/108/README.md
rename to note/0108/README.md
diff --git a/note/110/README.md b/note/0110/README.md
similarity index 100%
rename from note/110/README.md
rename to note/0110/README.md
diff --git a/note/111/README.md b/note/0111/README.md
similarity index 100%
rename from note/111/README.md
rename to note/0111/README.md
diff --git a/note/112/README.md b/note/0112/README.md
similarity index 100%
rename from note/112/README.md
rename to note/0112/README.md
diff --git a/note/118/README.md b/note/0118/README.md
similarity index 100%
rename from note/118/README.md
rename to note/0118/README.md
diff --git a/note/119/README.md b/note/0119/README.md
similarity index 100%
rename from note/119/README.md
rename to note/0119/README.md
diff --git a/note/121/README.md b/note/0121/README.md
similarity index 100%
rename from note/121/README.md
rename to note/0121/README.md
diff --git a/note/122/README.md b/note/0122/README.md
similarity index 100%
rename from note/122/README.md
rename to note/0122/README.md
diff --git a/note/0209/README.md b/note/0209/README.md
new file mode 100644
index 00000000..4c7dedcd
--- /dev/null
+++ b/note/0209/README.md
@@ -0,0 +1,81 @@
+# [长度最小的子数组][title]
+
+## 题目描述
+
+我们从二叉树的根节点 `root` 开始进行深度优先搜索。
+
+在遍历中的每个节点处，我们输出 `D` 条短划线（其中 `D` 是该节点的深度），然后输出该节点的值。（_如果节点的深度为 `D`，则其直接子节点的深度为 `D + 1`。根节点的深度为 `0`）。_
+
+如果节点只有一个子节点，那么保证该子节点为左子节点。
+
+给出遍历输出 `S`，还原树并返回其根节点 `root`。
+
+**示例 1：**
+
+**![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/04/12/recover-a-tree-from-preorder-traversal.png)**
+
+```
+输入："1-2--3--4-5--6--7"
+输出：[1,2,5,3,4,6,7]
+```
+
+**示例 2：**
+
+**![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/04/12/screen-shot-2019-04-10-at-114101-pm.png)**
+
+```
+输入："1-2--3---4-5--6---7"
+输出：[1,2,5,3,null,6,null,4,null,7]
+```
+
+**示例 3：**
+
+![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/04/12/screen-shot-2019-04-10-at-114955-pm.png)
+
+```
+输入："1-401--349---90--88"
+输出：[1,401,null,349,88,90]
+```
+
+**提示：**
+
+*   原始树中的节点数介于 `1` 和 `1000` 之间。
+*   每个节点的值介于 `1` 和 `10 ^ 9` 之间。
+
+**标签：** 树、深度优先搜索
+
+
+## 思路
+
+直接暴力两层 for 循环肯定过不了关，我们把公式变化为 `(A[i] + i) + (A[j] - j)`，看到此应该就可以想到在每次遍历 `j` 时，只需要知道 `max(A[i] + i)` 即可。
+
+```java
+class Solution {
+
+    public int maxScoreSightseeingPair(int[] A) {
+        int ans = 0, cur = A[0] + 0;
+        for (int j = 1; j < A.length; j++) {
+            ans = Math.max(ans, cur + A[j] - j); // 计算当前最大得分
+            cur = Math.max(cur, A[j] + j);       // 更新最大的 A[i] + i
+        }
+        return ans;
+    }
+
+    public static void main(String[] args) {
+        Solution solution = new Solution();
+        int[] A = new int[]{8, 1, 5, 2, 6};
+        System.out.println(solution.maxScoreSightseeingPair(A));
+    }
+}
+
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、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
diff --git a/note/543/README.md b/note/0543/README.md
similarity index 100%
rename from note/543/README.md
rename to note/0543/README.md
diff --git a/note/554/README.md b/note/0554/README.md
similarity index 100%
rename from note/554/README.md
rename to note/0554/README.md
diff --git a/note/1014/README.md b/note/1014/README.md
index 61a05d0a..34357d6c 100644
--- a/note/1014/README.md
+++ b/note/1014/README.md
@@ -1,4 +1,4 @@
-# [最佳观光组合][title]
+# [最佳观光组合(Best Sightseeing Pair)][title]
 
 ## 题目描述
 
@@ -56,5 +56,5 @@ class Solution {
 
 
 
-[title]: https://leetcode-cn.com/problems/best-sightseeing-pair/
+[title]: https://leetcode-cn.com/problems/best-sightseeing-pair
 [ajl]: https://github.com/Blankj/awesome-java-leetcode
diff --git a/note/1028/README.md b/note/1028/README.md
new file mode 100644
index 00000000..aaa185ba
--- /dev/null
+++ b/note/1028/README.md
@@ -0,0 +1,148 @@
+# [从先序遍历还原二叉树][title]
+
+## 题目描述
+
+我们从二叉树的根节点 `root` 开始进行深度优先搜索。
+
+在遍历中的每个节点处，我们输出 `D` 条短划线（其中 `D` 是该节点的深度），然后输出该节点的值。（_如果节点的深度为 `D`，则其直接子节点的深度为 `D + 1`。根节点的深度为 `0`）。_
+
+如果节点只有一个子节点，那么保证该子节点为左子节点。
+
+给出遍历输出 `S`，还原树并返回其根节点 `root`。
+
+**示例 1：**
+
+**![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/04/12/recover-a-tree-from-preorder-traversal.png)**
+
+```
+输入："1-2--3--4-5--6--7"
+输出：[1,2,5,3,4,6,7]
+```
+
+**示例 2：**
+
+**![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/04/12/screen-shot-2019-04-10-at-114101-pm.png)**
+
+```
+输入："1-2--3---4-5--6---7"
+输出：[1,2,5,3,null,6,null,4,null,7]
+```
+
+**示例 3：**
+
+![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/04/12/screen-shot-2019-04-10-at-114955-pm.png)
+
+```
+输入："1-401--349---90--88"
+输出：[1,401,null,349,88,90]
+```
+
+**提示：**
+
+*   原始树中的节点数介于 `1` 和 `1000` 之间。
+*   每个节点的值介于 `1` 和 `10 ^ 9` 之间。
+
+**标签：** 树、深度优先搜索
+
+
+## 思路 0
+
+主要就是根据先序遍历如何把树构建出来，其最主要就是找到当前待插入节点它爹，优先插入到它爹的左子节点，我们可以用一个链表来做辅助，该链表索引代表层级，元素存放其节点，由于是先序遍历（根-左-右），也就是右覆盖左时，此时左树已遍历完成，故无需考虑覆盖问题，利用该链表，我们根据层级便可轻松找到它爹，具体如下所示：
+
+```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;
+        List<TreeNode> 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);
+    }
+}
+```
+
+
+## 思路 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
diff --git a/src/com/blankj/easy/_001/Solution.java b/src/com/blankj/easy/_0001/Solution.java
similarity index 100%
rename from src/com/blankj/easy/_001/Solution.java
rename to src/com/blankj/easy/_0001/Solution.java
diff --git a/src/com/blankj/easy/_007/Solution.java b/src/com/blankj/easy/_0007/Solution.java
similarity index 100%
rename from src/com/blankj/easy/_007/Solution.java
rename to src/com/blankj/easy/_0007/Solution.java
diff --git a/src/com/blankj/easy/_009/Solution.java b/src/com/blankj/easy/_0009/Solution.java
similarity index 100%
rename from src/com/blankj/easy/_009/Solution.java
rename to src/com/blankj/easy/_0009/Solution.java
diff --git a/src/com/blankj/easy/_013/Solution.java b/src/com/blankj/easy/_0013/Solution.java
similarity index 100%
rename from src/com/blankj/easy/_013/Solution.java
rename to src/com/blankj/easy/_0013/Solution.java
diff --git a/src/com/blankj/easy/_014/Solution.java b/src/com/blankj/easy/_0014/Solution.java
similarity index 100%
rename from src/com/blankj/easy/_014/Solution.java
rename to src/com/blankj/easy/_0014/Solution.java
diff --git a/src/com/blankj/easy/_020/Solution.java b/src/com/blankj/easy/_0020/Solution.java
similarity index 100%
rename from src/com/blankj/easy/_020/Solution.java
rename to src/com/blankj/easy/_0020/Solution.java
diff --git a/src/com/blankj/easy/_021/Solution.java b/src/com/blankj/easy/_0021/Solution.java
similarity index 100%
rename from src/com/blankj/easy/_021/Solution.java
rename to src/com/blankj/easy/_0021/Solution.java
diff --git a/src/com/blankj/easy/_026/Solution.java b/src/com/blankj/easy/_0026/Solution.java
similarity index 100%
rename from src/com/blankj/easy/_026/Solution.java
rename to src/com/blankj/easy/_0026/Solution.java
diff --git a/src/com/blankj/easy/_027/Solution.java b/src/com/blankj/easy/_0027/Solution.java
similarity index 100%
rename from src/com/blankj/easy/_027/Solution.java
rename to src/com/blankj/easy/_0027/Solution.java
diff --git a/src/com/blankj/easy/_028/Solution.java b/src/com/blankj/easy/_0028/Solution.java
similarity index 100%
rename from src/com/blankj/easy/_028/Solution.java
rename to src/com/blankj/easy/_0028/Solution.java
diff --git a/src/com/blankj/easy/_035/Solution.java b/src/com/blankj/easy/_0035/Solution.java
similarity index 100%
rename from src/com/blankj/easy/_035/Solution.java
rename to src/com/blankj/easy/_0035/Solution.java
diff --git a/src/com/blankj/easy/_038/Solution.java b/src/com/blankj/easy/_0038/Solution.java
similarity index 100%
rename from src/com/blankj/easy/_038/Solution.java
rename to src/com/blankj/easy/_0038/Solution.java
diff --git a/src/com/blankj/easy/_053/Solution.java b/src/com/blankj/easy/_0053/Solution.java
similarity index 100%
rename from src/com/blankj/easy/_053/Solution.java
rename to src/com/blankj/easy/_0053/Solution.java
diff --git a/src/com/blankj/easy/_058/Solution.java b/src/com/blankj/easy/_0058/Solution.java
similarity index 100%
rename from src/com/blankj/easy/_058/Solution.java
rename to src/com/blankj/easy/_0058/Solution.java
diff --git a/src/com/blankj/easy/_066/Solution.java b/src/com/blankj/easy/_0066/Solution.java
similarity index 100%
rename from src/com/blankj/easy/_066/Solution.java
rename to src/com/blankj/easy/_0066/Solution.java
diff --git a/src/com/blankj/easy/_067/Solution.java b/src/com/blankj/easy/_0067/Solution.java
similarity index 100%
rename from src/com/blankj/easy/_067/Solution.java
rename to src/com/blankj/easy/_0067/Solution.java
diff --git a/src/com/blankj/easy/_069/Solution.java b/src/com/blankj/easy/_0069/Solution.java
similarity index 100%
rename from src/com/blankj/easy/_069/Solution.java
rename to src/com/blankj/easy/_0069/Solution.java
diff --git a/src/com/blankj/easy/_070/Solution.java b/src/com/blankj/easy/_0070/Solution.java
similarity index 100%
rename from src/com/blankj/easy/_070/Solution.java
rename to src/com/blankj/easy/_0070/Solution.java
diff --git a/src/com/blankj/easy/_083/Solution.java b/src/com/blankj/easy/_0083/Solution.java
similarity index 100%
rename from src/com/blankj/easy/_083/Solution.java
rename to src/com/blankj/easy/_0083/Solution.java
diff --git a/src/com/blankj/easy/_088/Solution.java b/src/com/blankj/easy/_0088/Solution.java
similarity index 100%
rename from src/com/blankj/easy/_088/Solution.java
rename to src/com/blankj/easy/_0088/Solution.java
diff --git a/src/com/blankj/easy/_100/Solution.java b/src/com/blankj/easy/_0100/Solution.java
similarity index 100%
rename from src/com/blankj/easy/_100/Solution.java
rename to src/com/blankj/easy/_0100/Solution.java
diff --git a/src/com/blankj/easy/_101/Solution.java b/src/com/blankj/easy/_0101/Solution.java
similarity index 100%
rename from src/com/blankj/easy/_101/Solution.java
rename to src/com/blankj/easy/_0101/Solution.java
diff --git a/src/com/blankj/easy/_104/Solution.java b/src/com/blankj/easy/_0104/Solution.java
similarity index 100%
rename from src/com/blankj/easy/_104/Solution.java
rename to src/com/blankj/easy/_0104/Solution.java
diff --git a/src/com/blankj/easy/_107/Solution.java b/src/com/blankj/easy/_0107/Solution.java
similarity index 100%
rename from src/com/blankj/easy/_107/Solution.java
rename to src/com/blankj/easy/_0107/Solution.java
diff --git a/src/com/blankj/easy/_108/Solution.java b/src/com/blankj/easy/_0108/Solution.java
similarity index 100%
rename from src/com/blankj/easy/_108/Solution.java
rename to src/com/blankj/easy/_0108/Solution.java
diff --git a/src/com/blankj/easy/_110/Solution.java b/src/com/blankj/easy/_0110/Solution.java
similarity index 100%
rename from src/com/blankj/easy/_110/Solution.java
rename to src/com/blankj/easy/_0110/Solution.java
diff --git a/src/com/blankj/easy/_111/Solution.java b/src/com/blankj/easy/_0111/Solution.java
similarity index 100%
rename from src/com/blankj/easy/_111/Solution.java
rename to src/com/blankj/easy/_0111/Solution.java
diff --git a/src/com/blankj/easy/_112/Solution.java b/src/com/blankj/easy/_0112/Solution.java
similarity index 100%
rename from src/com/blankj/easy/_112/Solution.java
rename to src/com/blankj/easy/_0112/Solution.java
diff --git a/src/com/blankj/easy/_118/Solution.java b/src/com/blankj/easy/_0118/Solution.java
similarity index 100%
rename from src/com/blankj/easy/_118/Solution.java
rename to src/com/blankj/easy/_0118/Solution.java
diff --git a/src/com/blankj/easy/_119/Solution.java b/src/com/blankj/easy/_0119/Solution.java
similarity index 100%
rename from src/com/blankj/easy/_119/Solution.java
rename to src/com/blankj/easy/_0119/Solution.java
diff --git a/src/com/blankj/easy/_121/Solution.java b/src/com/blankj/easy/_0121/Solution.java
similarity index 100%
rename from src/com/blankj/easy/_121/Solution.java
rename to src/com/blankj/easy/_0121/Solution.java
diff --git a/src/com/blankj/easy/_122/Solution.java b/src/com/blankj/easy/_0122/Solution.java
similarity index 100%
rename from src/com/blankj/easy/_122/Solution.java
rename to src/com/blankj/easy/_0122/Solution.java
diff --git a/src/com/blankj/easy/_543/Solution.java b/src/com/blankj/easy/_0543/Solution.java
similarity index 100%
rename from src/com/blankj/easy/_543/Solution.java
rename to src/com/blankj/easy/_0543/Solution.java
diff --git a/src/com/blankj/hard/_004/Solution.java b/src/com/blankj/hard/_0004/Solution.java
similarity index 100%
rename from src/com/blankj/hard/_004/Solution.java
rename to src/com/blankj/hard/_0004/Solution.java
diff --git a/src/com/blankj/hard/_010/Solution.java b/src/com/blankj/hard/_0010/Solution.java
similarity index 100%
rename from src/com/blankj/hard/_010/Solution.java
rename to src/com/blankj/hard/_0010/Solution.java
diff --git a/src/com/blankj/hard/_023/Solution.java b/src/com/blankj/hard/_0023/Solution.java
similarity index 100%
rename from src/com/blankj/hard/_023/Solution.java
rename to src/com/blankj/hard/_0023/Solution.java
diff --git a/src/com/blankj/hard/_025/Solution.java b/src/com/blankj/hard/_0025/Solution.java
similarity index 100%
rename from src/com/blankj/hard/_025/Solution.java
rename to src/com/blankj/hard/_0025/Solution.java
diff --git a/src/com/blankj/hard/_030/Solution.java b/src/com/blankj/hard/_0030/Solution.java
similarity index 100%
rename from src/com/blankj/hard/_030/Solution.java
rename to src/com/blankj/hard/_0030/Solution.java
diff --git a/src/com/blankj/hard/_044/Solution.java b/src/com/blankj/hard/_0044/Solution.java
similarity index 100%
rename from src/com/blankj/hard/_044/Solution.java
rename to src/com/blankj/hard/_0044/Solution.java
diff --git a/src/com/blankj/hard/_068/Solution.java b/src/com/blankj/hard/_0068/Solution.java
similarity index 100%
rename from src/com/blankj/hard/_068/Solution.java
rename to src/com/blankj/hard/_0068/Solution.java
diff --git a/src/com/blankj/hard/_1028/Solution.java b/src/com/blankj/hard/_1028/Solution.java
new file mode 100644
index 00000000..6089220f
--- /dev/null
+++ b/src/com/blankj/hard/_1028/Solution.java
@@ -0,0 +1,80 @@
+package com.blankj.hard._1028;
+
+import com.blankj.structure.TreeNode;
+
+import java.util.LinkedList;
+
+/**
+ * <pre>
+ *     author: Blankj
+ *     blog  : http://blankj.com
+ *     time  : 2020/06/19
+ *     desc  :
+ * </pre>
+ */
+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);
+    }
+
+//    public TreeNode recoverFromPreorder(String S) {
+//        char[] chars = S.toCharArray();
+//        int len = chars.length;
+//        List<TreeNode> 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"));
+        System.out.println("==============================================");
+        TreeNode.print(solution.recoverFromPreorder("1-2--3---4-5--6---7"));
+    }
+}
diff --git a/src/com/blankj/medium/_002/Solution.java b/src/com/blankj/medium/_0002/Solution.java
similarity index 100%
rename from src/com/blankj/medium/_002/Solution.java
rename to src/com/blankj/medium/_0002/Solution.java
diff --git a/src/com/blankj/medium/_003/Solution.java b/src/com/blankj/medium/_0003/Solution.java
similarity index 100%
rename from src/com/blankj/medium/_003/Solution.java
rename to src/com/blankj/medium/_0003/Solution.java
diff --git a/src/com/blankj/medium/_005/Solution.java b/src/com/blankj/medium/_0005/Solution.java
similarity index 100%
rename from src/com/blankj/medium/_005/Solution.java
rename to src/com/blankj/medium/_0005/Solution.java
diff --git a/src/com/blankj/medium/_006/Solution.java b/src/com/blankj/medium/_0006/Solution.java
similarity index 100%
rename from src/com/blankj/medium/_006/Solution.java
rename to src/com/blankj/medium/_0006/Solution.java
diff --git a/src/com/blankj/medium/_008/Solution.java b/src/com/blankj/medium/_0008/Solution.java
similarity index 100%
rename from src/com/blankj/medium/_008/Solution.java
rename to src/com/blankj/medium/_0008/Solution.java
diff --git a/src/com/blankj/medium/_011/Solution.java b/src/com/blankj/medium/_0011/Solution.java
similarity index 100%
rename from src/com/blankj/medium/_011/Solution.java
rename to src/com/blankj/medium/_0011/Solution.java
diff --git a/src/com/blankj/medium/_012/Solution.java b/src/com/blankj/medium/_0012/Solution.java
similarity index 100%
rename from src/com/blankj/medium/_012/Solution.java
rename to src/com/blankj/medium/_0012/Solution.java
diff --git a/src/com/blankj/medium/_015/Solution.java b/src/com/blankj/medium/_0015/Solution.java
similarity index 100%
rename from src/com/blankj/medium/_015/Solution.java
rename to src/com/blankj/medium/_0015/Solution.java
diff --git a/src/com/blankj/medium/_016/Solution.java b/src/com/blankj/medium/_0016/Solution.java
similarity index 100%
rename from src/com/blankj/medium/_016/Solution.java
rename to src/com/blankj/medium/_0016/Solution.java
diff --git a/src/com/blankj/medium/_017/Solution.java b/src/com/blankj/medium/_0017/Solution.java
similarity index 100%
rename from src/com/blankj/medium/_017/Solution.java
rename to src/com/blankj/medium/_0017/Solution.java
diff --git a/src/com/blankj/medium/_018/Solution.java b/src/com/blankj/medium/_0018/Solution.java
similarity index 100%
rename from src/com/blankj/medium/_018/Solution.java
rename to src/com/blankj/medium/_0018/Solution.java
diff --git a/src/com/blankj/medium/_019/Solution.java b/src/com/blankj/medium/_0019/Solution.java
similarity index 100%
rename from src/com/blankj/medium/_019/Solution.java
rename to src/com/blankj/medium/_0019/Solution.java
diff --git a/src/com/blankj/medium/_022/Solution.java b/src/com/blankj/medium/_0022/Solution.java
similarity index 100%
rename from src/com/blankj/medium/_022/Solution.java
rename to src/com/blankj/medium/_0022/Solution.java
diff --git a/src/com/blankj/medium/_024/Solution.java b/src/com/blankj/medium/_0024/Solution.java
similarity index 100%
rename from src/com/blankj/medium/_024/Solution.java
rename to src/com/blankj/medium/_0024/Solution.java
diff --git a/src/com/blankj/medium/_029/Solution.java b/src/com/blankj/medium/_0029/Solution.java
similarity index 100%
rename from src/com/blankj/medium/_029/Solution.java
rename to src/com/blankj/medium/_0029/Solution.java
diff --git a/src/com/blankj/medium/_033/Solution.java b/src/com/blankj/medium/_0033/Solution.java
similarity index 100%
rename from src/com/blankj/medium/_033/Solution.java
rename to src/com/blankj/medium/_0033/Solution.java
diff --git a/src/com/blankj/medium/_043/Solution.java b/src/com/blankj/medium/_0043/Solution.java
similarity index 100%
rename from src/com/blankj/medium/_043/Solution.java
rename to src/com/blankj/medium/_0043/Solution.java
diff --git a/src/com/blankj/medium/_049/Solution.java b/src/com/blankj/medium/_0049/Solution.java
similarity index 100%
rename from src/com/blankj/medium/_049/Solution.java
rename to src/com/blankj/medium/_0049/Solution.java
diff --git a/src/com/blankj/medium/_050/Solution.java b/src/com/blankj/medium/_0050/Solution.java
similarity index 100%
rename from src/com/blankj/medium/_050/Solution.java
rename to src/com/blankj/medium/_0050/Solution.java
diff --git a/src/com/blankj/medium/_056/Solution.java b/src/com/blankj/medium/_0056/Solution.java
similarity index 100%
rename from src/com/blankj/medium/_056/Solution.java
rename to src/com/blankj/medium/_0056/Solution.java
diff --git a/src/com/blankj/medium/_057/Solution.java b/src/com/blankj/medium/_0057/Solution.java
similarity index 100%
rename from src/com/blankj/medium/_057/Solution.java
rename to src/com/blankj/medium/_0057/Solution.java
diff --git a/src/com/blankj/medium/_554/Solution.java b/src/com/blankj/medium/_0554/Solution.java
similarity index 100%
rename from src/com/blankj/medium/_554/Solution.java
rename to src/com/blankj/medium/_0554/Solution.java

From 845a0df2cf9b4d77aad84771df4a058b97445fe6 Mon Sep 17 00:00:00 2001
From: Blankj <blankj@qq.com>
Date: Mon, 6 Jul 2020 13:32:03 +0800
Subject: [PATCH 55/58] add 0209

---
 README.md                                 |   7 +-
 note/0209/README.md                       | 116 +++++++++++++---------
 note/1014/README.md                       |   1 -
 src/com/blankj/hard/_1028/Solution.java   |  53 +++++-----
 src/com/blankj/medium/_0209/Solution.java |  70 +++++++++++++
 5 files changed, 172 insertions(+), 75 deletions(-)
 create mode 100644 src/com/blankj/medium/_0209/Solution.java

diff --git a/README.md b/README.md
index b47c19ac..d3d2aaff 100644
--- a/README.md
+++ b/README.md
@@ -85,7 +85,8 @@
 | 49   | [Group Anagrams][0049]                                            | Hash Table, String                                |
 | 50   | [Pow(x, n)][0050]                                                 | Math, Binary Search                               |
 | 56   | [Merge Intervals][0056]                                           | Array, Sort                                       |
-| 209  | [长度最小的子数组(Minimum Size Subarray Sum)][0209]                 | Array, Sort                                       |
+| 209  | [长度最小的子数组(Minimum Size Subarray Sum)][0209]                 | 数组、双指针、二分查找                               |
+| 215  | [数组中的第K个最大元素(Kth Largest Element in an Array)][0215]       | 堆、分治算法                                       |
 | 554  | [Brick Wall][0554]                                                | Hash Table                                        |
 | 1014 | [最佳观光组合(Best Sightseeing Pair)][1014]                         | 数组                                              |
 
@@ -168,11 +169,13 @@
 [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
+[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
 [1014]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/1014/README.md
+
 [0004]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0004/README.md
 [0010]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0010/README.md
-
 [0023]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0023/README.md
 [0025]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0025/README.md
 [0030]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/0030/README.md
diff --git a/note/0209/README.md b/note/0209/README.md
index 4c7dedcd..e0984de9 100644
--- a/note/0209/README.md
+++ b/note/0209/README.md
@@ -2,80 +2,106 @@
 
 ## 题目描述
 
-我们从二叉树的根节点 `root` 开始进行深度优先搜索。
+给定一个含有 **n** 个正整数的数组和一个正整数 **s** ，找出该数组中满足其和 **≥ s** 的长度最小的连续子数组，并返回其长度。如果不存在符合条件的连续子数组，返回 0。
 
-在遍历中的每个节点处，我们输出 `D` 条短划线（其中 `D` 是该节点的深度），然后输出该节点的值。（_如果节点的深度为 `D`，则其直接子节点的深度为 `D + 1`。根节点的深度为 `0`）。_
-
-如果节点只有一个子节点，那么保证该子节点为左子节点。
-
-给出遍历输出 `S`，还原树并返回其根节点 `root`。
-
-**示例 1：**
-
-**![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/04/12/recover-a-tree-from-preorder-traversal.png)**
+**示例：**
 
 ```
-输入："1-2--3--4-5--6--7"
-输出：[1,2,5,3,4,6,7]
+输入：s = 7, nums = [2,3,1,2,4,3]
+输出：2
+解释：子数组 [4,3] 是该条件下的长度最小的连续子数组。
 ```
 
-**示例 2：**
+**进阶：**
 
-**![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/04/12/screen-shot-2019-04-10-at-114101-pm.png)**
+* 如果你已经完成了 _O_(_n_) 时间复杂度的解法, 请尝试 _O_(_n_ log _n_) 时间复杂度的解法。
 
-```
-输入："1-2--3---4-5--6---7"
-输出：[1,2,5,3,null,6,null,4,null,7]
-```
+**标签：** 数组、双指针、二分查找
 
-**示例 3：**
 
-![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/04/12/screen-shot-2019-04-10-at-114955-pm.png)
+## 思路 0
 
-```
-输入："1-401--349---90--88"
-输出：[1,401,null,349,88,90]
+直接暴力法，两重 for 循环，记录最小长度即可，代码很简单，如下所示：
+
+
+```java
+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;
+    }
+}
 ```
 
-**提示：**
+## 思路 1
 
-*   原始树中的节点数介于 `1` 和 `1000` 之间。
-*   每个节点的值介于 `1` 和 `10 ^ 9` 之间。
+对上面进行优化，我们通过首位两个指针来模拟滑动窗口，如果加起来值小于 s，则向右扩大窗口直至不小于 s，然后固定窗口右侧来向左缩小窗口，同时更新符合条件的最小窗口长度即可，代码如下所示：
 
-**标签：** 树、深度优先搜索
+```java
+class Solution {
+    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;
+    }
+}
+```
 
+## 思路 2
 
-## 思路
+进阶中说了，尝试使用 O(nlogn) 时间复杂度的解法，由于数组都是正整数构成，所以前缀和一定是递增的，想到的应该就是用二分查找了，可以用 sums 数组来存储 nums 数组的前缀和，sums[i] 代表 nums[0] 到 nums[i - 1] 总和，然后遍历 sums 数组，对 sums[i] + s 进行二分查找然后不断更新结果即可，具体代码如下所示：
 
-直接暴力两层 for 循环肯定过不了关，我们把公式变化为 `(A[i] + i) + (A[j] - j)`，看到此应该就可以想到在每次遍历 `j` 时，只需要知道 `max(A[i] + i)` 即可。
 
 ```java
 class Solution {
-
-    public int maxScoreSightseeingPair(int[] A) {
-        int ans = 0, cur = A[0] + 0;
-        for (int j = 1; j < A.length; j++) {
-            ans = Math.max(ans, cur + A[j] - j); // 计算当前最大得分
-            cur = Math.max(cur, A[j] + j);       // 更新最大的 A[i] + i
+    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];
         }
-        return ans;
-    }
-
-    public static void main(String[] args) {
-        Solution solution = new Solution();
-        int[] A = new int[]{8, 1, 5, 2, 6};
-        System.out.println(solution.maxScoreSightseeingPair(A));
+        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;
     }
 }
-
 ```
 
-
 ## 结语
 
 如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
 
 
 
-[title]: https://leetcode-cn.com/problems/recover-a-tree-from-preorder-traversal
+[title]: https://leetcode-cn.com/problems/minimum-size-subarray-sum
 [ajl]: https://github.com/Blankj/awesome-java-leetcode
diff --git a/note/1014/README.md b/note/1014/README.md
index 34357d6c..fe4a965e 100644
--- a/note/1014/README.md
+++ b/note/1014/README.md
@@ -46,7 +46,6 @@ class Solution {
         System.out.println(solution.maxScoreSightseeingPair(A));
     }
 }
-
 ```
 
 
diff --git a/src/com/blankj/hard/_1028/Solution.java b/src/com/blankj/hard/_1028/Solution.java
index 6089220f..da93396b 100644
--- a/src/com/blankj/hard/_1028/Solution.java
+++ b/src/com/blankj/hard/_1028/Solution.java
@@ -13,6 +13,32 @@
  * </pre>
  */
 public class Solution {
+//    public TreeNode recoverFromPreorder(String S) {
+//        char[] chars = S.toCharArray();
+//        int len = chars.length;
+//        List<TreeNode> 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 TreeNode recoverFromPreorder(String S) {
         char[] chars = S.toCharArray();
@@ -44,33 +70,6 @@ public TreeNode recoverFromPreorder(String S) {
         return stack.get(0);
     }
 
-//    public TreeNode recoverFromPreorder(String S) {
-//        char[] chars = S.toCharArray();
-//        int len = chars.length;
-//        List<TreeNode> 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;
+
+/**
+ * <pre>
+ *     author: Blankj
+ *     blog  : http://blankj.com
+ *     time  : 2020/06/30
+ *     desc  :
+ * </pre>
+ */
+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 <blankj@qq.com>
Date: Tue, 7 Jul 2020 19:25:03 +0800
Subject: [PATCH 56/58] 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”）。
+
+现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？
+
+![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/10/22/robot_maze.png)
+
+网格中的障碍物和空位置分别用 `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;
+
+/**
+ * <pre>
+ *     author: Blankj
+ *     blog  : http://blankj.com
+ *     time  : 2020/07/07
+ *     desc  :
+ * </pre>
+ */
+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 <blankj@qq.com>
Date: Wed, 8 Jul 2020 13:37:41 +0800
Subject: [PATCH 57/58] 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;
+
+/**
+ * <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)));
+    }
+}

From 0d17728bfbe128132b21156dce19d4a5aa5001e9 Mon Sep 17 00:00:00 2001
From: Blankj <blankj@qq.com>
Date: Thu, 10 Dec 2020 23:20:20 +0800
Subject: [PATCH 58/58] 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://raw.githubusercontent.com/Blankj/AndroidUtilCode/master/art/wechat.png)
+欢迎加入我的小专栏「**[基你太美](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