Merge remote-tracking branch 'origin/master'

Author: relish-wang

README.md

@@ -80,10 +80,10 @@
 | [696][696-question] | [Count Binary Substrings][696-tips]                          | [✅][696-java] | [✅][696-js] |                  |
 | [697][697-question] | [Degree of an Array][697-tips]                               | [✅][697-java] | [✅][697-js] |                  |
 | [717][717-question] | [1-bit and 2-bit Characters][717-tips]                       | [✅][717-java] | [✅][717-js] |                  |
-| [720][720-question] | [Longest Word in Dictionary][720-tips]                       |                | [✅][720-js] |                  |
-| [724][724-question] | [Find Pivot Index][724-tips]                                 |                | [✅][724-js] |                  |
+| [720][720-question] | [Longest Word in Dictionary][720-tips]                       | [✅][720-java] | [✅][720-js] |                  |
+| [724][724-question] | [Find Pivot Index][724-tips]                                 | [✅][724-java] | [✅][724-js] |                  |
 | [728][728-question] | [Self Dividing Numbers][728-tips]                            | [✅][728-java] | [✅][728-js] |                  |
-| [733][733-question] | [Flood Fill][733-tips]                                       |                | [✅][733-js] |                  |
+| [733][733-question] | [Flood Fill][733-tips]                                       | [✅][733-java] | [✅][733-js] |                  |
 | [744][744-question] | [Find Smallest Letter Greater Than Target][744-tips]         |                | [✅][744-js] |                  |
 | [746][746-question] | [Min Cost Climbing Stairs][746-tips]                         |                | [✅][746-js] |                  |
 | [747][747-question] | [Largest Number At Least Twice of Others][747-tips]          |                | [✅][747-js] |                  |
@@ -478,7 +478,10 @@
 [696-java]: ./src/_696/Solution.java
 [697-java]: ./src/_697/Solution.java
 [717-java]: ./src/_717/Solution.java
+[720-java]: ./src/_720/Solution.java
+[724-java]: ./src/_724/Solution.java
 [728-java]: ./src/_728/Solution.java
+[733-java]: ./src/_733/Solution.java
 [771-java]: ./src/_771/Solution.java
 [804-java]: ./src/_804/Solution.java
 

src/_720/Solution.java

@@ -0,0 +1,21 @@
+package _720;
+
+import java.util.Arrays;
+import java.util.HashSet;
+
+class Solution {
+    public String longestWord(String[] words) {
+        String ans = "";
+        HashSet<String> set = new HashSet<>(words.length);
+        Arrays.sort(words);
+        for (String s : words) {
+            if (s.length() == 1 || set.contains(s.substring(0, s.length()-1))) {
+                if (ans.length() < s.length()) {
+                    ans = s;
+                }
+                set.add(s);
+            }
+        }
+        return ans;
+    }
+}

src/_724/Solution.java

@@ -0,0 +1,37 @@
+package _724;
+
+class Solution {
+    public int pivotIndex(int[] nums) {
+        if (nums == null || nums.length == 0) {
+            return -1;
+        }
+
+        int leftSum = 0;
+        int rightSum = 0;
+
+        for (int i = nums.length - 1; i > 0; i--) {
+            rightSum += nums[i];
+        }
+
+        if (rightSum == 0) {
+            return 0;
+        }
+
+        for (int i = 1; i < nums.length; i++) {
+            leftSum += nums[i - 1];
+            rightSum -= nums[i];
+            if (leftSum == rightSum) {
+                return i;
+            }
+        }
+
+        return -1;
+    }
+
+    public static void main(String[] args) {
+        Solution solution = new Solution();
+        System.out.println(solution.pivotIndex(new int[]{1, 7, 3, 6, 5, 6}));
+        System.out.println(solution.pivotIndex(new int[]{1, 2, 3}));
+        System.out.println(solution.pivotIndex(new int[]{0}));
+    }
+}

src/_733/Solution.java

