[pull] master from youngyangyang04:master

problems/0027.移除元素.md

@@ -146,18 +146,14 @@ public:
 };
 ```
 
-  
+
 ## 相关题目推荐
 
 * 26.删除排序数组中的重复项
 * 283.移动零
 * 844.比较含退格的字符串
 * 977.有序数组的平方
 
-
-
-
-
 ## 其他语言版本
 
 
@@ -177,6 +173,26 @@ class Solution {
     }
 }
 ```
+```java
+//相向双指针法
+class Solution {
+    public int removeElement(int[] nums, int val) {
+        int left = 0;
+        int right = nums.length - 1;
+        while(right >= 0 && nums[right] == val) right--; //将right移到从右数第一个值不为val的位置
+        while(left <= right) {
+            if(nums[left] == val) { //left位置的元素需要移除
+                //将right位置的元素移到left（覆盖），right位置移除
+                nums[left] = nums[right];
+                right--;
+            }
+            left++;
+            while(right >= 0 && nums[right] == val) right--;
+        }
+        return left;
+    }
+}
+```
 
 Python：
 

problems/0035.搜索插入位置.md

@@ -226,7 +226,32 @@ class Solution {
     }
 }
 ```
+```java
+//第二种二分法：左闭右开
+public int searchInsert(int[] nums, int target) {
+    int left = 0;
+    int right = nums.length; 
+    while (left < right) { //左闭右开 [left, right)
+        int middle = left + ((right - left) >> 1);
+        if (nums[middle] > target) {
+            right = middle; // target 在左区间，在[left, middle)中
+        } else if (nums[middle] < target) {
+            left = middle + 1; // target 在右区间，在 [middle+1, right)中
+        } else { // nums[middle] == target
+            return middle; // 数组中找到目标值的情况，直接返回下标
+        }
+    }
+    // 目标值在数组所有元素之前 [0,0)
+    // 目标值插入数组中的位置 [left, right) ，return right 即可
+    // 目标值在数组所有元素之后的情况 [left, right)，因为是右开区间，所以 return right
+    return right;
+}
+```
+
+
+
 Golang:
+
 ```golang
 // 第一种二分法
 func searchInsert(nums []int, target int) int {

problems/0131.分割回文串.md

@@ -206,6 +206,65 @@ public:
         return result;
     }
 };
