python_169

Author: OnlyChristmas

Python/lowest-common-ancestor-of-a-binary-tree.py

@@ -0,0 +1,33 @@
+'''
+
+Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.
+
+According to the definition of LCA on Wikipedia: “The lowest common ancestor is defined between two nodes p and q as the lowest node in T that has both p and q as descendants (where we allow a node to be a descendant of itself).”
+
+Given the following binary tree:  root = [3,5,1,6,2,0,8,null,null,7,4]
+
+
+ 
+
+Example 1:
+Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
+Output: 3
+Explanation: The LCA of nodes 5 and 1 is 3.
+
+
+Example 2:
+Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
+Output: 5
+Explanation: The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition.
+ 
+
+Note:
+
+All of the nodes' values will be unique.
+p and q are different and both values will exist in the binary tree.
+
+
+
+
+
+'''

Python/merge-intervals.py

@@ -0,0 +1,31 @@
+'''
+Given a collection of intervals, merge all overlapping intervals.
+
+Example 1:
+
+Input: [[1,3],[2,6],[8,10],[15,18]]
+Output: [[1,6],[8,10],[15,18]]
+Explanation: Since intervals [1,3] and [2,6] overlaps, merge them into [1,6].
+Example 2:
+
+Input: [[1,4],[4,5]]
+Output: [[1,5]]
+Explanation: Intervals [1,4] and [4,5] are considered overlapping.
+NOTE: input types have been changed on April 15, 2019. Please reset to default code definition to get new method signature.
+
+'''
+
+
+class Solution:
+    def merge(self, intervals: List[List[int]]) -> List[List[int]]:
+        intervals.sort(key=lambda x:(x[0],x[1]))
+        res = []
+        i = 0
+        while i < len(intervals):
+            j = i +1
+            while j < len(intervals) and intervals[i][1] >= intervals[j][0]:
+                intervals[i][1] = max(intervals[i][1], intervals[j][1])
+                j += 1
+            res.append(intervals[i])
+            i = j
+        return res

Python/multiply-strings.py

@@ -24,34 +24,24 @@
 class Solution:
     def multiply(self, num1: str, num2: str) -> str:
 
-        # Approach one  不符合题目要求
-        # return  str(int(num1) * int(num2))
-
-
-
-        # Approach two  采取列竖式乘法的方法， m位数乘以n位数，结果最多为m+n位数。
+        # 考察大数相乘(两个数相乘结果只可能为n1+n2或者n1+n2-1)
         if num1 == "0" or num2 == "0": return "0"
         n1 = len(num1)
         n2 = len(num2)
+        num1 = list(map(int, list(num1)))
+        num2 = list(map(int, list(num2)))
         result = [0 for i in range(n1 + n2)]
 
