regular leetcode

Author: KrisYu

049._group_anagrams_python.md

@@ -9,7 +9,13 @@
 我又来使用我的取巧神奇python大法 
 
 
-```
+
+思路是： 首先我们把这个单词都变成排序后的str，然后把它做key放入字典中，所以一样的就会放到同样的key下面，最后再把字典的值全部聚集起来。
+
+
+
+
+```python
 class Solution(object):
     def groupAnagrams(self, strs):
         """
@@ -29,7 +35,7 @@ class Solution(object):
         """
         :type s: str
         :type t: str
-        :rtype: bool
+        :rtype: str
         """
         sList = sorted(list(s))
         str1 = ''.join(sList)

062._Unique_Paths.md

@@ -0,0 +1,39 @@
+### 62. Unique Paths
+
+题目:
+
+<https://leetcode.com/problems/unique-paths/description/>
+
+难度:
+
+Medium
+
+
+
+思路：
+
+
+dp 典型， 走到(i, j) 可能的方法是走到 (i-1,j) 加上走到 (i, j-1)之和。
+
+同时针对于第一行和第一列都只能是一种走法。
+
+以上这个都是走向只可能是向右或者向下限制的。
+
+
+```python
+class Solution(object):
+    def uniquePaths(self, m, n):
+        """
+        :type m: int
+        :type n: int
+        :rtype: int
+        """
+        dp = [[1 for _ in range(n)] for _ in range(m)]
+
+        for i in range(1,m):
+            for j in range(1, n):
+                dp[i][j] = dp[i-1][j] + dp[i][j-1]
+
+        return dp[m-1][n-1]
+
+```

229._majority_element_ii.md

@@ -18,7 +18,7 @@ majority element是两两比较扔掉不同的元素，然后最后会留下一
 
 最后再加一个比较来确认这些函数是majority element
 
-```
+```python
 class Solution(object):
     def majorityElement(self, nums):
         """

235._lowest_common_ancestor_of_a_binary_search_tree.md

@@ -13,7 +13,7 @@
 
 AC解法
 
-```
+```python
 class Solution(object):
     def lowestCommonAncestor(self, root, p, q):
         """
@@ -31,3 +31,8 @@ class Solution(object):
         else:
             return self.lowestCommonAncestor(root.right,p,q)
 ```
+
+
+
+同样236的代码也可以解此题：[236](236._lowest_common_ancestor_of_a_binary_tree.md)
+

236._lowest_common_ancestor_of_a_binary_tree.md

@@ -26,8 +26,7 @@ Medium
 
 
 
-```
-
+```python
 class Solution(object):
     def lowestCommonAncestor(self, root, p, q):
         """
@@ -36,30 +35,25 @@ class Solution(object):
         :type q: TreeNode
         :rtype: TreeNode
         """
-        pathP = self.pathTo(root,p)
-        pathQ = self.pathTo(root,q)
+        def path(root, goal):
+            if root == None: return root
+            stack = [(root, [root])]
+            while stack:
+                node, path = stack.pop()
+                if node == goal:
+                    return path
+                if node.left: stack.append((node.left, path + [node.left]))
+                if node.right: stack.append((node.right, path + [node.right]))
+
+        pathP = path(root,p)
+        pathQ = path(root,q)
         n = min(len(pathP), len(pathQ))
 
         ans = root
         for i in range(n):
             if pathP[i] == pathQ[i]:
                 ans = pathP[i]
-            else:
-                break
         return ans
-
-
-    def pathTo(self, root, goal):
-        # goal node ,path
-        if root == None: return root
-        stack = [(root, [root])]
-        while stack:
-            node, path = stack.pop()
-            if node == goal:
-                return path
-            if node.left: stack.append((node.left, path + [node.left]))
-            if node.right: stack.append((node.right, path + [node.right]))
-
 ```
 
 递归解法，之所以我没有用递归因为有疑惑, BASE CASE 很容易想到，root 是none，或者p == root 或者q == root,那么LCA就是root，如果两个node一个在左边，一个在右边，那么LCA也是root，但是如果一个是6，另一个是4则有一点疑惑，但其实是没有问题的，因为这个时候给的总是他们的共同root，所以这个递归解法是没错的，总是想到递归是在那个状况下递归
@@ -79,7 +73,13 @@ AC代码
 
 
 
-```
+前面的思路很容易理解，到了递归的部分：
+
+按照 6 和 4 来看，我们进入left 5，递归进入 left 6, 另外会进入 right 2 最后进入4，但是在这个过程中，我们会看到对于node 5来说，她的left 和right 都不为none，那么return这个node 5.
+
+
+
+```python
 class Solution(object):
     def lowestCommonAncestor(self, root, p, q):
         """
@@ -88,17 +88,24 @@ class Solution(object):
         :type q: TreeNode
         :rtype: TreeNode
         """
-        if root == None:
-            return None
-
-        if p == root or q == root:
+        if root == None or root == p or root == q:
             return root
 
-        left = self.lowestCommonAncestor(self.left,p,q)
-        right = self.lowestCommonAncestor(self.right,p,q)
+        left = self.lowestCommonAncestor(root.left,p,q)
+        right = self.lowestCommonAncestor(root.right,p,q)
 
         if left and right:
             return root
 
-        return left if left is None else right
-```
+        return left if left else right
+```
+
+
+可以看一下SO上的问题：[How to find the lowest common ancestor of two nodes in any binary tree?](https://stackoverflow.com/questions/1484473/how-to-find-the-lowest-common-ancestor-of-two-nodes-in-any-binary-tree)
+
+和一些讨论：
+
+
+
+@David: LCA query answering is pretty useful. LCA + Suffix tree = powerful string related algorithms. – Aryabhatta 
+