Merge branch 'master' of github.com:youngyangyang04/leetcode-master

.gitignore

@@ -0,0 +1,7 @@
+.idea/
+.DS_Store
+.vscode
+.temp
+.cache
+*.iml
+__pycache__

README.md

@@ -399,7 +399,7 @@
 24. [图论：Bellman_ford 算法](./problems/kamacoder/0094.城市间货物运输I.md)
 25. [图论：Bellman_ford 队列优化算法（又名SPFA）](./problems/kamacoder/0094.城市间货物运输I-SPFA.md)
 26. [图论：Bellman_ford之判断负权回路](./problems/kamacoder/0095.城市间货物运输II.md)
-27. [图论：Bellman_ford之单源有限最短路](./problems/kamacoder/0095.城市间货物运输II.md)
+27. [图论：Bellman_ford之单源有限最短路](./problems/kamacoder/0096.城市间货物运输III.md)
 28. [图论：Floyd 算法](./problems/kamacoder/0097.小明逛公园.md)
 29. [图论：A * 算法](./problems/kamacoder/0126.骑士的攻击astar.md)
 30. [图论：最短路算法总结篇](./problems/kamacoder/最短路问题总结篇.md)

problems/0005.最长回文子串.md

@@ -256,7 +256,60 @@ public:
 * 时间复杂度：O(n^2)
 * 空间复杂度：O(1)
 
+### Manacher 算法
 
+Manacher 算法的关键在于高效利用回文的对称性，通过插入分隔符和维护中心、边界等信息，在线性时间内找到最长回文子串。这种方法避免了重复计算，是处理回文问题的最优解。
+
+```c++
+//Manacher 算法
+class Solution {
+public:
+    string longestPalindrome(string s) {
+        // 预处理字符串，在每个字符之间插入 '#'
+        string t = "#";
+        for (char c : s) {
+            t += c; // 添加字符
+            t += '#';// 添加分隔符
+        }
+        int n = t.size();// 新字符串的长度
+        vector<int> p(n, 0);// p[i] 表示以 t[i] 为中心的回文半径
+        int center = 0, right = 0;// 当前回文的中心和右边界
+
+
+        // 遍历预处理后的字符串
+        for (int i = 0; i < n; i++) {
+             // 如果当前索引在右边界内，利用对称性初始化 p[i]
+            if (i < right) {
+                p[i] = min(right - i, p[2 * center - i]);
+            }
+             // 尝试扩展回文
+            while (i - p[i] - 1 >= 0 && i + p[i] + 1 < n && t[i - p[i] - 1] == t[i + p[i] + 1]) {
+                p[i]++;// 增加回文半径
+            }
+            // 如果当前回文扩展超出右边界，更新中心和右边界
+            if (i + p[i] > right) {
+                center = i;// 更新中心
+                right = i + p[i];// 更新右边界
+            }
+        }
+       // 找到最大回文半径和对应的中心
+        int maxLen = 0, centerIndex = 0;
+        for (int i = 0; i < n; i++) {
+            if (p[i] > maxLen) {
+                maxLen = p[i];// 更新最大回文长度
+                centerIndex = i;// 更新中心索引
+            }
+        }
+        // 计算原字符串中回文子串的起始位置并返回
+        return s.substr((centerIndex - maxLen) / 2, maxLen);
+    }
+};
+```
+
+
+
+* 时间复杂度：O(n)
+* 空间复杂度：O(n)
 
 ## 其他语言版本
 