-        def _sum(value, index):                # 存储每一位相乘的结果
-            tmpIndex = n1 + n2 - 1 - index
-            tmp = result[tmpIndex] + value
-            if tmp > 9:
-                result[tmpIndex] = tmp % 10
-                _sum(tmp // 10, index + 1)
-            else:
-                result[tmpIndex] = tmp
-
-        for i in range(n1):
-            a = int(num1[n1 - 1 - i])
-            for j in range(n2):
-                b = int(num2[n2 - 1 - j])
-                c = a * b
-                _sum(c, i + j)  # 从0开始
+        for i in range(n1-1,-1,-1):
+            for j in range(n2-1,-1,-1):
+                result[i+j+1] += num1[i] * num2[j]
+
+        for i in range(n1+n2-1,0,-1):
+            result[i-1] += result[i] // 10
+            result[i] = result[i] % 10
+
 
         if result[0] == 0:
-            return "".join([str(k) for k in result[1:]])    # 最多只有一位零
+            return "".join([str(k) for k in result[1:]])    # 前面最多只有一位零
         else:
             return "".join([str(k) for k in result])

Python/subsets-ii.py

@@ -0,0 +1,31 @@
+'''
+Given a collection of integers that might contain duplicates, nums, return all possible subsets (the power set).
+
+Note: The solution set must not contain duplicate subsets.
+
+Example:
+
+Input: [1,2,2]
+Output:
+[
+  [2],
+  [1],
+  [1,2,2],
+  [2,2],
+  [1,2],
+  []
+]
+
+
+'''
+
+
+class Solution:
+    def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:
+        res  = [[]]
+        nums.sort()
+        for i in range(len(nums)):
+            if i == 0 or nums[i] != nums[i-1]:
+                l = len(res)
+            res += [ res[j] + [nums[i]]   for j in range(len(res)-l, len(res))]
+        return res

Python/unique-paths.py

@@ -0,0 +1,56 @@
+'''
+A robot is located at the top-left corner of a m x n grid (marked 'Start' in the diagram below).
+
+The robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked 'Finish' in the diagram below).
+
+How many possible unique paths are there?
+
+
+Above is a 7 x 3 grid. How many possible unique paths are there?
+
+Note: m and n will be at most 100.
+
+Example 1:
+Input: m = 3, n = 2
+Output: 3
+Explanation:
+From the top-left corner, there are a total of 3 ways to reach the bottom-right corner:
+1. Right -> Right -> Down
+2. Right -> Down -> Right
+3. Down -> Right -> Right
+
+
+Example 2:
+Input: m = 7, n = 3
+Output: 28
+
+
+
+'''
+
+
+
+
+class Solution:
+    def uniquePaths(self, m: int, n: int) -> int:
+
+
+        # Approach two  节省存储空间
+        dp = [1 for _ in range(m)]
+        for i in range(1,n):
+            for j in range(1,m):
+                dp[j] = dp[j-1] + dp[j]
+        return dp[-1]
+
+
+
+
+        # Approach one
+        # dp = [[0 for _ in range(m)]  for _ in range(n)]
+        # dp[0] = [1 for _ in range(m)]
+        # for i in range(n):
+        #     dp[i][0] = 1
+        # for i in range(1,n):
+        #     for j in range(1,m):
+        #         dp[i][j] = dp[i-1][j] + dp[i][j-1]
+        # return dp[n-1][m-1]

README.md

@@ -567,7 +567,7 @@ Binary Search Manipulation](https://github.com/OnlyChristmas/leetcode#bit-manipu
 ## Sort
 | # | Title | Solution | Time | Space | Difficulty |
 | --- | --- | --- | --- | --- | --- |
-| 056 | [Merge Intervals](https://leetcode.com/problems/merge-intervals/) | [Python](./Python/merge-intervals.py) |  |  | Hard |
+| 056 | [Merge Intervals](https://leetcode.com/problems/merge-intervals/) | [Python](./Python/merge-intervals.py) | O(n) | O(1) | Medium |
 | 057 | [Insert Interval](https://leetcode.com/problems/insert-interval/) | [Python](./Python/insert-interval.py) |  |  | Hard |
 | 075 | [Sort Colors](https://leetcode.com/problems/sort-colors/) | [Python](./Python/sort-colors.py) | O(n) | O(1) | Medium |
 | 088 | [Merge Sorted Array](https://leetcode.com/problems/merge-sorted-array/) | [Python](./Python/merge-sorted-array.py) | O(n) | O(1) | Easy |
@@ -795,9 +795,9 @@ Binary Search Manipulation](https://github.com/OnlyChristmas/leetcode#bit-manipu
 | 051 | [N-Queens](https://leetcode.com/problems/n-queens/) | [Python](./Python/n-queens.py) |  |  | Hard |
 | 052 | [N-Queens-II](https://leetcode.com/problems/n-queens-ii/) | [Python](./Python/n-queens-ii.py) |  |  | Hard |
 | 077 | [Combinations](https://leetcode.com/problems/combinations/) | [Python](./Python/combinations.py) |  |  | Medium |
-| 078 | [Subsets](https://leetcode.com/problems/subsets/) | [Python](./Python/subsets.py) | O(n2) | O(n) | Medium |
+| 078 | [Subsets](https://leetcode.com/problems/subsets/) | [Python](./Python/subsets.py) | O(n2) | O(1) | Medium |
 | 079 | [Word Search](https://leetcode.com/problems/word-search/) | [Python](./Python/word-search.py) |  |  | Medium |
-| 090 | [Subsets II](https://leetcode.com/problems/subsets-ii/) | [Python](./Python/subsets-ii.py) |  |  | Medium |
+| 090 | [Subsets II](https://leetcode.com/problems/subsets-ii/) | [Python](./Python/subsets-ii.py) | O(n^2) | O(1) | Medium |
 | 093 | [Restore IP Addresses](https://leetcode.com/problems/restore-ip-addresses/) | [Python](./Python/restore-ip-addresses.py) |  |  | Medium |
 | 126 | [Word Ladder II](https://leetcode.com/problems/word-ladder-ii/) | [Python](./Python/word-ladder-ii.py) |  |  | Hard |
 | 131 | [Palindrome Partitioning](https://leetcode.com/problems/palindrome-partitioning/) | [Python](./Python/palindrome-partitioning.py) |  |  | Medium |
@@ -824,7 +824,7 @@ Binary Search Manipulation](https://github.com/OnlyChristmas/leetcode#bit-manipu
 | --- | --- | --- | --- | --- | --- |
 | 010 | [Regular Expression Matching](https://leetcode.com/problems/regular-expression-matching/) | [Python](./Python/regular-expression-matching.py) |  |  | Hard |
 | 053 | [Maximum Subarray](https://leetcode.com/problems/maximum-subarray/) | [Python](./Python/maximum-subarray.py) | O(n) | O(1) | Easy |
-| 062 | [Unique Paths](https://leetcode.com/problems/unique-paths/) | [Python](./Python/unique-paths.py) |  |  | Medium |
+| 062 | [Unique Paths](https://leetcode.com/problems/unique-paths/) | [Python](./Python/unique-paths.py) | O(n*m) | O(n) | Medium |
 | 063 | [Unique Paths II](https://leetcode.com/problems/unique-paths-ii/) | [Python](./Python/unique-paths-ii.py) |  |  | Medium |
 | 064 | [Minimum Path Sum](https://leetcode.com/problems/minimum-path-sum/) | [Python](./Python/minimum-path-sum.py) | O(n^2) | O(1) | Medium |
 | 070 | [Climbing Stairs](https://leetcode.com/problems/climbing-stairs/) | [Python](./Python/climbing-stairs.py) | O(n) | O(1) | Easy |