Merge branch 'youngyangyang04:master' into master

2025-07-09 11:34:46 +08:00 · 2021-06-20 21:44:41 -05:00
parent 9d92c13420 9cbb43930b
commit 605399fc32
8 changed files with 240 additions and 5 deletions
--- a/problems/0037.解数独.md
+++ b/problems/0037.解数独.md
@ -321,6 +321,59 @@ class Solution:
        backtrack(board)
 ```

+Python3:
+
+```python3
+class Solution:
+    def __init__(self) -> None:
+        self.board = []
+
+    def isValid(self, row: int, col: int, target: int) -> bool:
+        for idx in range(len(self.board)):
+            # 同列是否重复
+            if self.board[idx][col] == str(target):
+                return False
+            # 同行是否重复
+            if self.board[row][idx] == str(target):
+                return False
+            # 9宫格里是否重复
+            box_row, box_col = (row // 3) * 3 + idx // 3, (col // 3) * 3 + idx % 3
+            if self.board[box_row][box_col] == str(target):
+                return False
+        return True
+    
+    def getPlace(self) -> List[int]:
+        for row in range(len(self.board)):
+            for col in range(len(self.board)):
+                if self.board[row][col] == ".":
+                    return [row, col]
+        return [-1, -1]
+    
+    def isSolved(self) -> bool:
+        row, col = self.getPlace() # 找个空位置
+        
+        if row == -1 and col == -1: # 没有空位置，棋盘被填满的
+            return True
+        
+        for i in range(1, 10):
+            if self.isValid(row, col, i): # 检查这个空位置放i，是否合适
+                self.board[row][col] = str(i) # 放i
+                if self.isSolved(): # 合适，立刻返回, 填下一个空位置。
+                    return True
+                self.board[row][col] = "." # 不合适，回溯
+        
+        return False # 空位置没法解决
+
+    def solveSudoku(self, board: List[List[str]]) -> None:
+        """
+        Do not return anything, modify board in-place instead.
+        """
+        if board is None or len(board) == 0:
+            return
+        self.board = board
+        self.isSolved()
+```
+
 Go：

 Javascript:
--- a/problems/0093.复原IP地址.md
+++ b/problems/0093.复原IP地址.md
@ -338,6 +338,46 @@ class Solution(object):
        return ans```
 ```

+```python3
+class Solution:
+    def __init__(self) -> None:
+        self.s = ""
+        self.res = []
+
+    def isVaild(self, s: str) -> bool:
+        if len(s) > 1 and s[0] == "0":
+            return False
+
+        if 0 <= int(s) <= 255:
+            return True
+
+        return False
+
+    def backTrack(self, path: List[str], start: int) -> None:
+        if start == len(self.s) and len(path) == 4:
+            self.res.append(".".join(path))
+            return
+
+        for end in range(start + 1, len(self.s) + 1):
+            # 剪枝
+            # 保证切割完，s没有剩余的字符。
+            if len(self.s) - end > 3 * (4 - len(path) - 1):
+                continue
+            if self.isVaild(self.s[start:end]):
+                # 在参数处，更新状态，实则创建一个新的变量
+                # 不会影响当前的状态，当前的path变量没有改变
+                # 因此递归完不用path.pop()
+                self.backTrack(path + [self.s[start:end]], end)
+
+    def restoreIpAddresses(self, s: str) -> List[str]:
+        # prune
+        if len(s) > 3 * 4:
+            return []
+        self.s = s
+        self.backTrack([], 0)
+        return self.res
+```
+
 JavaScript： 

 ```js
--- a/problems/0106.从中序与后序遍历序列构造二叉树.md
+++ b/problems/0106.从中序与后序遍历序列构造二叉树.md
@ -775,6 +775,20 @@ var buildTree = function(inorder, postorder) {
 };
 ```

+从前序与中序遍历序列构造二叉树
+
+```javascript
+var buildTree = function(preorder, inorder) {
+    if(!preorder.length)
+        return null;
+    let root = new TreeNode(preorder[0]);
+    let mid = inorder.findIndex((number) => number === root.val);
+    root.left = buildTree(preorder.slice(1, mid + 1), inorder.slice(0, mid));
+    root.right = buildTree(preorder.slice(mid + 1, preorder.length), inorder.slice(mid + 1, inorder.length));
+    return root;
+};
+```
+
 -----------------------
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
--- a/problems/0151.翻转字符串里的单词.md
+++ b/problems/0151.翻转字符串里的单词.md
@ -318,6 +318,57 @@ class Solution {

 Python：

+```Python3
+class Solution:
+  #1.去除多余的空格
+        def trim_spaces(self,s):     
+            n=len(s)
+            left=0
+            right=n-1
+        
+            while left<=right and s[left]==' ':       #去除开头的空格
+                left+=1
+            while left<=right and s[right]==' ':        #去除结尾的空格
+                right=right-1
+            tmp=[]
+            while left<=right:                                    #去除单词中间多余的空格
+                if s[left]!=' ':
+                    tmp.append(s[left])
+                elif tmp[-1]!=' ':                                  #当前位置是空格，但是相邻的上一个位置不是空格，则该空格是合理的
+                    tmp.append(s[left])
+                left+=1
+            return tmp
+#2.翻转字符数组
+        def reverse_string(self,nums,left,right):
+            while left<right:
+                nums[left], nums[right]=nums[right],nums[left]
+                left+=1
+                right-=1
+            return None
+#3.翻转每个单词
+        def reverse_each_word(self, nums):
+            start=0
+            end=0
+            n=len(nums)
+            while start<n:
+                while end<n and nums[end]!=' ':
+                    end+=1
+                self.reverse_string(nums,start,end-1)
+                start=end+1
+                end+=1
+            return None
+
+#4.翻转字符串里的单词
+        def reverseWords(self, s): #测试用例："the sky is blue"
+            l = self.trim_spaces(s)                     #输出：['t', 'h', 'e', ' ', 's', 'k', 'y', ' ', 'i', 's', ' ', 'b', 'l', 'u', 'e'
+            self.reverse_string( l,  0, len(l) - 1)   #输出：['e', 'u', 'l', 'b', ' ', 's', 'i', ' ', 'y', 'k', 's', ' ', 'e', 'h', 't']
+            self.reverse_each_word(l)               #输出：['b', 'l', 'u', 'e', ' ', 'i', 's', ' ', 's', 'k', 'y', ' ', 't', 'h', 'e']
+            return ''.join(l)                                 #输出：blue is sky the
+
+
+'''
+
+
 Go：

 ```go
--- a/problems/0209.长度最小的子数组.md
+++ b/problems/0209.长度最小的子数组.md
@ -109,7 +109,7 @@ public:
 };
 ```

-时间复杂度：$O(n)$
+时间复杂度：$O(n)$   
 空间复杂度：$O(1)$

 **一些录友会疑惑为什么时间复杂度是O(n)**。
@ -118,8 +118,8 @@ public:

 ## 相关题目推荐

-* 904.水果成篮
-* 76.最小覆盖子串
+* [904.水果成篮](https://leetcode-cn.com/problems/fruit-into-baskets/)
+* [76.最小覆盖子串](https://leetcode-cn.com/problems/minimum-window-substring/)



--- a/problems/0541.反转字符串II.md
+++ b/problems/0541.反转字符串II.md
@ -103,6 +103,7 @@ public:

 Java：
 ```Java
+//解法一
 class Solution {
    public String reverseStr(String s, int k) {
        StringBuffer res = new StringBuffer();
@ -128,6 +129,28 @@ class Solution {
        return res.toString();
    }
 }
+
+//解法二（似乎更容易理解点）
+//题目的意思其实概括为 每隔2k个反转前k个，尾数不够k个时候全部反转
+class Solution {
+    public String reverseStr(String s, int k) {
+        char[] ch = s.toCharArray();
+        for(int i = 0; i < ch.length; i += 2 * k){
+            int start = i;
+            //这里是判断尾数够不够k个来取决end指针的位置
+            int end = Math.min(ch.length - 1, start + k - 1);
+            //用异或运算反转 
+            while(start < end){
+                ch[start] ^= ch[end];
+                ch[end] ^= ch[start];
+                ch[start] ^= ch[end];
+                start++;
+                end--;
+            }
+        }
+        return new String(ch);
+    }
+}
 ```

 Python：
--- a/problems/0654.最大二叉树.md
+++ b/problems/0654.最大二叉树.md
@ -311,6 +311,42 @@ func findMax(nums []int) (index int){
 }
 ```

+JavaScript版本
+
+```javascript
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {number[]} nums
+ * @return {TreeNode}
+ */
+var constructMaximumBinaryTree = function (nums) {
+    const BuildTree = (arr, left, right) => {
+        if (left > right)
+            return null;
+        let maxValue = -1;
+        let maxIndex = -1;
+        for (let i = left; i <= right; ++i) {
+            if (arr[i] > maxValue) {
+                maxValue = arr[i];
+                maxIndex = i;
+            }
+        }
+        let root = new TreeNode(maxValue);
+        root.left = BuildTree(arr, left, maxIndex - 1);
+        root.right = BuildTree(arr, maxIndex + 1, right);
+        return root;
+    }
+    let root = BuildTree(nums, 0, nums.length - 1);
+    return root;
+};
+```



--- a/problems/背包理论基础01背包-2.md
+++ b/problems/背包理论基础01背包-2.md
@ -5,6 +5,7 @@
  <a href="https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ"><img src="https://img.shields.io/badge/知识星球-代码随想录-blue" alt=""></a>
 </p>
 <p align="center"><strong>欢迎大家<a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
+
 # 动态规划：关于01背包问题，你该了解这些！（滚动数组）

 昨天[动态规划：关于01背包问题，你该了解这些！](https://mp.weixin.qq.com/s/FwIiPPmR18_AJO5eiidT6w)中是用二维dp数组来讲解01背包。
@ -35,7 +36,7 @@

 **其实可以发现如果把dp[i - 1]那一层拷贝到dp[i]上，表达式完全可以是：dp[i][j] = max(dp[i][j], dp[i][j - weight[i]] + value[i]);**

-**于其把dp[i - 1]这一层拷贝到dp[i]上，不如只用一个一维数组了**，只用dp[j]（一维数组，也可以理解是一个滚动数组）。
+**与其把dp[i - 1]这一层拷贝到dp[i]上，不如只用一个一维数组了**，只用dp[j]（一维数组，也可以理解是一个滚动数组）。

 这就是滚动数组的由来，需要满足的条件是上一层可以重复利用，直接拷贝到当前层。

@ -214,7 +215,7 @@ int main() {
 Java：

 ```java
-		public static void main(String[] args) {
+    public static void main(String[] args) {
        int[] weight = {1, 3, 4};
        int[] value = {15, 20, 30};
        int bagWight = 4;
@ -242,7 +243,24 @@ Java：


 Python：
+```python
+def test_1_wei_bag_problem():
+    weight = [1, 3, 4]
+    value = [15, 20, 30]
+    bag_weight = 4
+    # 初始化: 全为0
+    dp = [0] * (bag_weight + 1)

+    # 先遍历物品, 再遍历背包容量
+    for i in range(len(weight)):
+        for j in range(bag_weight, weight[i] - 1, -1):
+            # 递归公式
+            dp[j] = max(dp[j], dp[j - weight[i]] + value[i])
+
+    print(dp)
+
+test_1_wei_bag_problem()
+```

 Go：
 ```go