+```
+# 优化
+
+上面的代码还存在一定的优化空间, 在于如何更高效的计算一个子字符串是否是回文字串。上述代码```isPalindrome```函数运用双指针的方法来判定对于一个字符串```s```, 给定起始下标和终止下标, 截取出的子字符串是否是回文字串。但是其中有一定的重复计算存在:
+
+例如给定字符串```"abcde"```, 在已知```"bcd"```不是回文字串时, 不再需要去双指针操作```"abcde"```而可以直接判定它一定不是回文字串。
+
+具体来说, 给定一个字符串`s`, 长度为```n```, 它成为回文字串的充分必要条件是```s[0] == s[n-1]```且```s[1:n-1]```是回文字串。
+
+大家如果熟悉动态规划这种算法的话, 我们可以高效地事先一次性计算出, 针对一个字符串```s```, 它的任何子串是否是回文字串, 然后在我们的回溯函数中直接查询即可, 省去了双指针移动判定这一步骤.
+
+具体参考代码如下:
+
+```CPP
+class Solution {
+private:
+    vector<vector<string>> result;
+    vector<string> path; // 放已经回文的子串
+    vector<vector<bool>> isPalindrome; // 放事先计算好的是否回文子串的结果
+    void backtracking (const string& s, int startIndex) {
+        // 如果起始位置已经大于s的大小，说明已经找到了一组分割方案了
+        if (startIndex >= s.size()) {
+            result.push_back(path);
+            return;
+        }
+        for (int i = startIndex; i < s.size(); i++) {
+            if (isPalindrome[startIndex][i]) {   // 是回文子串
+                // 获取[startIndex,i]在s中的子串
+                string str = s.substr(startIndex, i - startIndex + 1);
+                path.push_back(str);
+            } else {                                // 不是回文，跳过
+                continue;
+            }
+            backtracking(s, i + 1); // 寻找i+1为起始位置的子串
+            path.pop_back(); // 回溯过程，弹出本次已经填在的子串
+        }
+    }
+    void computePalindrome(const string& s) {
+        // isPalindrome[i][j] 代表 s[i:j](双边包括)是否是回文字串 
+        isPalindrome.resize(s.size(), vector<bool>(s.size(), false)); // 根据字符串s, 刷新布尔矩阵的大小
+        for (int i = s.size() - 1; i >= 0; i--) { 
+            // 需要倒序计算, 保证在i行时, i+1行已经计算好了
+            for (int j = i; j < s.size(); j++) {
+                if (j == i) {isPalindrome[i][j] = true;}
+                else if (j - i == 1) {isPalindrome[i][j] = (s[i] == s[j]);}
+                else {isPalindrome[i][j] = (s[i] == s[j] && isPalindrome[i+1][j-1]);}
+            }
+        }
+    }
+public:
+    vector<vector<string>> partition(string s) {
+        result.clear();
+        path.clear();
+        computePalindrome(s);
+        backtracking(s, 0);
+        return result;
+    }
+};
+
 ```
 
 # 总结

problems/0704.二分查找.md

@@ -290,10 +290,11 @@ func search(nums []int, target int) int {
  */
 var search = function(nums, target) {
     // right是数组最后一个数的下标，num[right]在查找范围内，是左闭右闭区间
-    let left = 0, right = nums.length - 1;
+    let mid, left = 0, right = nums.length - 1;
     // 当left=right时，由于nums[right]在查找范围内，所以要包括此情况
     while (left <= right) {
-        let mid = left + Math.floor((right - left)/2);
+        // 位运算 + 防止大数溢出
+        mid = left + ((right - left) >> 1);
         // 如果中间数大于目标值，要把中间数排除查找范围，所以右边界更新为mid-1；如果右边界更新为mid，那中间数还在下次查找范围内
         if (nums[mid] > target) {
             right = mid - 1;  // 去左面闭区间寻找
@@ -316,10 +317,11 @@ var search = function(nums, target) {
  */
 var search = function(nums, target) {
     // right是数组最后一个数的下标+1，nums[right]不在查找范围内，是左闭右开区间
-    let left = 0, right = nums.length;    
+    let mid, left = 0, right = nums.length;    
     // 当left=right时，由于nums[right]不在查找范围，所以不必包括此情况
     while (left < right) {
-        let mid = left + Math.floor((right - left)/2);
+        // 位运算 + 防止大数溢出
+        mid = left + ((right - left) >> 1);
         // 如果中间值大于目标值，中间值不应在下次查找的范围内，但中间值的前一个值应在；
         // 由于right本来就不在查找范围内，所以将右边界更新为中间值，如果更新右边界为mid-1则将中间值的前一个值也踢出了下次寻找范围
         if (nums[mid] > target) {
@@ -340,9 +342,10 @@ var search = function(nums, target) {
 
 ```typescript
 function search(nums: number[], target: number): number {
-    let left: number = 0, right: number = nums.length - 1;
+    let mid: number, left: number = 0, right: number = nums.length - 1;
     while (left <= right) {
-        let mid: number = left + Math.floor((right - left) / 2);
+        // 位运算 + 防止大数溢出
+        mid = left + ((right - left) >> 1);
         if (nums[mid] > target) {
             right = mid - 1;
         } else if (nums[mid] < target) {
@@ -359,9 +362,10 @@ function search(nums: number[], target: number): number {
 
 ```typescript
 function search(nums: number[], target: number): number {
-    let left: number = 0, right: number = nums.length;
+    let mid: number, left: number = 0, right: number = nums.length;
     while (left < right) {
-        let mid: number = left + Math.floor((right - left) / 2);
+        // 位运算 + 防止大数溢出
+        mid = left +((right - left) >> 1);
         if (nums[mid] > target) {
             right = mid;
         } else if (nums[mid] < target) {