[Function add]

1. Add leetcode solutions.

Author: Seanforfun

Algorithm(4th_Edition)/.idea/workspace.xml

@@ -371,6 +371,16 @@
 
 [212. Word Search II](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/212.%20Word%20Search%20II.md)
 
+[213. House Robber II](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/213.%20House%20Robber%20II.md)
+
+[214. Shortest Palindrome](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/214.%20Shortest%20Palindrome.md)
+
+[215. Kth Largest Element in an Array](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/215.%20Kth%20Largest%20Element%20in%20an%20Array.md)
+
+[216. Combination Sum III](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/216.%20Combination%20Sum%20III.md)
+
+[217. Contains Duplicate](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/217.%20Contains%20Duplicate.md)
+
 ## Algorithm(4th_Edition)
 Reading notes of book Algorithm(4th Algorithm),ISBN: 9787115293800.
 All java realization codes are placed in different packages.

README.md

@@ -48,4 +48,29 @@ class Solution {
         return Math.max(dp[len], dpp[len]);
     }
 }
+```
+
+### 二刷
+1. 这道题肯定是用DP解决，但是要分成两种情况：
+    * 如果抢了第一家，我们就不能抢最后一家。
+    * 如果我们抢了最后一家，就不能抢第一家。
+    * 这两种情况需要我们遍历两次循环，通过for循环控制。
+```Java
+class Solution {
+    public int rob(int[] nums) {
+        if(nums == null || nums.length < 1) return 0;
+        int len = nums.length;
+        if(1 == len) return nums[0];
+        int result = 0;
+        int[] dp = new int[len + 1];
+        for(int i = 1; i < len; i++){
+            dp[i] = Math.max(dp[i - 1], nums[i - 1] + (i >= 2 ? dp[i - 2] : 0));
+        }
+        int[] dp1 = new int[len + 1];
+        for(int i = 2; i <= len; i++){
+            dp1[i] = Math.max(dp1[i - 1], nums[i - 1] + dp1[i - 2]);
+        }
+        return Math.max(dp[len - 1], dp1[len]);
+    }
+}
 ```

leetcode/213. House Robber II.md

@@ -67,3 +67,47 @@ class Solution {
     }
 }
 ```
+
+### 二刷
+1. We can analyze one of the questions: aacecaaa
+    * We first assume we have a result, a + aacecaaa, so we want to find the "a".
+    * We create a new String aacecaaa # aaacecaa, where the third part is the reverse of the string and the first part is the original string. So the created string is palindrone.
+    * We want to find the longest common prefix and suffix. Where we find the a is the remain part of s, if not only a, we need to reverse the remain string.
+```Java
+class Solution {
+    public String shortestPalindrome(String s) {
+        String ss = s + "#" + new StringBuilder(s).reverse().toString();
+        int len = ss.length();
+        int[] next = new int[len];
+        next[0] = -1;
+        for(int i = 1, j = -1; i < len; i++){
+            while(j > -1 && ss.charAt(i) != ss.charAt(j + 1)){
+                j = next[j];
+            }
+            if(ss.charAt(j + 1) == ss.charAt(i)) j++;
+            next[i] = j;
+        }
+        return new StringBuilder(ss.substring(next[len - 1] + 1, s.length())).reverse().toString() + s;
+    }
+}
+```
+
+### Reference:
+1. [KMP](https://seanforfun.github.io/datastructure/2018/11/07/kmp.html)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

leetcode/214. Shortest Palindrome.md

@@ -50,3 +50,38 @@ class Solution {
     }
 }
 ```
+
+
+### 二刷
+1. Write quick sort by myself though the speed is not fast compared with Arrays.sort()
+```Java
+class Solution {
+    public int findKthLargest(int[] nums, int k) {
+        quickSort(nums, 0, nums.length - 1);
+        return nums[nums.length - k];
+    }
+    private void quickSort(int[] nums, int low, int high){
+        if(low >= high) return;
+        int pivot = partition(nums, low, high);
+        quickSort(nums, low, pivot - 1);
+        quickSort(nums, pivot + 1, high);
+    }
+    private int partition(int[] nums, int low, int high){
+        int i = low, j = high + 1;
+        int cmp = nums[low];
+        while(true){
+            while(nums[++i] <= cmp) if(i == high) break;
+            while(nums[--j] > cmp) if(j == low) break;
+            if(i >= j) break;
+            swap(nums, i, j);
+        }
+        swap(nums, low, j);
+        return j;
+    }
+    private void swap(int[] nums, int i, int j){
+        int temp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = temp;
+    }
+}
+```

leetcode/215. Kth Largest Element in an Array.md

@@ -50,3 +50,32 @@ class Solution {
     }
 }
 ```
+
+### 二刷
+1. Use backtrace to evaluate.
+2. Break out point: check the size of the array and the sum of the numbers in current array.
+```Java
+class Solution {
+    public List<List<Integer>> combinationSum3(int k, int n) {
+        List<List<Integer>> result = new LinkedList<>();
+        List<Integer> temp = new LinkedList<>();
+        backtrace(k, n, temp, result, 0, 1);
+        return result;
+    }
+    
+    private void backtrace(int k, int n, List<Integer> temp, List<List<Integer>> result, int sum, int cur){
+        if(temp.size() == k){
+            if(sum == n){
+                List<Integer> copy = new LinkedList<>(temp);
+                result.add(copy);
+            }
+        }else{
+            for(int i = cur; i <= 9; i++){
+                temp.add(i);
+                backtrace(k, n, temp, result, sum + i, i + 1);
+                temp.remove(temp.size() - 1);
+            }
+        }
+    }
+}
+```

leetcode/216. Combination Sum III.md

@@ -27,4 +27,19 @@ class Solution {
         return false;
     }
 }
+```
+
+### 二刷
+1. Sort the array first and traverse the array from the second index.
+2. check if current number equals the previous one, if equal, return true, else false;
+```Java
+class Solution {
+    public boolean containsDuplicate(int[] nums) {
+        Arrays.sort(nums);
+        for(int i = 1; i < nums.length; i++){
+            if(nums[i] == nums[i - 1]) return true;
+        }
+        return false;
+    }
+}
 ```