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

problems/0042.接雨水.md

@@ -388,6 +388,44 @@ class Solution:
                 res += res1
         return res
 ```
+动态规划
+```python3
+class Solution:
+    def trap(self, height: List[int]) -> int:
+        leftheight, rightheight = [0]*len(height), [0]*len(height)
+        
+        leftheight[0]=height[0]
+        for i in range(1,len(height)):
+            leftheight[i]=max(leftheight[i-1],height[i])
+        rightheight[-1]=height[-1]
+        for i in range(len(height)-2,-1,-1):
+            rightheight[i]=max(rightheight[i+1],height[i])
+        
+        result = 0
+        for i in range(0,len(height)):
+            summ = min(leftheight[i],rightheight[i])-height[i]
+            result += summ
+        return result
+```
+单调栈
+```python3
+class Solution:
+    def trap(self, height: List[int]) -> int:
+        st =[0]
+        result = 0
+        for i in range(1,len(height)):
+            while st!=[] and height[i]>height[st[-1]]:
+                midh = height[st[-1]]
+                st.pop()
+                if st!=[]:
+                    hright = height[i]
+                    hleft = height[st[-1]]
+                    h = min(hright,hleft)-midh
+                    w = i-st[-1]-1
+                    result+=h*w
+            st.append(i)
+        return result
+```
 
 Go:
 

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

@@ -191,4 +191,57 @@ public:
 
 这里我依然建议大家按部就班把版本一写出来，把情况一二三分析清楚，然后在精简代码到版本二。 直接看版本二容易忽略细节！
 
+## 其他语言版本 
+
+Java: 
+
+Python:
+
+动态规划
+```python3
+class Solution:
+    def largestRectangleArea(self, heights: List[int]) -> int:
+        result = 0
+        minleftindex, minrightindex = [0]*len(heights), [0]*len(heights)
+        
+        minleftindex[0]=-1
+        for i in range(1,len(heights)):
+            t = i-1
+            while t>=0 and heights[t]>=heights[i]: t=minleftindex[t]
+            minleftindex[i]=t
+            
+        minrightindex[-1]=len(heights)
+        for i in range(len(heights)-2,-1,-1):
+            t=i+1
+            while t<len(heights) and heights[t]>=heights[i]: t=minrightindex[t]
+            minrightindex[i]=t
+        
+        for i in range(0,len(heights)):
+            left = minleftindex[i]
+            right = minrightindex[i]
+            summ = (right-left-1)*heights[i]
+            result = max(result,summ)
+        return result
+```
+单调栈 版本二
+```python3
+class Solution:
+    def largestRectangleArea(self, heights: List[int]) -> int:
+        heights.insert(0,0) # 数组头部加入元素0
+        heights.append(0) # 数组尾部加入元素0
+        st = [0]
+        result = 0
+        for i in range(1,len(heights)):
+            while st!=[] and heights[i]<heights[st[-1]]:
+                midh = heights[st[-1]]
+                st.pop()
+                if st!=[]:
+                    minrightindex = i
+                    minleftindex = st[-1]
+                    summ = (minrightindex-minleftindex-1)*midh
+                    result = max(summ,result)
+            st.append(i)
+        return result
+```
+
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码.jpg width=450> </img></div>

problems/0100.相同的树.md

@@ -159,7 +159,7 @@ public:
                 return false;
             }
             que.push(leftNode->left);   // 添加p节点的左子树节点
-            que.push(rightNode->left); // 添加q节点的左子树节点点
+            que.push(rightNode->left); // 添加q节点的左子树节点
             que.push(leftNode->right);  // 添加p节点的右子树节点
             que.push(rightNode->right);  // 添加q节点的右子树节点
         }

problems/0102.二叉树的层序遍历.md

@@ -1205,6 +1205,35 @@ public:
 };
 ```
 
+java代码：
+
+```java
+class Solution {
+    public Node connect(Node root) {
+	Queue<Node> tmpQueue = new LinkedList<Node>();
+	if (root != null) tmpQueue.add(root);
+		
+	while (tmpQueue.size() != 0){
+	    int size = tmpQueue.size();
+            
+            Node cur = tmpQueue.poll();
+            if (cur.left != null) tmpQueue.add(cur.left);
+            if (cur.right != null) tmpQueue.add(cur.right);
+            
+	    for (int index = 1; index < size; index++){
+		Node next = tmpQueue.poll();
+		if (next.left != null) tmpQueue.add(next.left);
+		if (next.right != null) tmpQueue.add(next.right);
+                
+                cur.next = next;
+                cur = next;
+	    }
+	}
+        
+        return root;
+    }
+}
+```
 
 python代码：
 

