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 01/56] 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;
+
+/**
+ *
+ * author: Blankj
+ * blog : http://blankj.com
+ * time : 2017/11/04
+ * desc :
+ *
+ */
+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 02/56] 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 @@
*
*/
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 03/56] 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 04/56] 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 05/56] 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;
+
/**
*
* 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 fullJustify(String[] words, int maxWidth) {
+ int len = words.length;
+ if (len == 0) return Collections.emptyList();
+ List 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 06/56] 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 07/56] 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?=
Date: Mon, 13 Nov 2017 23:42:46 +0800
Subject: [PATCH 08/56] 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?=
Date: Tue, 14 Nov 2017 23:49:41 +0800
Subject: [PATCH 09/56] 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 10/56] 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 11/56] 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*th 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*th 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 12/56] 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 13/56] 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 14/56] 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`，下面是我画的草图，希望能帮助大家理解。
+
+
+
+借助上面的理论，你能写出相关代码了吗？
```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
zcmeFacU%`18(Sc4t
z5JU)3z#s?*P%zSG-~>CMiS7a#zE5Mzp2P4D_z)cMDX?b<9~`e?l>0O}pgUkxKV?9J
zFxsCqs0}*~;em3%g+^fvzv&M!-oM%u*>8sx$SlD`_h}kXg*40&!ab-9W4+1si^kD|
zAl#ckckrX^=H`Ng9Q7Q~C?u;StDcJ|27-vUgCU5A^4C?_7HxxM1tK13j04(@Rn0a;fTUA_#jbX5h)oFQ5g{tR$);YQDGU0QxL=w^7xmo@W&yEzv;A_?0@vW$@7y|
zf*@cr0-!6du&AiWU7TNIfal)D{Y^LAgB{4g;5bk;3?e=l8@xLj{=5C*Xq?~t_tCh&
z>4j*5pM3#qMic#{=>bjryYAO$nteX78GJMP-hRKh;-ZpJbo3uO<(Hl!!on#(=Nmga
zDe&L+Wlh2PMZ--h~&QBREjrWsg0`#wSgXN3v>j`wj
zfoF*A>jTyh4ts|9KFtGYUTj++VcTQ_2MIXv{y94$k}{$q|1o0+JRrLR4p9hV?u8(-
zNC=__?cj3)9yVdyGyn$;z9nu80S>Ojul!%v{r*6H|N1X0i`B*&;mnG#c15~dvx*Cf
zNVvMP+6jpYf<7S%&;xc~z|Vmbps;HmtbSZ#aNg&uWBIth`Rstg>V!S8yXog1!Ic3k
z3g
z1_xFT(t|50*n5yIID8KB`}P3kG`K4_pT!=-~Q$
z9)$rHFZ4hJj2!lB?SR$r$5-I?|M3;L|gf=
z_uiA5XsW7O>gnsA);z0@^>7gBnX`^4G#qH{it=#R*HB?KF}=u2&;e{j1ZF}6f~*l3
zHywl1`)1TsS7pTjA#CG+(t7{F%=HMI(PL%(!~Z{`jv(CJJ%E~eKw8Wei9rDRI-p&=
zJ>0PT&w!?}amLbcTrBMl6a+Nb?GTOq0nNWJb3iL$XR{`
z{x90*FWLj?1N4L-RkWM0yQ95>2P-dvk5xok`V{LKq_+#w!$Uw1Y#VELTUJ%HtD7|n
ztfGT4V{1WFSlhA!BTI@%OG*le3Ig;0PXEio-%|f;0z0<{65r16&l!xa?GNuy-9J2Z
z8U&qM1Gc&Qhi4N9L6tXvPZ|Eh<4ghD{yGFzbpACSI_!FJ@bGYx5fbwD_7-$RA_TDp
z{hj`|0>35yd*ZMD1hM`7wjHY)($3n`#e)@VR0P@u?di^nakEAsSq1)c5&w@X{-xGm
zdhqKb?U3$B6zIwbtTIQGJ(zBkt)qt{8pY~}`tN4=e^~7=9kArVx&{Pw#x6u-DF{(^
zf;-`I8-zA!G_&f)J1c=2r27?j6$Y9j4
zV=xvN7wjZV6m|-x08@vZh3UggVOB7E7z*YIy8^og3x`F+9>Y>$Ij|B~HLMBt2G#`|
zf=$8ZVP9dJa2z-(oCeMW=Y|WxPr;Sp+Hga-1>7Ef8SV$a4!;9`1W$wK!z4aAMWeT@4Aw*vPiZV&Dh?q}RxJTg2+ypwn`c$#=7c=mYS
zc%gW)cv*Pmc(3sK@IK%oBSAO8M}i-OB!n!4qJ*ajFA|~%LkMFDa|s&=y9s9rw}>c-
zxQJwkbct+sw=Q5!WLTM{5J(5=r@nC9#cQ&eC*z_%41{4agU!ke*U=k@ucIg
zjxRCLFvv0>7;ZC^G7K}q8BZ|kGx{^8Gqy3VF)=e~Fu5_sF}+|~Vy0tOVs>JVVQyfa
zXQ5_MU~y!LVQFMpV5MbMW_4kG#QKu;GaDn@88%P0RJIPbEp{IE3+y56MeJi7#2lwM
z>^NdLo^yQWWZ~4|yuz8sIm|`Gb&AV@>mgSQ*LQ9nZe#8+?n>@C9(o>49zUKuo>5*h
zUPa!^ylK3>eE58)_?-C?`QDv?pO84=a3cOh=SlcU$&-#J6Hj*W*RTh6q*)t_X1oT@<<})FQMiEFtV7oFP0SLM5Ul5+YI~@>TSNC_*$|
zv{#Hw?6g>rSe4ip@sr|6@g(s<32F%)i7<)h5<8MolJ1g)lJioWQdUw4QUj-GPU)SB
zIQ3c@Pg+GfNV-mXLq<}@L#9;bldOQOvuv*HoE(oFQZ7SoTAp3rT0T{NQh`;$N+CsI
zQjty3S}{%Wy%L9#tx}fKtTLanlXAZDii)s`yGpsrcU2kH0M%z|IBFVdx79k-snjp1
zKUN<<&3@Ycbl&OD8WI}*8qdz)ozXsX@63QElO{qlNAt6mlvaS&OKnnZ1MSD!@6Vn%
z>wdOI2d<-~b6;ol9M?J2xk_C~S5x=C?wB5r-etYo^Z4iW&c~mh(HGIbqTgabZD47T
zYp`ypVi;vOa)I}P=Y{7+6h`JoIY!@&)r_N!CryM*0!-eT9yfI~t-45X(dc5<#Wgc^
zvj=7$%_Yo3&HF8QEPO29TsnTqW*~{DCx1V=Vbcl6Wa#VGE?D)m$j8n4HcV}JaZ09`}
zW0xXVLRTx-Y7`a98TAs)jP^lyxt(+ib(_2_bNRvL&+gjpSr{0`0#oHd10JT@Jb68D
zcusjKc*T4D@HX-;^Eu*!@@exu;d{$>*6*}mra!Jf!vFadwkub!Oa&+hqz1wQZ33SM
zaRglt`WUPc{NyU}Rp+biA;KZiA*H9kOD`Hq-C{UPML{}7E3>AA8FO*o7^p|RvJ})~}R``_b
zX+k-5`Rxi=g>S{@N{7nHD$}a2YOU($HL^A3wSu+Tb!>I<^|bX-4a5!C8}=Ig8rPn=
zJzHwBZ<>B?`F!Ms$&22X=U;Zb(th>2`E>J(7Uh=4*YdCH-pIVEZavjn`Bw66MVmxh
zdAme=d52_2MW<9})jR2THC=LD4c&^}O+9Ko&ApnvZ~M;mb@gB99~>|rm>jenoEvf(
z`ZDY_yfqR$iZ^N^Pp`y}|pDX~gv62h4}wz#zvx_o3gVTE_)=_jR6ZJ$j(fBfS9W$$amw`1S3SH)MK
zuj#Fgue+{qeZT$V*pDY0r#4zPjW=hvytfIqAMNn%)a+{Sj_$ec?d>f?r2BtauvFE7
zV0$YN`F;+v4F*pJu)PuJIz&oHNJvCTN<>6@goK#n2rUIEDFrP(H8m|YHT@CN{q*y4
zkonIujEsbYjGT;;oSc$|oSd8ndm^VfsB+~0q=CI>&=ErLF)jrM#ty-cz;KSh_Qt@o
z3-R7dm?F>;4?JFg1Qf<59Pl?ETs(XNLLy=k*nbv+Pq#R~3MnBNE(`~b3&$hCC&a@c
z6$6DwaB$hEMDUc)TT`=NzAB1Ob1$_-g@cn;zsW{S+&!dAm4GYS;PccM1V(}`t@IkV
z+I>S?_2=mxl1IBQyhna5yZ)lbbNbt9o|udqPanMO{ji!@{;KcenvtDXXlzzRbN|e`
zl!mdrci6-1%9erI??)gw9B7NXuM+`2p2WTiY$8;+K!eNd)Oey-@6lj2XwvWcEXHXw
zbucHw=;D?Du&DQiN7M
z3Jhn(G_`xB5k_1$3Cwrth}C@bu*Git
zDoa{{SvSX*mC|p**UCy9F*{Bx6eaJsMn}vyyk=28F0Px`c3LG*_Q0^yP2xQrsXx9L;<^&AfDCaFE{J&
z>VJ*d;KuE!$;{O>e#5T+ox6|ggo@hrOz{oQOozCaK3U0}9SWL!d+(M?3*KZit=kMN
ze3%3Y26_tnq0cWNw^;WhhuCEu3IYiAbkMWHv|
zxf5LlL}%_#x4=aFlf8`8hm7?`uT&b`{$kc~GOwr?vzX0xXG=ZqR2-=*SuHwKqo;CP
z@dqBx1^WpvA%il`Q*sqAiM
z)P*t~De3%zF_lH$?-K?icS-UTwFy=Y2g)}JP
z|DY;FF}?-yU1mgNr1qrHMq`)3T;HOZO_hA1paWDDG7H1KD;e@>DI+voRCqbxEb>9p
zx*V#ob;z^8O-_z9!X;GNxM7LEl9aqC3Z;XLHH*4?8J(|D5%1mIkIIuQGF$Z(FY6xK
zgDw~BFg;!tW`&@s6iCjW$MNzzGTjg@2Me!buWAyUms?7|&IY8eei$?XW0MYWZykNB
zD4+D;f$?JC{T=q=-PE4KoIXp3@(M9zN}mG-u4~!Q{6mSNow3%}p7&YlA0_(k^c^p~
z(KccB_K_wvPwaiOCYCoCeFKZQdimHf|4)HiZ?)SaN(x}Xr4`0CkB9rW5?6OV?W_q6
z2S_EC8#9X{KHYFED)r!WrdBw~>N%d_S}YQ?R1i8j;u3(OjT|rVvc*?OE}v3dTK#|!
zE!w)EJKva~sWa8PY0n|WOt38xv>`tI#G_lhtwm%HBD37pv0XFoNDT}mYCd)%|`2{Iu8Ty
z$lQ4+F!xcbHh_^6g|MN3MRht1>nix^+KmK&J7j|H`IfyV&xj?2KrO0DorbjVIApjGRrr4TuUM
z+m1?x_HP@Tn0FaeCY-&h<7r&-sXo>(YAtz_L0)L}OsvehrBcO2roTz^K>DQ@%4?N<
zn;J_+0uAW_8oS{;>{>y4U5l8nBVo5tW`mbnk6T(fI$NjDH+p6ktg}C@?-N-;~Zyk~e`yl8%2&^KM_
z?BZK8tBV=MG2eMmQIoe`-k6@1n|t)>HM*hUm_S%CzNb<%#=gq`N1EP;7E}eXvcxSs=au$Ue>kSBJ`w_XyQnniBwOeAG
zcfrzrO;I=Vl7hVdy3s`U;9}Al@`rURCF462niG%XempXAw3DFNEkEnMV?d>^cxkq}
zFpyl?p9sS!PXL*dp@!FyOPds!^Xk@w)f!BiY=jE#*t{4gb2>)26Jkgqq{sn0yKTXK5w
zSmXnX3x1XULVFO-yv01#RDN*9Tr*j}#8At&`>7+VQOB@j(N}Om%43P=u81Q=Yjr*a
zhIy8FA)DE?$m{f$;~M=QG_$xCq`kPQ^?81fL)mOtuCOjp`#y7Gs6`Dwxy(_Lm1y~z
zqka>w?Kf`mh1XQH^+b9G-g1=~x8w|mm&Y$UI+yGi`$>%N#P6J3-nEO7bJ^O1
z96xr&JM-loD=6+)VrQnO$P6mq5*c+yCRNUhy1Of?pHqLV~C4WbOo>svj2Vb?#mg_e&j7nWKsnp+e{8P&Yqaovp%&{(q3!YnQxlk_0)
zRJHI#N=_)5I%^+4z8GKW`S8MW-qNQXp4z2}sfK~wBh(~0o+m%cgzE5newSiz-E<(8
zDcMaPOs?%|S#v@cjx4P=t_6LL%?r!&m?cics+|+z==mI;Fl`o|
zg#0iTm_b(hsb{OcU^x1`SkAEJO>#l?$ku`zp9=4n)-qdnR4lSsW}8WxEf{Sop6)z1
z@%cd?(&g-UmS2aC?*%!;TPK9tCYi#6IM`t9aBIQa>duw`siD$*ub>d)-4~IA<4u#J
z3Bd}VEYv0kmLno6mSy8NUnJv8zTVO(+9-4{Cv^-=%^*=(9&&fWp?&3&baWOj}83ksHNe08jl=$%9R_=i1n&P|D+c
zF^l)p5AHj{p7nn3KXKVDO24&aF1@e3F%Hr7rbn3tH)apo>t51-0RK>#C1lT6iAOoF
zbul__g@}OS@%8Ihoz9$Lq#7lU4y(?25kJTt8rb#b9II1mbzRI=0;TBaqc{`S$0umv
z7h|U;qaV!}EWS6>zO*ntbINE&iS1RPv#so^m(lWw3wTy)qYw@+ifM<)bahjA5Y%u3*zAx
zal8_Vq8T5IdHFOWd#`8F8~5pndM|3i(ns~to{;$&2$Pl*)h{f1;&nx>nst5OhdbJY
zC4+63M>Z-=Cb~GYRx{a@YOJ1y;WRnky)rzrWqy~Ni&G3wE;UTHO2>7ryHkIlqUK}4
z_%bBOUZJ^bFnXJ+)%UX=*XZd6V%pKSFi&0ANZhB@cgUfrjIlPs?-E?xF(Y*`%3e7~
znTLOT*F0P4%PputOgGGD9Z=f*G{VWTVV-cQFjCY%Z
zr0trwMw*yJ7-r@02Xbx&NHBfxc?*E|^
zWzAVC_*JL&jar?gRF#x3smr5>ENRVq5Z}9)+EPt>1)2WCo#(TLpE0Z%
zw^%cJ>bdShH%5H9n@ariQP0RPf8!!XqY%RG3&f`(&UGam)#UnruCXDqMl!tzogKy
zGA|Xpeu|Tg@wu%%6&>k`2BM`RGB=Kn4q+TBkL9~cQh0IT#p!s@
zA1hzC_q#A#`e{a?eY^Xl$k&sx@28OOd$?XO*R}HHWVT>l8TKxY>7ardUC-^NX?a!*
zn9z1NS)7HH_ji>SSgrRriwDq^!vtAdgk3Y|u8dqLo><_0QcNZ4Dp;
zH~Zkm{_}6_4VrVlPrd)(*LTgXvtlQ=Rx+|9Yt+25X?yiy^jk$&$InMf~U|&s-oka2#c*qHNk~ujqFepHAeOGYFd
z`s*Y8nJnjal3q&57HE`Iv32wKe_~gZo$G%Yx8+jDQ1E=D4n6u?<=9IqY^=-%><=QgZK!
zngNm3;VmXtqf-|JicO<8$DCX85GQwNnTxi`$_uZicF0~Nxiyupe+6C;+56>d?%In4
zzC!hix0hPS#~SMKTa)b;b0$_+_aKek$a%iE3svi5??g(1k+k(cwoq37aTe!jt1E1K
zKc&0I(QR6uYu#~uxY;<@KH#)q>R~+BgUD})pRbAT4{q5)6^>LW`kUSJl66J~Ijk-q
zljk2Son81^l3S?1
z8fqG!TQ}s6Z(k|u8gQ8~HYooQTit7nJpIDitnMj+#8OWCc)vnRbwfBRZ_Ueiv$Js{
z>a294MW5ZkRc-F?w#Ei;hd=ilnXQK}mj!tCukSogXffP$SA2%vgEaLkw!@@OI#4?L+
zcguu*`s!{^)O_9phI+}(E%lO5v>k7DPwzp2ea8zV{jLY&xCFRH+6r&_H!eS0VQw*DHZATOe_AO{%^4)|+UwAH6!VotRYKsJg>mX|NtzUV|TeTn@(rhKy)6
z4e(hR<*zhi%0>ru?zYw&+&{*Ua=(b{JlgnWMCHW*k+6sB98}*Go}U~li9lDctg&n!
zuQxlHTcrOIaqrUe;ZLa#UDl2*)VY$$geNs2QJ%5^6FSLX!U?ixJ-p50H~Tv;R2Yqh
znjAwm)UJ3f_yuyvYnTi#ZJCLhzh$|zT~xLQWoc4q>a1C63#Gnqb#(~vk_r>wIVx$$
zbU$LCq0++4(jY+l;_Op8u^q13sJWq)P2CGYD3AIrm&UHk*8cKdk1NZsP0ZDdMV10*
zoVx43OJ;97am#aPh=1YHSv!=hb6U8dRpMIr*bt_nEubO3zG`^_J-6Gn!~8U6&Xc*w
zh)z<_ioH#{09}Al#+co?xV%B;9}ux~@{2PvHZW?nbu8}GT4Gjn^|XD-b?GkWA$21c
z0`H710sDEnb6#lOH=QqA^Pbo|9I#tTyM$U_-h-YF-WV{PFqkmfgJu`jcDourshb6z
zpO=i9)s$U)y6I_ARg*U2I6iZ}erXiw+~2K=jMJ$YIgxWmFs;AO>$3@jk+=5r--D8h
z=A?%2aM>a3dPmSTEvBwuk@81|s&Cjx{r$zx|WkM2h357$c;3zN{RHVl<#
z_61~31PwE<2R>Y7nVjEY3mo>hK_+j$W?AzR;dqF4;ZOfUQ@LBjmBUBJqtX15RT2MF3wePzaCnx@2!`=41(#J7VG38{Hwwm_
zD;vMRQ|No77C{n-Kk63v$>L2ww)h@2Ob`{h8Z_bJr-cmCnIDqe96HrEW(~{y6m4Bw
z5$HYR7b~?HYijw;Oa92Cs{Gd|Z9W7FX%kyVc>87GP2s>ObV&sG%(ol1k-=h+lbjxT
zXM)F8E_s`Rto@8^F3V@1$R8t^J&0RgldHIS$qF^Az%yn&x~%C{q*yC!x_$j?o`#`Z
zBW)w`O3==QUT%ps>OIKGfu*m-cMr;K)6~h)IZ@!UAW&Xd$sX=F;Lo7C7)0P$*!gsH
zBC|3m$M~HQk*3gIf7DPxtwP;>>ztVK0&B#b?@qI$uXkM^j8vBo)%KP3*w57qU2vA@
z?uLaZQ%|u=3DIea+*@b76xNlSRbvq`desD7^K}c^?rgf~=dI8>gs9j>1WoRS)QmF6
z!Xo&sbUDvoYV2PZI-<#`Ftx4_SK1tKpHXzu452O&Jn133UP4uL`u5NT0onmGRr>y5
zwgQHW6W>%mKaDo{#J)vA;XSUu#_W4}Yv3AZbh3|Nl9v9_YZ-tVr9S$Uh!e)D*`x1O
zxjoC2_nb;ox9(id+lTvtF_}Ixntb2gJwJ-D`Dg*kl;{=pcYvJJ_4IJ_
z!~#FCU?oTo<6&TfM!W1wXrerjz)iVg3$XP5)ph?{bc+4D297>h2^B{VY#nUzL7PbT
za{yaqsBU5iSO=XQRM2xrqwNfk9-eNxHckL71K~NaIY@;!1fj5%A!4`RtDK6vt>Fcf$7v3Imwgz|
zulg!3wygig*T=Yc?DO?}T$J>GNkhb5NQ4L4UCr9V8asl0CH3s}Fu&FTmc|N$D^_jj
zEYj|vng8h45a2Waty=?x%K=}{9ie23ZDBuABHYn##tuj@xnNBK(8(|Jkz)(=flexD
z4-d4f3mRqrvkK|2608b;@yUMi^|2tPzY0ix6#(6Sv$4AaXZb*f1FRX?di$6&2)@5_
zxcAGj$k?ArF&LnVu)CLRpMl-O%=`Ic|IFij+s_m2pTP;XUkjjFv5ENSwg3xuUju+r
z0_hASWM>CTT)-Ki=s<$~{On6k!m+k^SaiF_18TTKUb{Zxf3MgCI8u0^f1{
zOTwAM7XM2DVEsQS+qVTFw(Vd05UvD<367t3!=e;_0&n(Zk7Khq>fm%RW^5LMn*bgw
zAP6B%NC(n@EFod=BLSTPyq{YKP=C^2JZwE|{ePyv1b!F%aTE~B(*^6nfa`_uZP1=5
zTg-p#Q-lW=(YEihv5Win3IfdkSb>nr@0EI>hW_t`xIZL(jEf@zi7|3Hi``1FfAoX5
zUk2D%OeVp8MpNytz6k8y(VlMqVBw9yZqzkuy6c-a&$2E|Ga_VTf2A|THF6aiX4G-
zaWMqAMNP~ZL!Gm~92Vg(_CJJ)9MJB5$}W!fzbr*@F!(dS*uVe;wg<2~KoWT&-97$A
z+~^nkpW-Ao_NoA;=l+**j~ukGqVc-`RDsR`fIGH%540P&^OXn9(@0Oh`c>S-X0=v50SUPF&rXq50STr$lF8Y?IH5^5P5ruygfwT9wKl56I^?U
zyxj-?9wKiKk++A)+e75-A@cSRd3%VwJw)CfB5x0ow};5vL*(rt^7asUdx*R}MBW}E
zZx4~ThsfJQm!0J|m6{;9T+oz>A+p50hNM_9*A73tu3#?KvT;CIdt;pdEywq;jT
zV3qTc@o{x?MS57X`nbBFFfu;!?E8(&02<2{VrShK@o<)B-;ZL!YNDeD;&-_tStSI;
z1Q5a?G^V7apoqAHq@)NxD*zXZ3JHT>NdXaY83_=QQHu3vVh6ps+uF(KtDXMY7s$!8
z{}m9;TTBq`ZZ8A^#7Se@5ET^w5&{@sl!vvC01CtLs|7U>7th^sAA8G+Z4ux~Jw4>v
zfu;vTaCQ6L?7!OTm!R9PxS#(n{=0bJz`rV4djb>v+e{!q^wfPxAc3{oFI{wW{$2jp
z%(=S$md1Ffdx3%cTkF51F<3a5kUkOv;Rw2c2gk3@Y!Scfx&c7kzAhw4H~y
zwL4PT9+>!-Q`7t93jQ+$@Gr#>4%R4pBv_F`>_T89LRi0ZFest_9PfVFUq0%WIBmw7{VS4lQtKfkO-Y|HuM=KC>ZF;L*Yxd?GuHN`4rX{4gpx2o-)9
zmHgNL$Q(u`Ka5I#7?u1mD*0hl^24a)hf&E7qmutmqmr*cY=6fg$AKtu;5dH;NC2T5
zu%XFW+1SK5#m);0pH~qQ5>nw|1c`_JC^oVGpF|div5Sd`bBnXn)3g5%Lz6!Tp~>MU
zIIMq#CVvUNzDo=hI3t*Y20S=$RI_vc7yT6<6TgZ4ilrO`28V%o=tn?yk#vrqCfHO7g7F3y)9FD(N+4Pbl*-QwabcxFf`QlY5vK9p
zX1|UNrosx{NF_W$e0%j~aVCD~_fr#Vt@BC2PRq2sv9#d7^I=x}8F*SS$b=V)g*ORk
z^TK%53~2?Zf{)PRDeGUS11;df^+U8M%c0WfRxOPr4Q(!rj7(trm@k=5WHR?l(8Fp-
z%99fmdW5_uh(j_V$`nust_SLYmxF=m8?1Et{FJhtxBk6r7fb8vLC{6uxfuxV$IGxD~l)$m;MX;}k9CiAODTc3$!SsYXQc9KshEH{gVfc|6Dx5+FgjcsgZn+bl46)m2;vq%AQT!>
zt8b$c8j>S9(q?)xW(`u_G5qihb&(0cQLMM*Ug~D3OkNuM62NH5)TU7&U-GaswV*7u
z$`&X29hpVp<=Xo##c+K?TH+W&2rpRWEeY`xeu$s_wY(BULivP_uvm~I`Cg-WLy=UP
zp2WH|{%)seB12oYdi$ye<5U-Bsv8r)gdeKvdd(c!nT4*4LNk+&i;!Ik6;vL#e(k4x
z#s9dh^i@1%J$+hUEvgV22p10*qNP!}3%{#Gq;j5y>xfzmo}52bn2^6XzdojhO$qj4
z^~+q!ZJvmjclI5Q?On}dosW9f%5>~rNtFA!b;nPud?Gv6ATId1tM+LZDw2Dy2Svuc
zDn4>evnEnVcKsG3-khtv$|MEXr=@z^eIq<53hM+I)k
zt9Gm0eFD!V#!Vr_i-BE}l6%oVwRUz+@YoZNLPeyqo*`Y6K68>I(4622WWp7aPjorE
z=t@L*cU@ic7xL5EX&&AiThkBw-ZQmZUZRj~xRTH*>vQM6u1n44Ze)kIF6@3ke{*5b
z6-p({WC6X9
zWVZra_yA^Tt7MtCd(80L;@S3Oe1tA4e0rQCS>~Ftpz;;lregtLH<8NMYgnTjB#-q7j9E_@u>&XjL++BnJi
zUM|^*I!Q$1>o_Ju4~WzRI827z#S-Z=OsLO{cfYD}LT}6_DqI#O4eDA
zk$NmX=Fo%gXiVqHS8M;I+xqFL_r2CR2jtrHO?5g+uFf#C2%=L0bRK#fPqi#TOmxiE>U$3yFyomp#@+ofCCVlA#qU
zNCTMd5Ewc_i)D(_E*>uBJM^Wt>rTtoZPM~C+_qu$WS{VrDPd=QO%QbibaqR
zKX8LE{pcno2#Qh&4c$&_vf>93OyK9`w&+bmg)X(kYdn;_vYuu_cY*TB3B8bwbjDWU
zA4A6jrCQ|QG44U~Y|W!%xOBiH?#Dxc1IJ4XR;IF^UNE5^p&mai9t=;}%8(ZCYI<2{
zyspCS8^AG9<|q;J7e4_M`!l>?y{lFwYM{$ZB4s?4VBoGuD1q-+c~;p@^$dbcHN&K?
zQ6!p&)i1k7r?8gBU_CMkJQ!T)ppc8P?6+Z7*d|k8R`6#gpd{sqR!A@el|Bb@#35I~
z-J`#EybS~)0t&`}oq?5RQ^KCkfbd0l!Qh3BDeMppu!A8TL8*{COsnNTNl6u+*QE+1s+TlOvs-C1w+L!D?{)qN8A)JP9ueivwuO>9b9;GZP5fFOhm{FQz%
zc%x=8&=pvp?F`j*<`hDGI(U=*bpd5Cxwy1ohG-!;4IwRW>0Mfwwf;RN2nHNVF&&tA
z!u@r~Gz1;;!a(oAlzN1SwV9Yq&^aENK!;;x$;%NL`kilg
zBAXI!vo|5xn|NtpypdNl>maH{1~Fq7;KxYhHo5d+(-YT5R0B>|m&iNB=iw{L5M0Qt
zf$?hL=#Ai}VwasdeST(XY%8nHn>48<8Zt|n=5fiU)MW1jI}mo~*5qqndCgp(iT7)y
zyYkKqQsf8??Lh8<2J{*6X0L|%)W-BW2*0K0n6gcCpO+>~SvR78&dT_mvl+p+zKLNa8
za-FwxBi}p6<#9R+XXRWlHM8|hOLi)B&~cM`Yng=cq`1n|lI#6z<)u~w^UjaH+Gk5C
zCTMoo#M{X(Ij*qfR0EX=63s_@6p|c#C%Wet=u4+1N@j-S-D|G&P#BZrWQIv{b@zW?
zYHyrQ@+imrkSO+>V`gAJC#5Z@YGzMopsHPY{mZpfiZfsfq+~!iohip>o{21=dbI36
z+l;M~3Ebz7)#30*7(1AL_%2bx(01&$V5Q8M|PELD6F0i
zt8aDO9Lj1qdsmN(5P~7OfDdw9`4*W^FLOgjx%$<7+!uVq&k}My0pVxo7MCz&cLFEm
zR*(a&{_jTDtvWmB$jL7w4!!c&s8*trC)=WMp;e-TIjj{4S&ya<>=+p-ZB$
z0vf`so}9pMcquMkYaY{HHm&J@nnQzeT&IAAYi{GIoBv=$u=CO#sie;IxbjkA%;x7;
zkL3LNhWO4vxYz|QJZN^Mw}QlKHDpMM;J&4E_|OUGcvft)ElXE6CTh%5aLfnK`F6c{
zXfh1pg*-D6p2^~82%%}Y2d4iC9|;X>juH{r!jMWP1Syg7X~pDdU+EqK$JH>&Tdz0e
zVV6CGkJqCWf}y?_j`iua8B&iz^N5NDs?Yk>9wREc>)$o+5T8^Bo*(~8zscX|ay(jGxsrwDjk>>fVXE1rNqev^d*42ZMlAvW*NWxy8s^`I7G6wi8)l
z{DO7VX54IbF%|kl6vmcAaj6M|z27qYJ982id}eykM-#H^@0^uM^0<e%q?9v^>4sa*rl>H2g6;_NB9SI%$G&t3jM$I%)2X
z=Nx%Z!BkQFJMh2{13nA*RxncAg+Xb);H
z+s}dj<^L;(eUBC>i}jA{GK^M)u|!fNf2CnG>R-O(GhgJDx?Quvo#t6GkXB9=elB+C
zOr+lh%;=J0Ox31wRGfwr*^|uMa-Q!>>ZYDVHyPSxP!)XN-jz~nYba-s=WNmO6<=E$
z_3NHGVt1;Qm%-9$&9iE&BZzcpNb{y^hQ8rfA&tqU9WOQ|)`;1HCG~Rd*Np_IR{`Vi
zC^+U=n(_0mK?E*{@<7FG`}c{<}-d}=zcmSkpQ
z52D{`q^ZAhCgtjC#i#eW(=9)C!-KQeuae6o7+AeqF?BA
z{C$s@8#SnR1fH9syPWmBH2+2MQcn%uEA?Z`DT-t%&xfj{BjT$SsndT9=$m&ctw%+!
z6q_!_BPHyWhe~kBY_j>do+!3t`3WV3lOESeDyTaCRC>O_Pi{6PuDtLbvis(XOzN=H
z8uFB4eYsNsaWHO}5Q0Q)i3cj(zz$z4W8?
zou;_m89CmGsk?#cg;U6??_!Z1zN0TJGCNV}@-?${FYv!~dd$|j1+fYTvBvFOFGjtb
z9J<%qg=%^zw9E71$m@J>rEgfhpcusTBxh^oKkvRV%f4zBX@BRf?CM}D9c%4P^V~ZyIa}V_
z--Z&&r{149Wt_|H?;z6M=Uey;(TOLSETy<6T`C#ZS1J3t9kW&euLHmm)Y5*^-=Tmq+RO4L9fT@1ZK=b9bZkI--M%CHnX1B
zKILxP;$x@aC|tUfTleLBt1~n5p;q5axJ0X>jq{?g*3xC2>0QpD#A98Sd}_g30{EEj
zcV814=Piq$<`}I~lSfqb>&H%da@@<)K$lNTDX!?}=q5AqNg5-wI$U2=($>E6FC52R
zQZuCLODOAe9I!dvN&ww)KYok)VQ^JUtg58bQ(NTa&nTahWy(Z822+k3=M8x$89grI
zK5j#<({Y?@Z9K}4bGi>*(D}UIBwsRw$u+ACGhpbx2buTSCpt55Fhhg&XKQOQsQR^T
zb;E`J3s>?lMrMyqtZST8OT%R`US9}Oriwokt+o(2Tw-SXiFG>wg-HObu0ul3Xy9Qe
zLPCb}%yoNQM@`;%v2?Lqu#cSgphkSBz#ZvnyqQ6!GaBp8U;Rp#{FN{BK0Q{CZ
zYxQ__V29<2X8+@x{YM7`J(p+9??23+dupEf);_{1Dc+m%56Euo_7dVfJDkO8ei|1Y4%F*_Qjk9mic~-hyGS_7>=J;z{+81^mtxcZo
zeb(h#J;@K!)~t)fTm_YXP;WXd9}nrQLekvK=)YYyIM8{imj1r!ZS@n1MHf0RE{2Vm
ze_h7;I3(RM)G=1~*+tUtX{UC=sxwl4SAh(ErL!H-oEDUDV=+R
zCoG8x_pvPHqZXp(wA%yr<;Ptlc=PF{Sz4f%JDesivAP$b?K@IsIljFCV
zDyhTOT|Qi?+Vs3VUF#FmVnSQ@RQBQrXRX
z&v_Ry{hC{v32Byf?N?f4D^3L1IWIg(#CRSHD=zlc>T4=2EoMZJPx124NE|b_UF&!9
z$Z&%Q=xdzfiV9h2E|(>IN&Hs6xf0bgBO=Pb;`67Lxgfm%nHfJTE;K;L{&`hvdzwY
zOIV#Pk_WFXxLdUcMfi630Y{`L7+3_3C`IPLD0%74e5IxzIX_r36kY}d>_KY+=PA^4
z%L4AnS;_6Z=(104Y`NEI$sV@N6VU0Esjrh^`iAXvt&qn$kHNZZ@_gho#iJw9wq7@q
z=cw>G@}eGaKRte}WYZY&a_DJYHSkva>r^M7Fehu+B07L&FyZlZww*BuHk;VKj`7hCPzZedW2}
zk|-%j>PYmsZlT<~z|3m?&R~m`{@0q`)zO_ov%!Z!D3^g^Dyw55Yvtx8(OR2%(@#8k
z79&`MKCs005U)HnlD|MJ+W4VdyL+?TsZf!*^DVGMru*fllau1Pyvn8wK5XW3)_zLnk;FTuW|^nvM;p3{v!$Muh3
zqvIip1agUyE8m6to#@}#RF~`)7|E}kXiupxZD#ww0s<=i)j{KOMZGnx?yIfe<5;ZP
zc6v6
zG;QWpaCrmu+P=q&JX;pT(wgF;uT8PcSN6@uBsU&iYqh>qJ)1upSz@%CQgzn~9y67#
z*td?dMCC^*qG
zS&WoYJ!h_xYyc0g2g&%5H7PESFzcdE
zcO6!0hvLc`IOFdxe-Bnr*Z>(-s~uZ4I@fS1l?7L0U_?_?i0aj8K8)(P+j3kR^W}D=
z$DVpqp4~W^CAHGosV9gUG7JD2vu2QyyukgwGlI>&sr_+ODEc8npTUcZZ2UGhmO>j-
ziUayRTV;|fH4fTMuO_Q;&OU;Z=$;0N#nG6>){^5!ZI7iU#+`LCby_dl_YQc^+X3h9
zD`kqS1|N57c+gFxs==43)sbo<&TX*NNk~a>fPNjrJC_ZRXR|CD6F41C60{o;@W~G=
zoQyP4hhjrLnGE)&p4>(q=!`q+bK9ZAv2%xKU|`#+&tqc-&GXN*o?Wc7?C=|J2-|!b
zmM!XAm(s5~y8Z$5yzI94yMzOI3w7ALMAoYn+Sx%p7&MoqHf|4CRjB^}X}b2=*QBIYz!~@Stva0LM(XbpR
zjD4tqdZSBa)0oW3I&7^4A$7XvJZ6~x03X^>P3;Gt6&@P=He_m=(`hHwtd^k^BK__5
zsT%25m+4vE+FIh&t4VR`AZ&4}b}YtBg|6r#;myDaF4
z!PmTZX0H!ivv$r4**~+rJZYseiAb$7>p+_9T7Q540MFOh*$~6ATjiqSm6xhlWHovU
zF14C%M&mc!s^I|O#6xNi+osxg$`tU#YSmSrW}{jL3wVnyHmq_I5lk+i{ipBv0iuTc
zG6Ba8+oq)3X6RE;c3Uj$iLAbBY(c8WUed|x(ci4#lRpm7emo9(Y-%maf(PJ9w69OF
z+5xT@F!~QrkMzV8QDTbM)--;JG*89Yax}`L0ti30wau66(YxquQlAZLHIbMor}7G<
z9z`Zv-;WQYckG&u>|Qw7*(A?Wz(6wJ<87ZC9g8Dl?ByW@AT_tJ9ja-pO8ygQ2pbwV!??dI-%l@~@*(5!uu0;mX
zNTm8w2~w&QZ4f1_L6&ci@vrUq9hfL>vgAV5144L+vm4x%A1#s1N?Thss?|<=wsGdJ
zZvHujZDfUom#wGdNl(O?zDJ5@mHacDE~7k&o>aqWfVP{TvK>aVRrnKKE1PESkzStsXYfD4-fgeao3#W
zVWNySn9pKa?8`m5XSW#yRc2dsaE;*v~%33hXv_Z5-^{C&99C
zYB|HAbJ5R4=b}z}8R!fj$F2c
z-9^N$B=*_!4|$01wQ+T#F@06fEC{+ld-DU?~uanlgVbh~v{yzut;|KBSpV!Yl32;A;L5rgyo}`9f
zP$p=}Swz%l1M*inBo;QD=bEx#_Rl)TL5p!!_=`RUK*E_(C$94Kg?gn$3q00;pB0tP<-ZJ+CJ|mIL*SL&Ec)1XB|}jf%}0Bd(~LYtXmD!a!{)h3Rg6UUGbb
zp189$Zz
zS~DqH0?e40gdoK61jJb7C9@MB@2r
zyqrYZGGK0!ZMvk@9OuuUck(bfK0#@b6W%RP2z9={RGN#$g|(-jCs$IhN!4i78wd+M
zmuo?~zk#?+oA#_)^~!uROvLdl;`%r>^0QCg*W1!3e*2e`x19PMSgBUz(yxKtuRk|W
z&L6`}J^R%-e=q0+JJjtL3t#Y23q6{fp0i!?Q?ulhzp*#jHV9tcN}*1fL9UD>R%yQ-
zGn-0T;F}Ya+m$1Xx4c9g7x$PW;2}}{s?0qdt2vcEQW7k$dxf)!JgvS^VjK~B&vKsc
z8ULQge1xu4Rl{JOfuiQDn|2M6MBY7VVhdt=Sjn|2*9q*J@J
zl&n&UTwRm}AyW1xx$SpD|jQGgCZ>H?OnwiC%D${l&3YX9Qznb@{%e^ezp+inK
z-aYIXnVX8GIjO&BHhpHsnG12DzUjRl0{bN|84LJCe`+~CYbSEcS~GAFQ+%LXDW4nW
z26aWGuJL!fM>3w?uhu9+UG+N(Q0D>`Gqiux^-D=r=c(-W`np&kZ53pQRV>bz1{MIRlf=bDlzX@5Y
z{AG=rqi(}*x==QHZ@#pmFBZWDXg2jh?={MskCWLZrtdx}ZD)M75oTw?G~;#jwMe=!
zAA8xUf#Ta3_!G0fj+SVXTiep69I~{(wKQGfes)~$$u@`>2X|2m)Ofv1((UN>Iwx#y
z(`hqPRd;(m9%s|V@iQVb#iVIyb~JzOtNLW(SdO1JQ{!x{GZK1~?NjNgZ+7addep=?
z+4fGt@)qq{awp`cV9t51e%f>Jc}eP)Q@imLd(48M<7n#zN9@=$h9ZDUp=ZQdz9fqy
zc#9Y@aDG)qj-QsbZw^23C>1hp5B^1~ExwIv&uN?gM#%8fpHHx9ERbPzC@R#oX
z;>sVA%vZ&@zuZ^F{{VOQ7CL@%Wn~C&umZ(mrL+2Aav>n>-bQIYkHym{-grY=5RzstkVpQRdo_6c@1GwXMYrCYx*$ZX<
z9~`r3chxCtv_6yCrW0lmVVgzN(gD&UKJk^2+vhZRB_@ccXJ(nI=xInYV4MnBZwBo(
zS0XoiUN1|4q{&Xjt?$RGoLG71E^>RlipPd#XuL#a;V3>wYe~o&(?Zl!KJ#=73preJwcKq;Zyo**Lr>E#ddrR3^J;aKz1L`+
z#xNI_ZP%K^Gx{;zp50=3%bYi!r@_-Gi_F{J?}@yurKimWVsoXW{{ZA@y#D}DhzQJt
zA)O~V@X>)pg|#D`r8Zz^9VYwI=`hBfqYxmMsqMc|r5Dl>-yzREWp6u8Gfvdmx-hyF
z{TgO>j{9_@;7nB>0xorF+39L@s!@D@bgB2!f@bhA{{UjN>_5G8Vn?0LgtHQAk_ZsO
zQm9_mk4d6UJBy5Y#fvI~kcRjWGw#N02f;(Z95DSeJk6}BP2{DwwDoD4qs)7)y3aX)
z>bZu~8c4loj)A(MAAKfo4Gk64il@fLq-zJYZ;`Ss0sck?hlkck76w?TW
zJn2(4Ctz-n%KreNQF0?EyhV4_Dsk{1D**kp&$zLzE4xj0{{Xw|6|%-XT9%tT%f0?>
zTB>+B?@xNBcA4JIFx}Ks*LZFz24`p3`(*3@E>N*P@6IQh@jb1_a
z;8Fk;zy$92rRM$1Lb4-c%q=lXaLel8vo~DsKYM6|!Qyz+%
z5#12@sp*VfTlG36JBvAQl%&Kv={cnq*ff~jUTHSj(tJT
z>uG$2D6|`IIajp6Mc`sXR2~&?h@Pze5&|Z0F|k&j?veFXSJ^c+AUw|rriVA{Ri>I2
zl+Ms=yx3jyx-~Go&9D-Si_?4*i|rup7L=q2W@{%_h|BkawDG(otxK*Ck4-SRy()bq`r4h6YP9i5
zEW$mWs<+2XO`Ovwq&6wGy0-8AH|Z9SAn#NKrEThqG+%Ufkhp5ty-!`}lM6fsJnsXu
zP-O>GHKNTfug!d149@U^lv@{-fvClVZ`Y~+0PE82ed35bM(-nIW)pAjC_9BV-dZ&z
zX4tq!S+kQfcbZj=nMzGFC<98^EnbC+d%u#Jo#UwbLm}1E?DjTVV%(F+KD7xOfUrE^
z6z2Aw$1!n3IQI02jm6HPy}5H~rxF=q_u1^fQLw5|gic;ha6AAxUavh&?JKj$N!^-f
zY|Yd9k0{
zcN|@}*Oa2rZO?GLGQmwzg~(n_zIj<@9uIW08%9;4rrsS}b9OfCJC>xmUz?}rYH0TM
zX@&CNJ{jPs{u+;i5|*QbmVDCszI8DLMiGs>cEkO(Uw2hXFBiP6J2wf_3llj#)k|)6
z8js2-;^GbhjT4s)a#1d|e=aDNHXG!Ogsn
z8|3nHeI~%zvkJ!r3$wd4+~$vS)uz#mqZ?;?o7>glVko>`TPcaM6HS4|ou+HSpRk>d
zMkZmB{X!w=e?|IF=4q2utWMCiPLV#7^))+6wE7Bth7xkgDJBTOZ`9z2Roi<#fq^{C
z1!TBg52NlV4>(<(-(;-`2=0_y8#;^RS}Hj@Z`5uFviQ9xMu;k6XR;^ks`;Ah7CsHH
zqsrW+35Gl&QJ8s3@bZOT9#HH|$}w}WLY|uzlAANyEX}&EsX0DtOqt&)bG)?rI8U2B
z#TtfO3RXcw6vKN+cD*XZBgs)_W`DbNtW4*dXDW!cHBHBr$HP!}^K1-U1_9D%PcN(O
zRIdEUyv99Y^mKgHU1#c3RHpLO9!*Zq-K=jSh*BZylB9EjgPun+S80H>warx|3ChF%V@
zM_aeS19&_pPgUK-V|PBLpPKzW4G;4>B+}j|myxabX@#FIU~_b-2V2c`Dj9G}PSVo@
znrnkvuBAh8?jH95)f+C)&i21Et-%+_%33WsZsoD)>GZzMG1hq|d*W06ueIko8gzP!
zOG?<<_L%L|{<kTDCgAaD)xJQGJrHU+2!dJrIGgYYEXqh&E9-3W}{rC9;Tk%AEoD1qSA_i
zw0yr>q9j7B)Q=8tn6nG;SizrfS)^LF+vyfcY_A94vD9YZGS-^4P~FxtGUF_T%U675
zck?B8^L2@xxXLulgtymLjFKF*(3r5v78b{33W
zZthbyDj?9!wn5clltyaLc)Fnf08p4&=8>2-PY;BBIqMMvHk5?5k&;A4cj{gcxC=o}`|E0E(4+B_ex99{gx{#C)llod
zQ~v1-J=>J?{UY$Qs0&Kl)aGv5F}b~)vFp1;Ebkb!{0X`$STSYI;U*e|3Wv^B{YJAy
zJyj0gxA~tppiBWXxjyHeGV81D=I~5x&>Z8;MOVP{Qx7@P`YLIRxx*pQ(ET=Volm8N
zTv)ljj(_`FUhy$DN3@<8o)%`fo~?I_IcI7Pr}~P$A7M+SMNP2g0cqoV=WJpGKoHR7`-nlTos*~xxA?m+R
zx1&`)))P+P)0bAFMAVyeO8(zSvDGtu@o3g}EjtEBd95d@3vZlOy-!wzU98m4&eA9|
zLxc1L<9-?d^POU0@7}5BHZJdy1^tRwvcy7X!4^`B6AN9kv$-ofkg~ra)$bIQ_E?>t
zj4La0yM|KYmUTZghz+sPYbVxqYGQ+9md?r8UQ*3H!nRK2_odGDiRF#0*2^0xHYUL2
z%{K5;RI6vIr5n9xGtqg?YH;a~M>zIXOa7jh>HX?v@HDEUzghnPE(fU15_w1AX}c;(
z+~Oeb&gN9F@^;cvJ6XFba5k{oua)n5s+b*x+3B9@Q~v-D=zAp1JCu$;;wu?+olOsC
zgA+9o-|IaZkfKd`rES$enW={l?gEsc%s
z{3O`2S-pB*xk0jEh&c)MyWjHlC~9iaPSKgk=0*0?3=w>YWq=6hOK<@|N;PTV8A!8WlZk4KhnEb^J5h&=M3J*-9
z#`sHD<*ao4rD~Zr-U7I55F4#oaet;>1Gl
zpCKkEoZYVTeBD0PVwkuftkW{_Rw`VhPEuMixg5dibjw%ctaP3m(oStivF2iuZoY+u
zj4B|gz-=VcZ-DwGbona~8?9NaU~I9>+(moEFW^_3#{LC;yl>!F$MIH3UyXu%*9kcD
zd(04Y#KO$uby{|A6RR%84a?1f1>SZs;fK%>WP>_*#EhQcD_qSz$4Y7f+-&pny9g&>
zXfwRs)c*i+c`7~7`mtE2cUqsdtZk}D%}SwZEC@NKM($z_qb
zErS=*<7VWtx;&M1c`E3uznLtK++~T$L`<7+WNQ^)DPl1$6u%8)HWu82$?Sne++UQP
z%JFV)i2P5YaV%`=!!YgZKVZSs1)wdP-9l}YU*`Kn&iP%0zOntpC|`O%Sl@}|A^RpD
z8AP5|-6*zCtPBN;Z2pZG*#i92alE872P?Z&sl2DRoKS3y^@3Aqw%uAP6)iNs^!2wx
z(SDw)nfuN`!>iG$&suhmdDwkocJH;Y;-(|GHmK7q<3IbatZdJ#ykXZLLrSOmUupjU
zg&r@9>m)oR5}~7?1|Jus!r<42@b?^DMZ2M#-G!fYqS-bu@9uN98aUf_o?Y+kp#jUR
z<7(+ABfYo(0FhlCN4jrhciVZT7sSnIkyohfGufp!;Ytq|`@4v~@A;6?W{b01JixQ0
z{-(CC>J*|;dE)5;(
zi8}+gN%1<=G=6mCWP#-IrBIrB=Da+oRF-Y0U4QZ&n{h@8D^a#PBM`FwLFj
zu(=jNyrS7312*aWo^d{ror&|eDq(oG!Q6Y#E=3U*XH`D$hqH)fjiTHpc(l&ehkw#2
zJI%cdeu*5d0gFrj0P=b~F*k>o>XSG$l$q~!gW7zoE;Ol>V=Ts}GL_h__0_P8#h5^}
zwI);3w(qO>iG~_Etai0~PRfU~OfK^3y!$QJ5n8kk-p`Q6aX-*V*H_lRkOOx9_YPidj^dl^BVsdj%6M7g#n
zl1h5ZU2Rnpa;W>~Q5MFrG&m`s_uAhlSMc_3?~#)mGqXPH1WDlAf
zm@U*S%3V+BsUnvkJd^dFZvlPZ^C1Yd(v6(^xCQZO!qr92J4Lq|&o|9Ssj;%`+gWsT`N)J)*p5Quq^>*r$Md25acgNM?(Nb$rnCq3w
zAYET-gbSQvZg7vRt<(A>biw0HcUiSI^K}!8J2^GrjiKF+=>$MTeNNZi#t`O9DW
zl;Y198~fdbmSK+N1wQa|=k8R1Qb;rJJu-JJqEbvZDqs!?Y~j0kc|7XT9$0f+4y)j&
zVR=h5w<||fh>3?uXI7Y76Ecsk+Uyb
zM9^lW+43z-$f4K&0n64}HH!nlTOF*4#u-?=Wddnl
zZ0rU0fb5`67T+QkfVODykg+wmS)?0|f~|h1N~WmoOmjnX{{Xet)TvXgsG?3pTkn*l
z2bx=6vu`3!0!1P(uml{VtmS!
zlMXtyD!ZQu{i2DxQjN-EuRmy+>R#VplcCb0s`%aFQy)i9siKQU-0erVSNy#Wht2kt
zJsN{w4sZ*88qZvqvzpCLA6e;eK!QLQeJw(o#V}4_@nLFZIBn||JIBt{<9swNPc1!t
zO}g%{`hCt-O}ryceZ3VmJv%48v!wV{lf74AB7EYvC-oFXt>=u2}YG%?1KmA5*=eJes
zRFJa?CEh60cdJe8=*rjhy!|gooL>~pnxq%-^PBVOG+ymVQpI|2q@z@IRlMI-r=*14
zvb6TIFgU(Pyr3+?*d9iN*RYWeer{lSpGnSO#Myh6Vt6uu0UFJw-ZHgNxT+-XTYAMP
z+4RkoFVaT8)
z;O%P8axik7MXzu6O;Ve*!)DqhtCV${^HPgJwlHaF4(nT0F_V#-XB+2ipiMJxk!bZr
zt)g8Q`k&JwV#dxoGg4F?H6DnAUq{aSx~a*A!L+@oQ=6OSkhx`*uoE^{5=_L>y{s+|
zkgTI(ywc6Y=2Uz5UB#GOugjgXfin|tlsm9m5uN430%-7*8xrQpg}2O!ju8izVZ!1K
zJB{+_g)ujML9v-!6y{j!yXh)>%6}0vHQ}&B!NU@EZWF7~;95|%4cdbfajYodd2d1F
z;V2V8iRSof)?CxhABdbv5RHw!s+r>Z%*6)CnSfk~uJ04D3$wlRA-1vXoZ2xv-%kN(
zHs|P_*|C-V{{ZZEZuLKCKQm(NFB+cD^dJ-VK7lva+Dz&cvncKS6VHYdNo^NGdU
zYHw&hC%dekwOqXr`_D(v;D|eh_cdcO+s9CIExdJ(V&M|RE#<6Y--5|60Zb1yJX>nf
z_teuHWbSB39_I!%i@GK#!ZO)Y3&o!}d$G&GcZPTj^
zOz)P21^L6Ud<|FglL+^`Zqo!GVU?Cv2e240ag
zd;{d+#^cImcz+dmRpD2bSAGbqB2KYWFVFZEDsWMg#U%|KUyiX;@|Lg4TEENt>f?SN
zFx7EbJ8eJi|;iE%-gxFCue!4elOAJ$*i8Fz9!0Icnc;L
zVzl;4$hS-}F0rMKNT=Jhf%mw3Y{R+f?{{qH-+wb9qU#wkZ%3R??`esI^mh(ZEpKJ#5REL>mw7!-tNlk?SunfB
z+seWV?*Yo}ta##Vf3
zgtGlKrI9eUL1}xs4F?zrN?#QaLdnLr0}HT|4L9XUx7H`T^ut+D@76A>vC{h_({e`i
zoo|~=MTyGS6QTZ6fwWna6Om+Xx+OhF(T_n(-&aJ{A5=~@y_G+9qS0YCA+>+2(kGxz
zcHG-~AJl7Us6Izl8V+PM=G-cP_gDk;{EwN=rUQ736r^Fdtmf(`Aj&Sq==yZTISHmx
zXG2NC4$IzPsBLyK;3sB_%2rU1fJeC;yZ1+orhKR5sJmM02KsR;W7ZC|eDyRgS$|-C
zoxss(xj%{0s8JbPtv$LV!5t++@k^^gP;w77TYoyyi%ihgZ?&GQ-r=b=*MWfWx->KE
zE5E7zEk1_;!z}IMV8?)|v%p-4&(Y7K*b_EZwmd{tGmNxU_)_aV8XBzAKC?%k*mGU4
zN}$7|XR=#r^l8Q3Y;z9rLNburrBiT!4QOEsmkh@7`JS)+!eMN={&S@Hcp&c6ZX<8@
zs|&kK_d~fcvUUtb3mhem^D)mh?L9WOWzA^!-z%d`F3>Asfyf$S+oY@Ll*aSCG~9lJ
z)g~}037Nx)OPVR8tkQ0iRIKrZ+J4Wor%Pb&Ee9*x9F6#FV+?z(?ir&g?zlU3iJ9JK
zX1%-phoffj+u(N(f(#l%;3=CMKhTIif6_fxyzMUc&nGr(Z=JVRhM+v8FrSI5_;_8#
zrJDZ$?RRXLlbJjiY!3Qm7Rc)sRPOC8uP@U(yV)YVJz5Gh;Vc`~{{T;8F=dO5l@fS1
z`9K`c+h{GQb`xZ5>78f_AL6MP?dp)`%TPR#SktS#Q!n<)jH
z&vJ!~SVZ1k_6P`(KOtKgL+-#*V<;#dB71Z051{#}+^rSSmviS+6ST2b-GwmH8L`_l
z%?_~>{e+wCn3FNI&_cq{X|s4KzUKOqizIEP-MdXT-mPJc27nz|~>Ghk;ni?V>TGjCCS
z(xHau13vjT+&|g%A};V{EfLahx;1R1-UrKBNlG}G2)0r!oi^V(a%UG8du6-ziehME
zv%g#bz|Ks?3$r3G19?aUS|?MSKXpk*Bej#^>>P4CrVY*rcifo^??=h~osHX+D)91!
zULH`WxeqBoNuB=w=9;s`n&mOOxA}?XW)>Ei6+(PY^Kx~H2GA4Kaejn&Kl3Ik*IMNd
zkGD*q*qIwsXqi~^W7a5>xf$R1SQ-s8F-=fMaG8a)dydRH#GO7N@9uX#%MpPOMF*>?Y+^j-MEli=ec(GG0
zyhVze{%cmXYY;PVmO*dB_|@TUyalY=$X2Qs6<;WA->c=fj<1*J@fI^JzL8%oymgGt
zV#h5Wr>@T+X(kmA0iMOLuClIZKBylJGLk&lki78lw1jicB2?@lm^*vZY?Q`
zy!)?qpyI>66#*3jA*MOl#6D_?9NcEKp=J0{C6pkd1u1WCDNCFj($3rGQ;SU(`x6VZ
z#~sy(U0v~(AjSLD&n;pP6xGiaMqd~E>%2UWSkH?x#(rAA<)~>fan>_^zL8!fjEQA0
z$!C5mBl4C{7?svnSz;07tb@rFk-07VR%gf!{{YcFLUx*`iYpey-@wkDp%QySrY3ro
zcSUeK%{2xLyQLWzd{t%xUK}eJmd$fV3IDrZX0Daix*pT3+o&
e@ox4|e2%3YjrDHRMM1yd?8MM`mn2K}PygApo3!Kr
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 15/56] 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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