Merge branch 'master' into master

problems/0337.打家劫舍III.md

@@ -370,46 +370,39 @@ class Solution:
 
 Go:
 
-树形DP
+动态规划
 
 ```go
-/**
- * Definition for a binary tree node.
- * type TreeNode struct {
- *     Val int
- *     Left *TreeNode
- *     Right *TreeNode
- * }
- */
 func rob(root *TreeNode) int {
-    return max(robTree(root))
+	res := robTree(root)
+	return max(res[0], res[1])
 }
-func robTree(root *TreeNode)(int,int){
+
-    if root==nil{
+func max(a, b int) int {
-        return 0,0
+	if a > b {
-    }
-    //获取左节点的偷的值与不偷的值
-    left0,left1:=robTree(root.Left)
-    //获取右节点的偷的值与不偷的值
-    right0,right1:=robTree(root.Right)
-    //偷
-    val1:=root.Val
-    val1+=left1+right1
-    //不偷
-    val2:=0
-    val2+=max(left0,left1)+max(right0,right1)
-    return val1,val2
-}
-func max(a,b int)int{
-    if a>b{
 		return a
 	}
 	return b
 }
+
+func robTree(cur *TreeNode) []int {
+	if cur == nil {
+		return []int{0, 0}
+	}
+	// 后序遍历
+	left := robTree(cur.Left)
+	right := robTree(cur.Right)
+
+    // 考虑去偷当前的屋子
+	robCur := cur.Val + left[0] + right[0]
+    // 考虑不去偷当前的屋子
+	notRobCur := max(left[0], left[1]) + max(right[0], right[1])
+
+    // 注意顺序：0:不偷，1:去偷
+	return []int{notRobCur, robCur}
+}
 ```
 
-
-
 JavaScript：
 
 > 动态规划

problems/0416.分割等和子集.md

@@ -226,6 +226,32 @@ class Solution:
         return taraget == dp[taraget]
 ```
 Go：
+```go
+// 分割等和子集 动态规划
+// 时间复杂度O(n^2) 空间复杂度O(n)
+func canPartition(nums []int) bool {
+    sum := 0
+    for _, num := range nums {
+        sum += num
+    }
+    // 如果 nums 的总和为奇数则不可能平分成两个子集
+    if sum % 2 == 1 {
+        return false
+    }
+    
+    target := sum / 2
+    dp := make([]int, target + 1)
+
+    for _, num := range nums {
+        for j := target; j >= num; j-- {
+            if dp[j] < dp[j - num] + num {
+                dp[j] = dp[j - num] + num
+            }
+        }
+    }
+    return dp[target] == target
+}
+```
 
 ```go
 func canPartition(nums []int) bool {

problems/剑指Offer58-II.左旋转字符串.md

@@ -200,17 +200,14 @@ func reverse(b []byte, left, right int){
 JavaScript：
 
 ```javascript
-var reverseLeftWords = function (s, n) {
+var reverseLeftWords = function(s, n) {
-    const reverse = (str, left, right) => {
+  const length = s.length;
-        let strArr = str.split("");
+  let i = 0;
-        for (; left < right; left++, right--) {
+  while (i < length - n) {
-            [strArr[left], strArr[right]] = [strArr[right], strArr[left]];
+    s = s[length - 1] + s;
+    i++;
   }
-        return strArr.join("");
+  return s.slice(0, length);
-    }
-    s = reverse(s, 0, n - 1);
-    s = reverse(s, n, s.length - 1);
-    return reverse(s, 0, s.length - 1);
 };
 ```