Merge pull request #1 from Blankj/master

更新数据

Author: brianfdc

README.md

@@ -69,12 +69,19 @@
 | :--- | :--------------------------------------- | :------------------------------- |
 | 2    | [Add Two Numbers][002]                   | Linked List, Math                |
 | 3    | [Longest Substring Without Repeating Characters][003] | Hash Table, Two Pointers, String |
-| 5    | [Longest Palindromic Substring][005]     | String                           |
+| 5    | [Longest Palindromic Substring][005]     | String, Dynamic Programming      |
 | 6    | [ZigZag Conversion][006]                 | String                           |
 | 8    | [String to Integer (atoi)][008]          | Math, String                     |
+| 11   | [Container With Most Water][011]         | Array, Two Pointers              |
+| 12   | [Integer to Roman][012]                  | Math, String                     |
 | 15   | [3Sum][015]                              | Array, Two Pointers              |
+| 15   | [3Sum Closest][016]                      | Array, Two Pointers              |
 | 17   | [Letter Combinations of a Phone Number][017] | String, Backtracking             |
+| 18   | [4Sum][018]                              | Array, Hash Table, Two Pointers  |
 | 19   | [Remove Nth Node From End of List][019]  | Linked List, Two Pointers        |
+| 22   | [Generate Parentheses][022]              | String, Backtracking             |
+| 24   | [Swap Nodes in Pairs][024]               | Linked List                      |
+| 29   | [Divide Two Integers][029]               | Math, Binary Search              |
 | 33   | [Search in Rotated Sorted Array][033]    | Arrays, Binary Search            |
 | 43   | [Multiply Strings][043]                  | Math, String                     |
 | 49   | [Group Anagrams][049]                    | Hash Table, String               |
@@ -85,15 +92,16 @@
 
 ## Hard
 
-| #    | Title                              | Tag                                      |
-| :--- | :--------------------------------- | :--------------------------------------- |
-| 4    | [Median of Two Sorted Arrays][004] | Array, Binary Search, Divide and Conquer |
-| 10   | [Regular Expression Matching][010] | String, Dynamic Programming, Backtracking |
-| 23   | [Merge k Sorted Lists][023]        | Linked List, Divide and Conquer, Heap    |
-| 25   | [Reverse Nodes in k-Group][025]    | Linked List                              |
-| 44   | [Wildcard Matching][044]           | String, Dynamic Programming, Backtracking, Greedy |
-| 57   | [Insert Interval][057]             | Array, Sort                              |
-| 68   | [Text Justification][068]          | String                                   |
+| #    | Title                                    | Tag                                      |
+| :--- | :--------------------------------------- | :--------------------------------------- |
+| 4    | [Median of Two Sorted Arrays][004]       | Array, Binary Search, Divide and Conquer |
+| 10   | [Regular Expression Matching][010]       | String, Dynamic Programming, Backtracking |
+| 23   | [Merge k Sorted Lists][023]              | Linked List, Divide and Conquer, Heap    |
+| 25   | [Reverse Nodes in k-Group][025]          | Linked List                              |
+| 30   | [Substring with Concatenation of All Words][030] | Hash Table, Two Pointers, String         |
+| 44   | [Wildcard Matching][044]                 | String, Dynamic Programming, Backtracking, Greedy |
+| 57   | [Insert Interval][057]                   | Array, Sort                              |
+| 68   | [Text Justification][068]                | String                                   |
 
 
 
@@ -141,9 +149,16 @@
 [005]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/005/README.md
 [006]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/006/README.md
 [008]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/008/README.md
+[011]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/011/README.md
+[012]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/012/README.md
 [015]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/015/README.md
+[016]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/016/README.md
 [017]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/017/README.md
+[018]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/018/README.md
 [019]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/019/README.md
+[022]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/022/README.md
+[024]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/024/README.md
+[029]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/029/README.md
 [033]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/033/README.md
 [043]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/043/README.md
 [049]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/049/README.md
@@ -155,6 +170,7 @@
 [010]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/010/README.md
 [023]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/023/README.md
 [025]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/025/README.md
