Update

Author: youngyangyang04

README.md

@@ -373,7 +373,7 @@
 
 ## 图论 
 
-通知：开始更新图论内容，图论部分还没有其他语言版本，欢迎录友们提交PR，成为contributor
+**[图论正式发布](./problems/qita/tulunfabu.md)**
 
 1. [图论：理论基础](./problems/kamacoder/图论理论基础.md)
 2. [图论：深度优先搜索理论基础](./problems/kamacoder/图论深搜理论基础.md)

problems/0018.四数之和.md

@@ -244,56 +244,61 @@ int** fourSum(int* nums, int numsSize, int target, int* returnSize, int** return
 ### Java：
 
 ```Java
-class Solution {
+import java.util.*;
+
+public class Solution {
     public List<List<Integer>> fourSum(int[] nums, int target) {
-        List<List<Integer>> result = new ArrayList<>();
-        Arrays.sort(nums);
-       
-        for (int i = 0; i < nums.length; i++) {
-		
-            // nums[i] > target 直接返回, 剪枝操作
-            if (nums[i] > 0 && nums[i] > target) {
-                return result;
+        Arrays.sort(nums);  // 排序数组
+        List<List<Integer>> result = new ArrayList<>();  // 结果集
+        for (int k = 0; k < nums.length; k++) {
+            // 剪枝处理
+            if (nums[k] > target && nums[k] >= 0) {
+                break;
             }
-		
-            if (i > 0 && nums[i - 1] == nums[i]) {    // 对nums[i]去重
+            // 对nums[k]去重
+            if (k > 0 && nums[k] == nums[k - 1]) {
                 continue;
             }
-            
-            for (int j = i + 1; j < nums.length; j++) {
-
-		// nums[i]+nums[j] > target 直接返回, 剪枝操作
-		            if (nums[i]+nums[j] > 0 && nums[i]+nums[j] > target) {
-		                return result;
-		            }
-
-                if (j > i + 1 && nums[j - 1] == nums[j]) {  // 对nums[j]去重
+            for (int i = k + 1; i < nums.length; i++) {
+                // 第二级剪枝
+                if (nums[k] + nums[i] > target && nums[k] + nums[i] >= 0) {
+                    break;
+                }
+                // 对nums[i]去重
+                if (i > k + 1 && nums[i] == nums[i - 1]) {
                     continue;
                 }
-
-                int left = j + 1;
+                int left = i + 1;
                 int right = nums.length - 1;
                 while (right > left) {
-		    // nums[k] + nums[i] + nums[left] + nums[right] > target int会溢出
-                    long sum = (long) nums[i] + nums[j] + nums[left] + nums[right];
+                    long sum = (long) nums[k] + nums[i] + nums[left] + nums[right];
                     if (sum > target) {
                         right--;
                     } else if (sum < target) {
                         left++;
                     } else {
-                        result.add(Arrays.asList(nums[i], nums[j], nums[left], nums[right]));
+                        result.add(Arrays.asList(nums[k], nums[i], nums[left], nums[right]));
                         // 对nums[left]和nums[right]去重
                         while (right > left && nums[right] == nums[right - 1]) right--;
                         while (right > left && nums[left] == nums[left + 1]) left++;
-
-                        left++;
                         right--;
+                        left++;
                     }
                 }
             }
         }
         return result;
     }
+
+    public static void main(String[] args) {
+        Solution solution = new Solution();
+        int[] nums = {1, 0, -1, 0, -2, 2};
+        int target = 0;
+        List<List<Integer>> results = solution.fourSum(nums, target);
+        for (List<Integer> result : results) {
+            System.out.println(result);
+        }
+    }
 }
 ```
 

problems/0084.柱状图中最大的矩形.md

@@ -188,13 +188,13 @@ public:
 
 开头为什么要加元素0？ 
 
-如果数组本身是降序的，例如 [8,6,4,2]，在 8 入栈后，6 开始与8 进行比较，此时我们得到 mid（8），rigt（6），但是得不到 left。
+如果数组本身是降序的，例如 [8,6,4,2]，在 8 入栈后，6 开始与8 进行比较，此时我们得到 mid（8），right（6），但是得不到 left。
 
 （mid、left，right 都是对应版本一里的逻辑）
 
 因为 将 8 弹出之后，栈里没有元素了，那么为了避免空栈取值，直接跳过了计算结果的逻辑。 
 
-之后又将6 加入栈（此时8已经弹出了），然后 就是 4 与 栈口元素 8 进行比较，周而复始，那么计算的最后结果resutl就是0。 如图所示： 
+之后又将6 加入栈（此时8已经弹出了），然后 就是 4 与 栈口元素 6 进行比较，周而复始，那么计算的最后结果result就是0。 如图所示： 
 
 ![](https://code-thinking-1253855093.file.myqcloud.com/pics/20230221164533.png)
 

problems/0139.单词拆分.md

@@ -243,7 +243,7 @@ public:
 
 使用用例：s = "applepenapple", wordDict = ["apple", "pen"]，对应的dp数组状态如下： 
 
-![](https://code-thinking-1253855093.file.myqcloud.com/pics/20221123205105.png) 
+![](https://code-thinking-1253855093.file.myqcloud.com/pics/20240809155103.png)
 
 最后dp[s.size()] = 0 即 dp[13] = 0 ，而不是1，因为先用 "apple" 去遍历的时候，dp[8]并没有被赋值为1 （还没用"pen"），所以 dp[13]也不能变成1。 
 

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

@@ -131,7 +131,7 @@ public:
     }
 };
 ```
-* 时间复杂度: pop为O(n)，其他为O(1)
+* 时间复杂度: pop为O(n)，top为O(n)，其他为O(1)
 * 空间复杂度: O(n)
 
 ## 优化
@@ -147,17 +147,14 @@ class MyStack {
 public:
     queue<int> que;
 
-    /** Initialize your data structure here. */
     MyStack() {
 
     }
 
-    /** Push element x onto stack. */
     void push(int x) {
         que.push(x);
     }
 
-    /** Removes the element on top of the stack and returns that element. */
     int pop() {
         int size = que.size();
         size--;
@@ -170,9 +167,6 @@ public:
         return result;
     }
 
-    /** Get the top element.
-     ** Can not use back() direactly.
-     */
     int top(){
         int size = que.size();
         size--;
@@ -187,13 +181,12 @@ public:
         return result;
     }
 
-    /** Returns whether the stack is empty. */
     bool empty() {
         return que.empty();
     }
 };
 ```
-* 时间复杂度: pop为O(n)，其他为O(1)
+* 时间复杂度: pop为O(n)，top为O(n)，其他为O(1)
 * 空间复杂度: O(n)