Merge branch 'master' of https://github.com/azl397985856/leetcode

Author: robot

problems/1015.smallest-integer-divisible-by-k.md

@@ -46,9 +46,9 @@ https://leetcode-cn.com/problems/smallest-integer-divisible-by-k/
 
 这道题是说给定一个 K 值，能否找到一个形如 1，11，111，1111 。。。 的数字 n，使得 n % K == 0，并要求 n 尽可能地小。
 
-由于题目要找一个尽可能小的 n ，那么我们可以从小到大进行枚举，知道找到这样的一个 n 值即可。即从 1，11，111，1111 。。。 这样一直除下去，直到碰到可以整除的，我们返回即可。
+由于题目要找一个尽可能小的 n ，那么我们可以从小到大进行枚举，直到找到这样的一个 n 值即可。即从 1，11，111，1111 。。。 这样一直除下去，直到碰到可以整除的，我们返回即可。
 
-但是如果这个数字根本就无法整除怎么办？没错，我们会无限循环下去。我们应该在什么时刻跳出循环返回 - 1 （表示不能整除）呢？
+但是如果这个数字根本就无法整除怎么办？没错，我们会无限循环下去。那么我们应该在什么时刻跳出循环返回 - 1 （表示不能整除）呢？
 
 比如 k = 2 来说我们的算法过程如下：
 
@@ -78,15 +78,7 @@ https://leetcode-cn.com/problems/smallest-integer-divisible-by-k/
 
 ## 代码
 
-```python
-#
-# @lc app=leetcode.cn id=1015 lang=python3
-#
-# [1015] 可被 K 整除的最小整数
-#
-
-# @lc code=start
-
+```py
 
 class Solution:
     def smallestRepunitDivByK(self, K: int) -> int:

problems/437.path-sum-iii.md

@@ -117,8 +117,9 @@ var pathSum = function (root, sum) {
 
 ## 代码
 
-- 语言支持：JS
+- 语言支持：JS, Python
 
+JS code:
 ```js
 /*
  * @lc app=leetcode id=437 lang=javascript
@@ -164,6 +165,39 @@ var pathSum = function (root, sum) {
 };
 ```
 
+Python Code:
+```python
+import collections
+'''
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+'''
+class Solution:
+    def helper(self,root,acc,target,hashmap):
+        if not root:
+            return 0
+        count=0
+        acc+=root.val
+        if acc==target:
+            count+=1
+        if acc-target in hashmap:
+            count+=hashmap[acc-target]
+        hashmap[acc]+=1
+        if root.left:
+            count+=self.helper(root.left,acc,target,hashmap)
+        if root.right:
+            count+=self.helper(root.right,acc,target,hashmap)
+        hashmap[acc]-=1
+        return count
+    
+    def pathSum(self, root: Optional[TreeNode], targetSum: int) -> int:
+        hashmap=collections.defaultdict(lambda:0)
+        return self.helper(root,0,targetSum,hashmap)
+```
+
 **复杂度分析**
 
 - 时间复杂度：$O(N)$

problems/455.AssignCookies.md

@@ -61,8 +61,9 @@ https://leetcode-cn.com/problems/assign-cookies/
 
 ## 代码
 
-语言支持：JS
+语言支持：JS, Python
 
+JS Code:
 ```js
 /**
  * @param {number[]} g
@@ -90,6 +91,21 @@ const findContentChildren = function (g, s) {
 };
 ```
 
+Python Code:
+```python
+class Solution:
+    def findContentChildren(self, g: List[int], s: List[int]) -> int:
+        g.sort()
+        s.sort()
+        count=gIdx=sIdx=0
+        while gIdx<len(g) and sIdx<len(s):
+            if s[sIdx]>=g[gIdx]:
+                gIdx+=1
+                count+=1
+            sIdx+=1
+        return count
+```
+
 ***复杂度分析***
 
 - 时间复杂度：由于使用了排序，因此时间复杂度为 O(NlogN)

problems/84.largest-rectangle-in-histogram.md

@@ -143,7 +143,7 @@ class Solution:
 
 实际上，读完第二种方法的时候，你应该注意到了。我们的核心是求左边第一个比 i 小的和右边第一个比 i 小的。 如果你熟悉单调栈的话，那么应该会想到这是非常适合使用单调栈来处理的场景。
 
-从左到右遍历柱子，对于每一个柱子，我们想找到第一个高度小于它的柱子，那么我们就可以使用一个单调递增栈来实现。 如果柱子大于栈顶的柱子，那么说明不是我们要找的柱子，我们把它塞进去继续遍历，如果比栈顶小，那么我们就找到了第一个小于的柱子。 **对于栈顶元素，其右边第一个小于它的就是当前遍历到的柱子，左边第一个小于它的就是栈中下一个要被弹出的元素**，因此以当前栈顶为最小柱子的面积为**当前栈顶的柱子高度 \* (当前遍历到的柱子索引 - 1 - (栈中下一个要被弹出的元素索引 + 1) + 1)**，化简一下就是 **当前栈顶的柱子高度 \* (当前遍历到的柱子索引 - 栈中下一个要被弹出的元素索引 - 1)**。
+从左到右遍历柱子，对于每一个柱子，我们想找到第一个高度小于它的柱子，那么我们就可以使用一个单调递减栈来实现。 如果柱子大于栈顶的柱子，那么说明不是我们要找的柱子，我们把它塞进去继续遍历，如果比栈顶小，那么我们就找到了第一个小于的柱子。 **对于栈顶元素，其右边第一个小于它的就是当前遍历到的柱子，左边第一个小于它的就是栈中下一个要被弹出的元素**，因此以当前栈顶为最小柱子的面积为**当前栈顶的柱子高度 \* (当前遍历到的柱子索引 - 1 - (栈中下一个要被弹出的元素索引 + 1) + 1)**，化简一下就是 **当前栈顶的柱子高度 \* (当前遍历到的柱子索引 - 栈中下一个要被弹出的元素索引 - 1)**。
 
 这种方法只需要遍历一次，并用一个栈。由于每一个元素最多进栈出栈一次，因此时间和空间复杂度都是$O(N)$。