+[030]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/030/README.md
 [044]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/044/README.md
 [057]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/057/README.md
 [068]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/068/README.md

note/005/README.md

@@ -4,7 +4,7 @@
 
 Given a string **s**, find the longest palindromic substring in **s**. You may assume that the maximum length of **s** is 1000.
 
-**Example:**
+**Example 1:**
 
 ```
 Input: "babad"
@@ -14,15 +14,15 @@ Output: "bab"
 Note: "aba" is also a valid answer.
 ```
 
-**Example:**
+**Example 2:**
 
 ```
 Input: "cbbd"
 
 Output: "bb"
 ```
 
-**Tags:** String
+**Tags:** String, Dynamic Programming
 
 
 ## 思路 0

note/006/README.md

@@ -15,10 +15,28 @@ And then read line by line: `"PAHNAPLSIIGYIR"`
 Write the code that will take a string and make this conversion given a number of rows:
 
 ```
-string convert(string text, int nRows);
+string convert(string s, int numRows);
 ```
 
-`convert("PAYPALISHIRING", 3)` should return `"PAHNAPLSIIGYIR"`.
+**Example 1:**
+
+```
+Input: s = "PAYPALISHIRING", numRows = 3
+Output: "PAHNAPLSIIGYIR"
+```
+
+**Example 2:**
+
+```
+Input: s = "PAYPALISHIRING", numRows = 4
+Output: "PINALSIGYAHRPI"
+Explanation:
+
+P     I    N
+A   L S  I G
+Y A   H R
+P     I
+```
 
 **Tags:** String
 

note/008/README.md

@@ -2,23 +2,62 @@
 
 ## Description
 
-Implement atoi to convert a string to an integer.
+Implement `atoi` which converts a string to an integer.
 
-**Hint:** Carefully consider all possible input cases. If you want a challenge, please do not see below and ask yourself what are the possible input cases.
+The function first discards as many whitespace characters as necessary until the first non-whitespace character is found. Then, starting from this character, takes an optional initial plus or minus sign followed by as many numerical digits as possible, and interprets them as a numerical value.
 
-**Notes:** It is intended for this problem to be specified vaguely (ie, no given input specs). You are responsible to gather all the input requirements up front.
+The string can contain additional characters after those that form the integral number, which are ignored and have no effect on the behavior of this function.
 
-**Spoilers:**
+If the first sequence of non-whitespace characters in str is not a valid integral number, or if no such sequence exists because either str is empty or it contains only whitespace characters, no conversion is performed.
 
-**Requirements for atoi:**
+If no valid conversion could be performed, a zero value is returned.
 
-The function first discards as many whitespace characters as necessary until the first non-whitespace character is found. Then, starting from this character, takes an optional initial plus or minus sign followed by as many numerical digits as possible, and interprets them as a numerical value.
+**Note:**
 
-The string can contain additional characters after those that form the integral number, which are ignored and have no effect on the behavior of this function.
+- Only the space character `' '` is considered as whitespace character.
+- Assume we are dealing with an environment which could only store integers within the 32-bit signed integer range: [−2<sup>31</sup>,  2<sup>31</sup> − 1]. If the numerical value is out of the range of representable values, INT_MAX (2<sup>31</sup> − 1) or INT_MIN (−2<sup>31</sup>) is returned.
 
-If the first sequence of non-whitespace characters in str is not a valid integral number, or if no such sequence exists because either str is empty or it contains only whitespace characters, no conversion is performed.
+**Example 1:**
+
+```
+Input: "42"
+Output: 42
+```
+
+**Example 2:**
+
+```
+Input: "   -42"
+Output: -42
+Explanation: The first non-whitespace character is '-', which is the minus sign.
+             Then take as many numerical digits as possible, which gets 42.
+```
+
+**Example 3:**
+
+```
+Input: "4193 with words"
+Output: 4193
+Explanation: Conversion stops at digit '3' as the next character is not a numerical digit.
+```
+
+**Example 4:**
 