@@ -682,3 +735,4 @@ public class Solution {
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">
   <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
 </a>
+

problems/0046.全排列.md

@@ -201,6 +201,7 @@ class Solution {
     public void backtrack(int[] nums, LinkedList<Integer> path) {
         if (path.size() == nums.length) {
             result.add(new ArrayList<>(path));
+            return;
         }
         for (int i =0; i < nums.length; i++) {
             // 如果path中已有，则跳过
@@ -524,3 +525,4 @@ public class Solution
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">
   <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
 </a>
+

problems/0053.最大子序和.md

@@ -240,6 +240,42 @@ class Solution:
             res = max(res, dp[i])
         return res
 ```
+
+动态规划
+
+```python
+class Solution:
+    def maxSubArray(self, nums):
+        if not nums:
+            return 0
+        dp = [0] * len(nums)    # dp[i]表示包括i之前的最大连续子序列和
+        dp[0] = nums[0]
+        result = dp[0]
+        for i in range(1, len(nums)):
+            dp[i] = max(dp[i-1]+nums[i], nums[i])   # 状态转移公式
+            if dp[i] > result:
+                result = dp[i]                      # result 保存dp[i]的最大值
+        return result
+```
+
+动态规划优化
+
+```python
+class Solution:
+    def maxSubArray(self, nums: List[int]) -> int:
+        max_sum = float("-inf") # 初始化结果为负无穷大，方便比较取最大值
+        current_sum = 0         # 初始化当前连续和
+
+        for num in nums:
+
+            # 更新当前连续和
+            # 如果原本的连续和加上当前数字之后没有当前数字大，说明原本的连续和是负数，那么就直接从当前数字开始重新计算连续和
+            current_sum = max(current_sum+num, num) 
+            max_sum = max(max_sum, current_sum) # 更新结果
+
+        return max_sum
+```
+
 ### Go
 贪心法
 ```go

problems/0055.跳跃游戏.md

@@ -143,6 +143,23 @@ class Solution:
         return False
 ```
 
+```python
+## 基于当前最远可到达位置判断
+class Solution:
+    def canJump(self, nums: List[int]) -> bool:
+        far = nums[0]
+        for i in range(len(nums)):
+            # 要考虑两个情况
+            # 1. i <= far - 表示 当前位置i 可以到达
+            # 2. i > far - 表示 当前位置i 无法到达
+            if i > far:
+                return False
+            far = max(far, nums[i]+i)
+        # 如果循环正常结束，表示最后一个位置也可以到达，否则会在中途直接退出
+        # 关键点在于，要想明白其实列表中的每个位置都是需要验证能否到达的
+        return True
+```
+
 ### Go
 
 ```go

problems/0112.路径总和.md

@@ -564,10 +564,10 @@ class Solution:
 
         return False
 
-    def hasPathSum(self, root: TreeNode, sum: int) -> bool:
+    def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
         if root is None:
             return False
-        return self.traversal(root, sum - root.val)      
+        return self.traversal(root, targetSum - root.val)      
 ```
 
 (版本二) 递归 + 精简
@@ -579,12 +579,12 @@ class Solution:
 #         self.left = left
 #         self.right = right
 class Solution:
-    def hasPathSum(self, root: TreeNode, sum: int) -> bool:
+    def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
         if not root:
             return False
-        if not root.left and not root.right and sum == root.val:
+        if not root.left and not root.right and targetSum == root.val:
             return True
-        return self.hasPathSum(root.left, sum - root.val) or self.hasPathSum(root.right, sum - root.val)
+        return self.hasPathSum(root.left, targetSum - root.val) or self.hasPathSum(root.right, targetSum - root.val)
 
 ```
 (版本三) 迭代
@@ -596,7 +596,7 @@ class Solution:
 #         self.left = left
 #         self.right = right
 class Solution:
-    def hasPathSum(self, root: TreeNode, sum: int) -> bool:
+    def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
         if not root:
             return False
         # 此时栈里要放的是pair<节点指针，路径数值>
@@ -659,13 +659,13 @@ class Solution:
 
         return
 
-    def pathSum(self, root: TreeNode, sum: int) -> List[List[int]]:
+    def pathSum(self, root: Optional[TreeNode], targetSum: int) -> List[List[int]]:
         self.result.clear()
         self.path.clear()
         if not root:
             return self.result
         self.path.append(root.val) # 把根节点放进路径
-        self.traversal(root, sum - root.val)
+        self.traversal(root, targetSum - root.val)
         return self.result 
 ```
 
@@ -678,7 +678,7 @@ class Solution:
 #         self.left = left
 #         self.right = right
 class Solution:
-    def pathSum(self, root: TreeNode, targetSum: int) -> List[List[int]]:
+    def pathSum(self, root: Optional[TreeNode], targetSum: int) -> List[List[int]]:
 
         result = []
         self.traversal(root, targetSum, [], result)
@@ -703,7 +703,7 @@ class Solution:
 #         self.left = left
 #         self.right = right
 class Solution:
-    def pathSum(self, root: TreeNode, targetSum: int) -> List[List[int]]:
+    def pathSum(self, root: Optional[TreeNode], targetSum: int) -> List[List[int]]:
         if not root:
             return []
         stack = [(root, [root.val])]

problems/0122.买卖股票的最佳时机II（动态规划）.md

@@ -251,6 +251,27 @@ func max(a, b int) int {
 }
 ```
 
+```go
+// 动态规划 版本二 滚动数组
+func maxProfit(prices []int) int {
+    dp := [2][2]int{} // 注意这里只开辟了一个2 * 2大小的二维数组
+    dp[0][0] = -prices[0]
+    dp[0][1] = 0
+    for i := 1; i < len(prices); i++ {
+        dp[i%2][0] = max(dp[(i-1)%2][0], dp[(i - 1) % 2][1] - prices[i])
+        dp[i%2][1] = max(dp[(i-1)%2][1], dp[(i-1)%2][0] + prices[i])
+    }
+    return dp[(len(prices)-1)%2][1]
+}
+
+func max(x, y int) int {
+    if x > y {
+        return x
+    }
+    return y
+}
+```
+
 ### JavaScript：
 
 ```javascript

problems/0123.买卖股票的最佳时机III.md

@@ -317,6 +317,7 @@ class Solution:
 ### Go:
 
 ```go
+// 版本一
 func maxProfit(prices []int) int {
     dp := make([][]int, len(prices))
     for i := 0; i < len(prices); i++ {
@@ -344,6 +345,58 @@ func max(a, b int) int {
 }
 ```
 
+```go
+// 版本二
+func maxProfit(prices []int) int {
+    if len(prices) == 0 {
+        return 0
+    }
+    dp := make([]int, 5)
+    dp[1] = -prices[0]
+    dp[3] = -prices[0]
+    for i := 1; i < len(prices); i++ {
+        dp[1] = max(dp[1], dp[0] - prices[i])
+        dp[2] = max(dp[2], dp[1] + prices[i])
+        dp[3] = max(dp[3], dp[2] - prices[i])
+        dp[4] = max(dp[4], dp[3] + prices[i])
+    }
+    return dp[4]
+}
+
+func max(x, y int) int {
+    if x > y {
+        return x
+    }
+    return y
+}
+```
+
+```go
+// 版本三
+func maxProfit(prices []int) int {
+    if len(prices) == 0 {
+        return 0
+    }
+    dp := make([][5]int, len(prices))
+    dp[0][1] = -prices[0]
+    dp[0][3] = -prices[0]
+    for i := 1; i < len(prices); i++ {
+        dp[i][1] = max(dp[i-1][1], 0 - prices[i])
+        dp[i][2] = max(dp[i-1][2], dp[i-1][1] + prices[i])
+        dp[i][3] = max(dp[i-1][3], dp[i-1][2] - prices[i])
+        dp[i][4] = max(dp[i-1][4], dp[i-1][3] + prices[i])
+    }
+    return dp[len(prices)-1][4]
+}
+
+func max(x, y int) int {
+    if x > y {
+        return x
+    }
+    return y
+}
+```
+
 ### JavaScript:
 
 > 版本一：

problems/0135.分发糖果.md

@@ -177,21 +177,20 @@ class Solution {
 ```python
 class Solution:
     def candy(self, ratings: List[int]) -> int:
-        candyVec = [1] * len(ratings)
+        n = len(ratings)
+        candies = [1] * n
 
-        # 从前向后遍历，处理右侧比左侧评分高的情况
-        for i in range(1, len(ratings)):
+        # Forward pass: handle cases where right rating is higher than left
+        for i in range(1, n):
             if ratings[i] > ratings[i - 1]:
-                candyVec[i] = candyVec[i - 1] + 1
+                candies[i] = candies[i - 1] + 1
 
-        # 从后向前遍历，处理左侧比右侧评分高的情况
-        for i in range(len(ratings) - 2, -1, -1):
+        # Backward pass: handle cases where left rating is higher than right
+        for i in range(n - 2, -1, -1):
             if ratings[i] > ratings[i + 1]:
-                candyVec[i] = max(candyVec[i], candyVec[i + 1] + 1)
+                candies[i] = max(candies[i], candies[i + 1] + 1)
 
-        # 统计结果
-        result = sum(candyVec)
-        return result
+        return sum(candies)
 
 ```
 

problems/0150.逆波兰表达式求值.md

@@ -108,7 +108,7 @@ public:
             }
         }
 
-        int result = st.top();
+        long long result = st.top();
         st.pop(); // 把栈里最后一个元素弹出（其实不弹出也没事）
         return result;
     }

problems/0151.翻转字符串里的单词.md

@@ -440,11 +440,10 @@ class Solution {
 ```Python
 class Solution:
     def reverseWords(self, s: str) -> str:
-        # 删除前后空白
-        s = s.strip()
         # 反转整个字符串
         s = s[::-1]
         # 将字符串拆分为单词，并反转每个单词
+        # split()函数能够自动忽略多余的空白字符
         s = ' '.join(word[::-1] for word in s.split())
         return s
 
@@ -1029,3 +1028,4 @@ public string ReverseWords(string s) {
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">
   <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
 </a>
+