problems/0383.赎金信.md

@@ -209,6 +209,22 @@ class Solution(object):
         return True
 ```
 
+Python写法四：
+
+```python3
+class Solution:
+    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
+        c1 = collections.Counter(ransomNote)
+        c2 = collections.Counter(magazine)
+        x = c1 - c2
+        #x只保留值大于0的符号，当c1里面的符号个数小于c2时，不会被保留
+        #所以x只保留下了，magazine不能表达的
+        if(len(x)==0):
+            return True
+        else:
+            return False
+```
+
 Go：
 
 ```go

problems/0925.长按键入.md

@@ -9,6 +9,7 @@
 
 # 925.长按键入
 题目链接：https://leetcode-cn.com/problems/long-pressed-name/
+
 你的朋友正在使用键盘输入他的名字 name。偶尔，在键入字符 c 时，按键可能会被长按，而字符可能被输入 1 次或多次。
 
 你将会检查键盘输入的字符 typed。如果它对应的可能是你的朋友的名字（其中一些字符可能被长按），那么就返回 True。
@@ -98,7 +99,36 @@ public:
 # 其他语言版本
 
 Java：
-
+```java
+class Solution {
+    public boolean isLongPressedName(String name, String typed) {
+        int i = 0, j = 0;
+        int m = name.length(), n = typed.length();
+        while (i< m && j < n) {
+            if (name.charAt(i) == typed.charAt(j)) {  // 相同则同时向后匹配
+                i++; j++;
+            }
+            else {
+                if (j == 0) return false; // 如果是第一位就不相同直接返回false
+                // 判断边界为n-1,若为n会越界,例如name:"kikcxmvzi" typed:"kiikcxxmmvvzzz"
+                while (j < n-1 && typed.charAt(j) == typed.charAt(j-1)) j++;
+                if (name.charAt(i) == typed.charAt(j)) {  // j跨越重复项之后再次和name[i]匹配
+                    i++; j++; // 相同则同时向后匹配
+                }
+                else return false;
+            }
+        }
+        // 说明name没有匹配完
+        if (i < m) return false;
+        // 说明type没有匹配完
+        while (j < n) {
+            if (typed.charAt(j) == typed.charAt(j-1)) j++;
+            else return false;
+        }
+        return true;
+    }
+}
+```
 Python：
 ```python
 class Solution:

problems/1002.查找常用字符.md

@@ -169,6 +169,7 @@ class Solution {
     }
 }
 ```
+Python
 ```python
 class Solution:
     def commonChars(self, words: List[str]) -> List[str]:

problems/前序/关于空间复杂度，可能有几个疑问？.md

@@ -30,7 +30,7 @@
 
 2. 空间复杂度是准确算出程序运行时所占用的内存么？
 
-不要以为空间复杂度就已经精准的掌握了程序的内存使用大小，很有多因素会影响程序真正内存使用大小，例如编译器的内存对齐，编程语言容器的底层实现等等这些都会影响到程序内存的开销。
+不要以为空间复杂度就已经精准的掌握了程序的内存使用大小，很多因素会影响程序真正内存使用大小，例如编译器的内存对齐，编程语言容器的底层实现等等这些都会影响到程序内存的开销。
 
 所以空间复杂度是预先大体评估程序内存使用的大小。
 

problems/剑指Offer58-II.左旋转字符串.md

@@ -141,6 +141,18 @@ class Solution:
 # 空间复杂度：O(n)，python的string为不可变，需要开辟同样大小的list空间来修改
 ```
 
+```python 3
+#方法三：考虑不能用切片的情况下，利用模+下标实现
+class Solution:
+    def reverseLeftWords(self, s: str, n: int) -> str:
+        new_s = ''
+        for i in range(len(s)):
+            j = (i+n)%len(s)
+            new_s = new_s + s[j]
+        return new_s
+
+```
+
 Go：
 
 ```go