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

Author: flames519

README.md

@@ -17,6 +17,11 @@
   <a href="https://space.bilibili.com/525438321"><img src="https://img.shields.io/badge/B站-代码随想录-orange" alt=""></a>
   <a href="https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ"><img src="https://img.shields.io/badge/知识星球-代码随想录-blue" alt=""></a>
 </p>
+<p align="center">
+<a href="https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ" target="_blank">
+	<img src="./pics/知识星球.png" width="600"/>
+</a>
+
 
 # LeetCode 刷题攻略
 
@@ -120,6 +125,10 @@
 4. [马上秋招了，慌得很！](https://mp.weixin.qq.com/s/7q7W8Cb2-a5U5atZdOnOFA)
 5. [Carl看了上百份简历，总结了这些！](https://mp.weixin.qq.com/s/sJa87MZD28piCOVMFkIbwQ)
 6. [面试中遇到了发散性问题.....](https://mp.weixin.qq.com/s/SSonDxi2pjkSVwHNzZswng)
+7. [英语到底重不重要！](https://mp.weixin.qq.com/s/1PRZiyF_-TVA-ipwDNjdKw)
+8. [计算机专业要不要读研！](https://mp.weixin.qq.com/s/c9v1L3IjqiXtkNH7sOMAdg)
+9. [秋招和提前批都越来越提前了....](https://mp.weixin.qq.com/s/SNFiRDx8CKyjhTPlys6ywQ)
+
 
 ## 数组 
 
@@ -379,9 +388,12 @@
 54. [动态规划：最长回文子序列](./problems/0516.最长回文子序列.md)
 55. [动态规划总结篇](./problems/动态规划总结篇.md)
 
-
 （持续更新中....）
 
+## 单调栈 
+
+1. [每日温度](./problems/0739.每日温度.md)
+
 ## 图论 
 
 ## 十大排序

problems/0001.两数之和.md

@@ -107,7 +107,7 @@ public int[] twoSum(int[] nums, int target) {
 
 Python：
 
-```python3
+```python
 class Solution:
     def twoSum(self, nums: List[int], target: int) -> List[int]:
         hashmap={}

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:

problems/0051.N皇后.md

@@ -353,14 +353,6 @@ class Solution {
 }
 ```
 
-## 其他语言版本
-
-
-Java：
-
-
-Python：
-
 
 Go：
 ```Go

problems/0053.最大子序和（动态规划）.md

@@ -95,10 +95,47 @@ public:
 
 
 Java：
+```java
+   /**
+     * 1.dp[i]代表当前下标对应的最大值
+     * 2.递推公式 dp[i] = max (dp[i-1]+nums[i],nums[i]) res = max(res,dp[i])
+     * 3.初始化 都为 0
+     * 4.遍历方向，从前往后
+     * 5.举例推导结果。。。
+     *
+     * @param nums
+     * @return
+     */
+    public static int maxSubArray(int[] nums) {
+        if (nums.length == 0) {
+            return 0;
+        }
 
+        int res = nums[0];
+        int[] dp = new int[nums.length];
+        dp[0] = nums[0];
+        for (int i = 1; i < nums.length; i++) {
+            dp[i] = Math.max(dp[i - 1] + nums[i], nums[i]);
+            res = res > dp[i] ? res : dp[i];
+        }
+        return res;
+    }
+```
 
 Python：
-
+```python
+class Solution:
+    def maxSubArray(self, nums: List[int]) -> int:
+        if len(nums) == 0:
+            return 0
+        dp = [0] * len(nums)
+        dp[0] = nums[0]
+        result = dp[0]
+        for i in range(1, len(nums)):
+            dp[i] = max(dp[i-1] + nums[i], nums[i]) #状态转移公式
+            result = max(result, dp[i]) #result 保存dp[i]的最大值
+        return result
+```
 
 Go：
 

problems/0062.不同路径.md

@@ -308,6 +308,27 @@ func uniquePaths(m int, n int) int {
 }
 ```
 
+Javascript：
+```Javascript
+var uniquePaths = function(m, n) {
+    const dp = Array(m).fill().map(item => Array(n))
+    
+    for (let i = 0; i < m; ++i) {
+        dp[i][0] = 1
+    }
+    
+    for (let i = 0; i < n; ++i) {
+        dp[0][i] = 1
+    }
+    
+    for (let i = 1; i < m; ++i) {
+        for (let j = 1; j < n; ++j) {
+            dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
+        }
+    }
+    return dp[m - 1][n - 1]
+};
+```
 
 
 -----------------------

problems/0063.不同路径II.md

@@ -279,6 +279,30 @@ func uniquePathsWithObstacles(obstacleGrid [][]int) int {
 
 ```
 
+Javascript
+``` Javascript
+var uniquePathsWithObstacles = function(obstacleGrid) {
+    const m = obstacleGrid.length
+    const n = obstacleGrid[0].length
+    const dp = Array(m).fill().map(item => Array(n).fill(0))
+    
+    for (let i = 0; i < m && obstacleGrid[i][0] === 0; ++i) {
+        dp[i][0] = 1
+    }
+    
+    for (let i = 0; i < n && obstacleGrid[0][i] === 0; ++i) {
+        dp[0][i] = 1
+    }
+    
+    for (let i = 1; i < m; ++i) {
+        for (let j = 1; j < n; ++j) {
+            dp[i][j] = obstacleGrid[i][j] === 1 ? 0 : dp[i - 1][j] + dp[i][j - 1]
+        }
+    }
+        
+    return dp[m - 1][n - 1]
+};
+```
 
 
 -----------------------

problems/0070.爬楼梯完全背包版本.md

@@ -148,8 +148,43 @@ class Solution {
 Python：
 
 
-Go：
+```python3
+class Solution:
+    def climbStairs(self, n: int) -> int:
+        dp = [0]*(n + 1)
+        dp[0] = 1
+        m = 2
+        # 遍历背包
+        for j in range(n + 1):
+            # 遍历物品
+            for step in range(1, m + 1):
+                if j >= step:
+                    dp[j] += dp[j - step]
+        return dp[n]
+```
+
 
+Go：
+```go
+func climbStairs(n int) int {
+	//定义
+	dp := make([]int, n+1)
+	//初始化
+	dp[0] = 1
+	// 本题物品只有两个1,2
+	m := 2
+	// 遍历顺序
+	for j := 1; j <= n; j++ {	//先遍历背包
+		for i := 1; i <= m; i++ {	//再遍历物品
+			if j >= i {
+				dp[j] += dp[j-i]
+			}
+			//fmt.Println(dp)
+		}
+	}
+	return dp[n]
+}
+```