Update

Author: youngyangyang04

README.md

@@ -107,7 +107,6 @@
 5. [数组：209.长度最小的子数组](./problems/0209.长度最小的子数组.md)
 6. [数组：区间和](./problems/kamacoder/0058.区间和.md)
 6. [数组：59.螺旋矩阵II](./problems/0059.螺旋矩阵II.md)
-7. [数组：区间和](./problems/kamacoder/0058.区间和.md)
 8. [数组：开发商购买土地](./problems/kamacoder/0044.开发商购买土地.md)
 9. [数组：总结篇](./problems/数组总结篇.md)
 

problems/0116.填充每个节点的下一个右侧节点指针.md

@@ -169,6 +169,56 @@ class Solution {
 }
 ```
 
+```Java
+// 迭代法
+class Solution {
+    public Node connect(Node root) {
+        if (root == null) {
+            return root;
+        }
+        
+        Queue<Node> queue = new LinkedList<>();
+
+        queue.add(root);
+
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+
+            // 每层的第一个节点
+            Node cur = queue.poll();
+            if (cur.left != null) {
+                queue.add(cur.left);
+            }
+            if (cur.right != null) {
+                queue.add(cur.right);
+            }
+
+            // 因为已经移除了每层的第一个节点，所以将 0 改为 1
+            while (size-- > 1) {
+                Node next = queue.poll();
+
+                if (next.left != null) {
+                    queue.add(next.left);
+                }
+                if (next.right != null) {
+                    queue.add(next.right);
+                }
+
+                // 当前节点指向同层的下一个节点
+                cur.next = next;
+                // 更新当前节点
+                cur = next;
+            }
+
+            // 每层的最后一个节点不指向 null 在力扣也能过
+            cur.next = null;
+        }
+
+        return root;
+    }
+}
+```
+
 ### Python
 
 ```python
@@ -443,3 +493,4 @@ public class Solution
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">
   <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
 </a>
+

problems/0226.翻转二叉树.md