@@ -0,0 +1,33 @@
+package _733;
+
+class Solution {
+    public int[][] floodFill(int[][] image, int sr, int sc, int newColor) {
+        int oldColor = image[sr][sc];
+        if (oldColor == newColor) {
+            return image;
+        }
+        dfs(image, sr, sc, oldColor, newColor);
+        return image;
+    }
+
+    private void dfs(int[][] image, int sr, int sc, int oldColor, int newColor) {
+        if (image[sr][sc] == oldColor) {
+            image[sr][sc] = newColor;
+            if (sr > 0) dfs(image, sr - 1, sc, oldColor, newColor);
+            if (sr + 1 < image.length) dfs(image, sr + 1, sc, oldColor, newColor);
+            if (sc > 0) dfs(image, sr, sc - 1, oldColor, newColor);
+            if (sc + 1 < image[sr].length) dfs(image, sr, sc + 1, oldColor, newColor);
+        }
+    }
+
+    public static void main(String[] args) {
+        Solution solution = new Solution();
+        int[][] image = solution.floodFill(new int[][]{{1, 1, 1}, {1, 1, 0}, {1, 0, 1}}, 1, 1, 2);
+        for (int[] row : image) {
+            for (int num : row) {
+                System.out.print(num + " ");
+            }
+            System.out.println();
+        }
+    }
+}

tips/720/README.md

@@ -1,46 +1,65 @@
-[xxxx][title]
+[Longest Word in Dictionary ][title]
 
 ## Description
-// 抄题目
 
+Given a list of strings `words` representing an English Dictionary, find the longest word in `words` that can be built one character at a time by other words in `words`. If there is more than one possible answer, return the longest word with the smallest lexicographical order.
 
-**Example:**
+If there is no answer, return the empty string.
+
+**Example 1:**
 
 ```
-// 抄Example
+Input: 
+words = ["w","wo","wor","worl", "world"]
+Output: "world"
+Explanation: 
+The word "world" can be built one character at a time by "w", "wo", "wor", and "worl".
 ```
 
-**Note:**
-// Note
+**Example 2:**
 
-**Tags:** // tags
+```
+Input: 
+words = ["a", "banana", "app", "appl", "ap", "apply", "apple"]
+Output: "apple"
+Explanation: 
+Both "apply" and "apple" can be built from other words in the dictionary. However, "apple" is lexicographically smaller than "apply".
+```
 
+**Note:**
 
-## 思路 1
-// 贴一些关键代码,说一些解题思路
-// (同一种语言可以写多种思路，与某种语言思路相同的另一种语言的思路无须赘述，但可以把代码贴在后面) 
-```java
+All the strings in the input will only contain lowercase letters.
 
-```
-```javascript
+The length of `words` will be in the range `[1, 1000]`.
 
-```
+The length of `words[i]` will be in the range `[1, 30]`.
 
-## 思路 2
-// 贴一些关键代码,说一些解题思路
-```java
+**Tags:** [Hash Table](https://leetcode.com/tag/hash-table/)、[Trie](https://leetcode.com/tag/trie/)
 
-```
+## 思路 1
 
-## 思路 3
-// 贴一些关键代码,说一些解题思路
-```kotlin
+我们可以将字符串按长度从小到大依次放入一个集合中，这样可以保证在放入字符串时，所有有可能是此字符串前缀的字符串都在此集合中。当要放入集合中时，我们判断原字符串去掉最后一个字符后的字符串是否存在于集合中，若存在才将此字符串放入集合，这样可以保证，集合中的字符串都可以在集合中找到自己的任意长度前缀。按上述要求将所有字符串放入集合，过程中不断更新较长的符合要求的字符串即可。
 
+```java
+public String longestWord(String[] words) {
+    String ans = "";
+    HashSet<String> set = new HashSet<>(words.length);
+    Arrays.sort(words);
+    for (String s : words) {
+        if (s.length() == 1 || set.contains(s.substring(0, s.length()-1))) {
+            if (ans.length() < s.length()) {
+                ans = s;
+            }
+            set.add(s);
+        }
+    }
+    return ans;
+}
 ```
 
 ## 结语
-   
+
 如果你同我们一样热爱数据结构、算法、LeetCode，可以关注我们 GitHub 上的 LeetCode 题解：[LeetCode-Solution][ls]
 
-[title]: https://leetcode.com/problems/xxxx
+[title]: https://leetcode.com/problems/longest-word-in-dictionary/description/
 [ls]: https://github.com/RichCodersAndMe/LeetCode-Solution

tips/724/README.md

@@ -1,46 +1,83 @@
-[xxxx][title]
+[Find Pivot Index ][title]
 
 ## Description
-// 抄题目
 
+Given an array of integers `nums`, write a method that returns the "pivot" index of this array.
 
-**Example:**
+We define the pivot index as the index where the sum of the numbers to the left of the index is equal to the sum of the numbers to the right of the index.
+
+If no such index exists, we should return -1. If there are multiple pivot indexes, you should return the left-most pivot index.
+
+**Example 1:**
 
 ```