-If no valid conversion could be performed, a zero value is returned. If the correct value is out of the range of representable values, INT_MAX (2147483647) or INT_MIN (-2147483648) is returned.
+```
+Input: "words and 987"
+Output: 0
+Explanation: The first non-whitespace character is 'w', which is not a numerical 
+             digit or a +/- sign. Therefore no valid conversion could be performed.
+```
+
+**Example 5:**
+
+```
+Input: "-91283472332"
+Output: -2147483648
+Explanation: The number "-91283472332" is out of the range of a 32-bit signed integer.
+             Thefore INT_MIN (−2^31) is returned.
+```
 
 **Tags:** Math, String
 
@@ -37,12 +76,13 @@ class Solution {
         }
         for (; i < len; ++i) {
             int tmp = str.charAt(i) - '0';
-            if (tmp < 0 || tmp > 9)
-                break;
-            if (ans > Integer.MAX_VALUE / 10 || ans == Integer.MAX_VALUE / 10 && Integer.MAX_VALUE % 10 < tmp)
+            if (tmp < 0 || tmp > 9) break;
+            if (ans > Integer.MAX_VALUE / 10
+                    || (ans == Integer.MAX_VALUE / 10 && (sign == 1 && tmp > 7 || sign == -1 && tmp > 8))) {
                 return sign == 1 ? Integer.MAX_VALUE : Integer.MIN_VALUE;
-            else
+            } else {
                 ans = ans * 10 + tmp;
+            }
         }
         return sign * ans;
     }

note/009/README.md

@@ -2,19 +2,34 @@
 
 ## Description
 
-Determine whether an integer is a palindrome. Do this without extra space.
+Determine whether an integer is a palindrome. An integer is a palindrome when it reads the same backward as forward.
 
-**Spoilers:**
+**Example 1:**
 
-**Some hints:**
+```
+Input: 121
+Output: true
+```
+
+**Example 2:**
+
+```
+Input: -121
+Output: false
+Explanation: From left to right, it reads -121. From right to left, it becomes 121-. Therefore it is not a palindrome.
+```
 
-Could negative integers be palindromes? (ie, -1)
+**Example 3:**
 
-If you are thinking of converting the integer to string, note the restriction of using extra space.
+```
+Input: 10
+Output: false
+Explanation: Reads 01 from right to left. Therefore it is not a palindrome.
+```
 
-You could also try reversing an integer. However, if you have solved the problem "Reverse Integer", you know that the reversed integer might overflow. How would you handle such case?
+**Follow up:**
 
-There is a more generic way of solving this problem.
+Coud you solve it without converting the integer to a string?
 
 **Tags:** Math
 

note/010/README.md

@@ -2,33 +2,75 @@
 
 ## Description
 
-Implement regular expression matching with support for `'.'` and `'*'`.
+Given an input string (`s`) and a pattern (`p`), implement regular expression matching with support for `'.'` and `'*'`.
 
 ```
 '.' Matches any single character.
 '*' Matches zero or more of the preceding element.
+```
+
+The matching should cover the **entire** input string (not partial).
+
+**Note:**
+
+- `s` could be empty and contains only lowercase letters `a-z`.
+- `p` could be empty and contains only lowercase letters `a-z`, and characters like `.` or `*`.
+
+**Example 1:**
+
+```
+Input:
+s = "aa"
+p = "a"
+Output: false
+Explanation: "a" does not match the entire string "aa".
+```
+
+**Example 2:**
+
+```
+Input:
+s = "aa"
+p = "a*"
+Output: true
+Explanation: '*' means zero or more of the precedeng element, 'a'. Therefore, by repeating 'a' once, it becomes "aa".
+```
+
+**Example 3:**
+
+```
+Input:
+s = "ab"
+p = ".*"
+Output: true
+Explanation: ".*" means "zero or more (*) of any character (.)".
+```
 
-The matching should cover the entire input string (not partial).
+**Example 4:**
 