@@ -14,7 +14,7 @@
 
 ![226.翻转二叉树](https://code-thinking-1253855093.file.myqcloud.com/pics/20210203192644329.png)
 
-这道题目背后有一个让程序员心酸的故事，听说 Homebrew的作者Max Howell，就是因为没在白板上写出翻转二叉树，最后被Google拒绝了。（真假不做判断，权当一个乐子哈）
+这道题目背后有一个让程序员心酸的故事，听说 Homebrew的作者Max Howell，就是因为没在白板上写出翻转二叉树，最后被Google拒绝了。（真假不做判断，全当一个乐子哈）
 
 ## 算法公开课
 
@@ -1033,3 +1033,4 @@ public TreeNode InvertTree(TreeNode root) {
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">
   <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
 </a>
+

problems/0232.用栈实现队列.md

@@ -44,7 +44,7 @@ queue.empty(); // 返回 false
 
 这是一道模拟题，不涉及到具体算法，考察的就是对栈和队列的掌握程度。
 
-使用栈来模式队列的行为，如果仅仅用一个栈，是一定不行的，所以需要两个栈**一个输入栈，一个输出栈**，这里要注意输入栈和输出栈的关系。
+使用栈来模拟队列的行为，如果仅仅用一个栈，是一定不行的，所以需要两个栈**一个输入栈，一个输出栈**，这里要注意输入栈和输出栈的关系。
 
 下面动画模拟以下队列的执行过程：
 

problems/0343.整数拆分.md

@@ -309,6 +309,8 @@ class Solution:
 
 ```
 ### Go
+
+动态规划
 ```go
 func integerBreak(n int) int {
     /**
@@ -338,6 +340,28 @@ func max(a, b int) int{
 }
 ```
 
+贪心
+```go
+func integerBreak(n int) int {
+    if n == 2 {
+        return 1
+    }
+    if n == 3 {
+        return 2
+    }
+    if n == 4 {
+        return 4
+    }
+    result := 1
+    for n > 4 {
+        result *= 3
+        n -= 3
+    }
+    result *= n
+    return result
+}
+```
+
 ### Javascript
 ```Javascript
 var integerBreak = function(n) {

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

@@ -453,6 +453,7 @@ class Solution:
 ```
 
 ### Go：
+一维dp
 ```go
 // 分割等和子集 动态规划
 // 时间复杂度O(n^2) 空间复杂度O(n)
@@ -480,6 +481,44 @@ func canPartition(nums []int) bool {
 }
 ```
 
+二维dp
+```go
+func canPartition(nums []int) bool {
+    sum := 0
+    for _, val := range nums {
+        sum += val
+    }
+    if sum % 2 == 1 {
+        return false
+    }
+    target := sum / 2
+    dp := make([][]int, len(nums))
+    for i := range dp {
+        dp[i] = make([]int, target + 1)
+    }
+    for j := nums[0]; j <= target; j++ {
+        dp[0][j] = nums[0]
+    }
+    for i := 1; i < len(nums); i++ {
+        for j := 0; j <= target; j++ {
+            if j < nums[i] {
+                dp[i][j] = dp[i-1][j]
+            } else {
+                dp[i][j] = max(dp[i-1][j], dp[i-1][j-nums[i]] + nums[i])
+            }
+        }  
+    }
+    return dp[len(nums)-1][target] == target
+}
+
+func max(x, y int) int {
+    if x > y {
+        return x
+    }
+    return y
+}
+```
+
 ### JavaScript: 
 
 ```js

problems/0977.有序数组的平方.md

@@ -207,6 +207,7 @@ class Solution:
                 new_list.append(nums[left] ** 2)
                 left += 1
         return new_list[::-1]
+```
 
 ### Go：
 
@@ -539,7 +540,7 @@ public class Solution {
         return result;
     }
 }
-
+```
 C# LINQ：
 ```csharp
 public class Solution {
@@ -553,3 +554,4 @@ public class Solution {
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">
   <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
 </a>
+

problems/kamacoder/0094.城市间货物运输I-SPFA.md

@@ -352,6 +352,77 @@ SPFA（队列优化版Bellman_ford） 在理论上 时间复杂度更胜一筹
 ## 其他语言版本
 
 ### Java 
+```Java
+import java.util.*;
+
+public class Main {
+
+    // Define an inner class Edge
+    static class Edge {
+        int from;
+        int to;
+        int val;
+        public Edge(int from, int to, int val) {
+            this.from = from;
+            this.to = to;
+            this.val = val;
+        }
+    }
+
+    public static void main(String[] args) {
+        // Input processing
+        Scanner sc = new Scanner(System.in);
+        int n = sc.nextInt();
+        int m = sc.nextInt();
+        List<List<Edge>> graph = new ArrayList<>();
+
+        for (int i = 0; i <= n; i++) {
+            graph.add(new ArrayList<>());
+        }
+
+        for (int i = 0; i < m; i++) {
+            int from = sc.nextInt();
+            int to = sc.nextInt();
+            int val = sc.nextInt();
+            graph.get(from).add(new Edge(from, to, val));
+        }
+
+        // Declare the minDist array to record the minimum distance form current node to the original node
+        int[] minDist = new int[n + 1];
+        Arrays.fill(minDist, Integer.MAX_VALUE);
+        minDist[1] = 0;
+
+        // Declare a queue to store the updated nodes instead of traversing all nodes each loop for more efficiency
+        Queue<Integer> queue = new LinkedList<>();
+        queue.offer(1);
+
+        // Declare a boolean array to record if the current node is in the queue to optimise the processing
+        boolean[] isInQueue = new boolean[n + 1];
+
+        while (!queue.isEmpty()) {
+            int curNode = queue.poll();
+            isInQueue[curNode] = false; // Represents the current node is not in the queue after being polled
+            for (Edge edge : graph.get(curNode)) {
+                if (minDist[edge.to] > minDist[edge.from] + edge.val) { // Start relaxing the edge
+                    minDist[edge.to] = minDist[edge.from] + edge.val;
+                    if (!isInQueue[edge.to]) { // Don't add the node if it's already in the queue
+                        queue.offer(edge.to);
+                        isInQueue[edge.to] = true;
+                    }
+                }
+            }
+        }
+        
+        // Outcome printing
+        if (minDist[n] == Integer.MAX_VALUE) {
+            System.out.println("unconnected");
+        } else {
+            System.out.println(minDist[n]);
+        }
+    }
+}
+
+```
 
 ### Python
 

problems/kamacoder/0094.城市间货物运输I.md

@@ -392,6 +392,63 @@ Bellman_ford 是可以计算 负权值的单源最短路算法。
 ## 其他语言版本
 
 ### Java 
+```Java
+public class Main {
+
+    // Define an inner class Edge
+    static class Edge {
+        int from;
+        int to;
+        int val;
+        public Edge(int from, int to, int val) {
+            this.from = from;
+            this.to = to;
+            this.val = val;
+        }
+    }
+
+    public static void main(String[] args) {
+        // Input processing
+        Scanner sc = new Scanner(System.in);
+        int n = sc.nextInt();
+        int m = sc.nextInt();
+        List<Edge> edges = new ArrayList<>();
+
+        for (int i = 0; i < m; i++) {
+            int from = sc.nextInt();
+            int to = sc.nextInt();
+            int val = sc.nextInt();
+            edges.add(new Edge(from, to, val));
+        }
+
+        // Represents the minimum distance from the current node to the original node
+        int[] minDist = new int[n + 1];
+
+        // Initialize the minDist array
+        Arrays.fill(minDist, Integer.MAX_VALUE);
+        minDist[1] = 0;
+
+        // Starts the loop to relax all edges n - 1 times to update minDist array
+        for (int i = 1; i < n; i++) {
+
+            for (Edge edge : edges) {
+                // Updates the minDist array
+                if (minDist[edge.from] != Integer.MAX_VALUE && (minDist[edge.from] + edge.val) < minDist[edge.to]) {
+                    minDist[edge.to] = minDist[edge.from] + edge.val;
+                }
+            }
+        }
+
+        // Outcome printing
+        if (minDist[n] == Integer.MAX_VALUE) {
+            System.out.println("unconnected");
+        } else {
+            System.out.println(minDist[n]);
+        }
+    }
+}
+
+```
 
 ### Python