-// 抄Example
+Input: 
+nums = [1, 7, 3, 6, 5, 6]
+Output: 3
+Explanation: 
+The sum of the numbers to the left of index 3 (nums[3] = 6) is equal to the sum of numbers to the right of index 3.
+Also, 3 is the first index where this occurs.
 ```
 
-**Note:**
-// Note
+**Example 2:**
 
-**Tags:** // tags
+```
+Input: 
+nums = [1, 2, 3]
+Output: -1
+Explanation: 
+There is no index that satisfies the conditions in the problem statement.
+```
 
+**Note:**
 
-## 思路 1
-// 贴一些关键代码,说一些解题思路
-// (同一种语言可以写多种思路，与某种语言思路相同的另一种语言的思路无须赘述，但可以把代码贴在后面) 
-```java
+The length of `nums` will be in the range `[0, 10000]`.
 
-```
-```javascript
+Each element `nums[i]` will be an integer in the range `[-1000, 1000]`.
 
-```
+**Tags:** [Array](https://leetcode.com/tag/array/)
 
-## 思路 2
-// 贴一些关键代码,说一些解题思路
-```java
+## 思路
 
-```
+在所给整型数组中寻找枢纽点（枢纽点左侧数字的和等于右侧数字的和），若有多个枢纽点，仅返回最左边的，若没有枢纽点则返回`-1`。
+
+我们通过一遍循环就可以获得所有数字的左右两侧的和，将其记录下来就可以轻松的得出枢纽点的位置。不过一次性记录下来需要额外的申请两个等大的数组。实际上我们只需要通过整个数组的和，就可以简单的推算出左右两边的和。假使我们从左往右遍历，每遍历到一个数都将其当做枢纽点，将枢纽左侧的数依次相加就等于左边的和，将数组的和依次减去枢纽的值就等于右边的和。 
 
-## 思路 3
-// 贴一些关键代码,说一些解题思路
-```kotlin
+**Java:**
 
+```java
+public int pivotIndex(int[] nums) {
+    if (nums == null || nums.length == 0) {
+        return -1;
+    }
+
+    int leftSum = 0;
+    int rightSum = 0;
+    
+    for (int i = nums.length - 1; i > 0; i--) {
+        rightSum += nums[i];
+    }
+
+    if (rightSum == 0) {
+        return 0;
+    }
+    
+    for (int i = 1; i < nums.length; i++) {
+        leftSum += nums[i - 1];
+        rightSum -= nums[i];
+        if (leftSum == rightSum) {
+            return i;
+        }
+    }
+
+    return -1;
+}
 ```
 
 ## 结语
-   
+
 如果你同我们一样热爱数据结构、算法、LeetCode，可以关注我们 GitHub 上的 LeetCode 题解：[LeetCode-Solution][ls]
 
-[title]: https://leetcode.com/problems/xxxx
-[ls]: https://github.com/RichCodersAndMe/LeetCode-Solution
+[title]: https://leetcode.com/problems/find-pivot-index/description/
+[ls]: https://github.com/RichCodersAndMe/LeetCode-Solution
+