Merge branch 'youngyangyang04:master' into zhicheng-lee-patch-8

problems/0337.打家劫舍III.md

@@ -191,7 +191,7 @@ public:
         vector<int> left = robTree(cur->left);
         vector<int> right = robTree(cur->right);
         // 偷cur，那么就不能偷左右节点。
-        int val1 = cur->val + left[1] + right[1];
+        int val1 = cur->val + left[0] + right[0];
         // 不偷cur，那么可以偷也可以不偷左右节点，则取较大的情况
         int val2 = max(left[0], left[1]) + max(right[0], right[1]);
         return {val2, val1};

problems/0452.用最少数量的箭引爆气球.md

@@ -137,29 +137,21 @@ public:
 ### Java 
 ```java
 /**
-时间复杂度 : O(NlogN)  排序需要 O(NlogN) 的复杂度
-
-空间复杂度 : O(logN) java所使用的内置函数用的是快速排序需要 logN 的空间
-*/
+ * 时间复杂度 : O(NlogN)  排序需要 O(NlogN) 的复杂度
+ * 空间复杂度 : O(logN) java所使用的内置函数用的是快速排序需要 logN 的空间
+ */
 class Solution {
     public int findMinArrowShots(int[][] points) {
-        if (points.length == 0) return 0;
-        //用x[0] - y[0] 会大于2147483647 造成整型溢出
-        Arrays.sort(points, (x, y) -> Integer.compare(x[0], y[0]));
-        //count = 1 因为最少需要一个箭来射击第一个气球
-        int count = 1;
-        //重叠气球的最小右边界
-        int leftmostRightBound  = points[0][1];
+        // 根据气球直径的开始坐标从小到大排序
+        // 使用Integer内置比较方法，不会溢出
+        Arrays.sort(points, (a, b) -> Integer.compare(a[0], b[0]));
+
+        int count = 1;  // points 不为空至少需要一支箭
         for (int i = 1; i < points.length; i++) {
-        //如果下一个气球的左边界大于最小右边界
-        for(int i = 1; i < points.length; i++){
-            if (points[i][0] > leftmostRightBound ) {
-                //增加一次射击
-                count++;
-                leftmostRightBound  = points[i][1];
-                //不然就更新最小右边界
-            } else {
-                leftmostRightBound  = Math.min(leftmostRightBound , points[i][1]);
+            if (points[i][0] > points[i - 1][1]) {  // 气球i和气球i-1不挨着，注意这里不是>=
+                count++; // 需要一支箭
+            } else {  // 气球i和气球i-1挨着
+                points[i][1] = Math.min(points[i][1], points[i - 1][1]); // 更新重叠气球最小右边界
             }
         }
         return count;

problems/0463.岛屿的周长.md

@@ -179,6 +179,25 @@ class Solution:
 ```
 
 Go：
+```go
+func islandPerimeter(grid [][]int) int {
+    m, n := len(grid), len(grid[0])
+    res := 0
+    for i := 0; i < m; i++ {
+        for j := 0; j < n; j++ {
+            if grid[i][j] == 1 {
+                res += 4
+                // 上下左右四个方向
+                if i > 0 && grid[i-1][j] == 1 {res--} // 上边有岛屿
+                if i < m-1 && grid[i+1][j] == 1 {res--} // 下边有岛屿
+                if j > 0 && grid[i][j-1] == 1 {res--} // 左边有岛屿
+                if j < n-1 && grid[i][j+1] == 1 {res--} // 右边有岛屿
+            }
+        }
+    }
+    return res
+}
+```
 
 JavaScript：
 ```javascript

problems/1356.根据数字二进制下1的数目排序.md

@@ -170,6 +170,39 @@ class Solution:
 ## Go
 
 ```go
+func sortByBits(arr []int) []int {
+    var tmp int
+    for i := 0; i < len(arr); i++ {
+        for j := i+1; j < len(arr); j++ {
+            // 冒泡排序的手法，但是排序的规则从比大小变成了比位运算1的个数
+            if isCmp(arr[i], arr[j]) {
+                tmp = arr[i]
+                arr[i] = arr[j]
+                arr[j] = tmp
+            }
+        } 
+    }
+    return arr
+}
+
+func isCmp(a, b int) bool {
+    bitA := bitCount(a)
+    bitB := bitCount(b)
+    if bitA == bitB {
+        return a > b
+    } else {
+        return bitA > bitB 
+    }
+}
+
+func bitCount(n int) int {
+    count := 0
+    for n != 0 {
+        n &= (n-1) // 清除最低位的1
+        count++
+    }
+    return count
+}
 ```
 
 ## JavaScript