-The function prototype should be:
-bool isMatch(const char *s, const char *p)
+```
+Input:
+s = "aab"
+p = "c*a*b"
+Output: true
+Explanation: c can be repeated 0 times, a can be repeated 1 time. Therefore it matches "aab".
+```
 
-Some examples:
-isMatch("aa", "a") → false
-isMatch("aa", "aa") → true
-isMatch("aaa", "aa") → false
-isMatch("aa", "a*") → true
-isMatch("aa", ".*") → true
-isMatch("ab", ".*") → true
-isMatch("aab", "c*a*b") → true
+**Example 5:**
+
+```
+Input:
+s = "mississippi"
+p = "mis*is*p*."
+Output: false
 ```
 
 **Tags:** String, Dynamic Programming, Backtracking
 
 
 ## 思路 0
 
-题意是让让你从判断 `s` 字符串是否正则匹配于 `p`，这道题和[Wildcard Matching][044]很是相似，区别在于 `*`，通配符的 `*` 是可以随意出现的，跟前面字符没有任何关系，其作用是可以表示任意字符串；而正则匹配的 `*` 不能单独存在，前面必须具有一个字符，其意义是表明前面的这个字符个数可以是任意个数，包括 0 个。首先我们用递归的方式来实现，其思路如下：
+题意是让让你从判断 `s` 字符串是否正则匹配于 `p`，这道题和 [Wildcard Matching][044] 很是相似，区别在于 `*`，通配符的 `*` 是可以随意出现的，跟前面字符没有任何关系，其作用是可以表示任意字符串；而正则匹配的 `*` 不能单独存在，前面必须具有一个字符，其意义是表明前面的这个字符个数可以是任意个数，包括 0 个。首先我们用递归的方式来实现，其思路如下：
 
 * 如果 `s` 和 `p` 都为空，那么返回 `true`；
 

note/011/README.md

@@ -0,0 +1,47 @@
+# [Container With Most Water][title]
+
+## Description
+
+Given *n* non-negative integers *a1*, *a2*, ..., *an*, where each represents a point at coordinate (*i*, *ai*). *n* vertical lines are drawn such that the two endpoints of line *i* is at (*i*, *ai*) and (*i*, 0). Find two lines, which together with x-axis forms a container, such that the container contains the most water.
+
+Note: You may not slant the container and *n* is at least 2.
+
+**Tags:** Array, Two Pointers
+
+
+## 思路
+
+题意是给你 *a1*, *a2*, ..., *an* 这 *n* 个数，代表 (*i*, *ai*) 坐标，让你从中找两个点与 x 轴围成的容器可以容纳最多的水。
+
+不明白的话可以看数据为 `1 8 6 2 5 4 8 3 7` 所示的图。
+
+![](https://raw.githubusercontent.com/Blankj/awesome-java-leetcode/master/note/011/water.png)
+
+如果用暴力法求每种情况的结果，其时间复杂度为 O(n^2)，相信肯定会超时，我们可以探索下是否有更巧妙的办法呢，题目的标签有双指针，是否就可以想到首尾各放一指针，然后根据条件来收缩。首先计算一次首尾构成的最大面积，然后分析下该移动哪个指针，如果移动大的那个指针的话，那样只会减小面积，所以我们要移动小的那个指针，小的那个指针移动到哪呢？当然是移动到大于之前的值的地方，否则面积不都比之前小么，然后继续更新最大值即可，借助如上分析写出如下代码应该不是什么难事了吧。
+
+
+```java
+class Solution {
+    public int maxArea(int[] height) {
+        int l = 0, r = height.length - 1;
+        int max = 0, h = 0;
+        while (l < r) {
+            h = Math.min(height[l], height[r]);
+            max = Math.max(max, (r - l) * h);
+            while (height[l] <= h && l < r) ++l;
+            while (height[r] <= h && l < r) --r;
+        }
+        return max;
+    }
+}
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-java-leetcode][ajl]
+
+
+
+[title]: https://leetcode.com/problems/container-with-most-water
+[ajl]: https://github.com/Blankj/awesome-java-leetcode