20190604_150

Author: OnlyChristmas

Python/copy-list-with-random-pointer.py

@@ -34,8 +34,7 @@ class Solution:
     def copyRandomList(self, head: 'Node') -> 'Node':
 
 #         Approach one  深拷贝不是引用，需要新构造一个链表
-#         构造新链表
-#         赋值 random 指针
+#         构造新链表赋值 random 指针
 
 #         pre = pre2 = Node(0, None, None)
 #         orig =  orig1 = head
@@ -61,20 +60,48 @@ def copyRandomList(self, head: 'Node') -> 'Node':
 
         # Approach two   O(n)    O(1)
 
+#         if not head: return None
+#         pre = None
+#         current = head
+
+#         while current:
+#             current.random = Node(current.val, None, current.random)
+#             if pre:
+#                 pre.random.next = current.random
+#             pre = current
+#             current = current.next
+
+#         current = head.random
+#         while current:
+#             if current.random:
+#                 current.random = current.random.random
+#             current = current.next
+#         return head.random
+
+
+
+        # Approach three
         if not head: return None
-        pre = None
-        current = head
-
-        while current:
-            current.random = Node(current.val, None, current.random)
-            if pre:
-                pre.random.next = current.random
-            pre = current
-            current = current.next
-
-        current = head.random
-        while current:
-            if current.random:
-                current.random = current.random.random
-            current = current.next
-        return head.random
+
+        # 将新结点复制出来，插进原链表
+        tmp = head
+        while tmp:
+            node = Node(tmp.val,tmp.next,None)
+            tmp.next, tmp = node , node.next
+
+        # 复制随机指针
+        tmp = head
+        while tmp:
+            if tmp.random:
+                tmp.next.random  = tmp.random.next
+            tmp =  tmp.next.next
+
+        # 拆分两个链表(注意边界条件，插入后的链表一个为偶数，原链表结点为空的时候就可以停止)
+        res = new_head = Node(0, None, None)
+        origin = head
+        while origin:
+            new_head.next =  origin.next
+            new_head = new_head.next
+            origin.next = new_head.next
+            origin = origin.next
+        return res.next

Python/count-primes.py

@@ -9,18 +9,13 @@
 '''
 
 
-
 class Solution:
-    def countPrimes(self, n):
-        """
-        :type n: int
-        :rtype: int
-        """
+    def countPrimes(self, n: int) -> int:
         # 思路一:  简单的遍历除以小于他的数,效率太低了!
         # 思路二:　遍历除以小于他一半的数，有率提升一倍
-        # 思路三:  动态简历素数表,这样居然还不行?!效率还是低
+        # 思路三:  动态建立素数表,这样居然还不行?!效率还是低
         # num = 0
-        # result = [2  ]
+        # result = [2 ]
         # for i in range(2, n):
         #     for j in range(len(result)):
         #         if i % result[j] == 0 and i!=result[j]:
@@ -31,16 +26,13 @@ def countPrimes(self, n):
         # return num
 
         # 思路四: Sieve of Eratosthenes(埃拉托色尼筛法，简称埃氏筛法)，参考维基百科：https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes
-        # fasle 表示不是素数, true 代表素数. 所以总和是多少,最后就有多少个.
-
-
-        # 注意审题边界条件,是小于n,不包括n
-        if n < 2:
-            return 0     # 注意 数组越界的情况
+        # 0 表示不是素数, 1 代表素数. 所以总和是多少,最后就有多少个
+        if n < 3:       # 注意审题边界条件,是小于n,不包括n
+            return 0    # 注意 数组越界的情况
 
-        primes = [True] * n
-        primes[0] = primes[1] = False
-        for i in range(2, int(n**0.5)+1):    # 在选择除数时候的一个小技巧.大于一半的数是不可能做除数的. 事实证明, 能够节省400ms的时间
+        primes = [1] * n
+        primes[0] = primes[1] = 0
+        for i in range(2, int(n**0.5)+1):    # 在选择除数时候的一个小技巧.大于一半的数是不可能做除数的
             if primes[i]:
-                primes[i * i: n: i] = [False] * len(primes[i * i: n: i])  # 非常简洁的语句, 从小到大用埃氏筛法, 将每一个不是素数的数筛选掉.大大减少出发的数量.
+                primes[i * i: n: i] = [0] * ((n - 1) // i - i + 1)  # 用埃氏筛法, 将每一个不是素数的数筛选掉.大大减少除法的数量.
         return sum(primes)

Python/excel-sheet-column-number.py

@@ -0,0 +1,35 @@
+'''
+
+Given a column title as appear in an Excel sheet, return its corresponding column number.
+
+For example:
+
+    A -> 1
+    B -> 2
+    C -> 3
+    ...
+    Z -> 26
+    AA -> 27
+    AB -> 28
+    ...
+Example 1:
+
+Input: "A"
+Output: 1
+Example 2:
+
+Input: "AB"
+Output: 28
+Example 3:
+
+Input: "ZY"
+Output: 701
+
+'''
+
+class Solution:
+    def titleToNumber(self, s: str) -> int:
+        res = 0
+        for i in s:
+            res = res*26 + ord(i) - 64
+        return res

Python/factorial-trailing-zeroes.py

@@ -0,0 +1,29 @@
+'''
+
+Given an integer n, return the number of trailing zeroes in n!.
+
+Example 1:
+
+Input: 3
+Output: 0
+Explanation: 3! = 6, no trailing zero.
+Example 2:
+
+Input: 5
+Output: 1
+Explanation: 5! = 120, one trailing zero.
+Note: Your solution should be in logarithmic time complexity.
+
+
+'''
+
+
+
+class Solution:
+    def trailingZeroes(self, n: int) -> int:
+        # 将原问题简化为寻找有多少个2*5的个数，只有这样才能出现零。因为2必然比5多，只关注5就好。
+        res = 0
+        while n >= 5:
+            n = n // 5
+            res += n
+        return res

Python/house-robber-ii.py

@@ -0,0 +1,31 @@
+'''
+You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed. All houses at this place are arranged in a circle. That means the first house is the neighbor of the last one. Meanwhile, adjacent houses have security system connected and it will automatically contact the police if two adjacent houses were broken into on the same night.
+
+Given a list of non-negative integers representing the amount of money of each house, determine the maximum amount of money you can rob tonight without alerting the police.
+
+Example 1:
+
+Input: [2,3,2]
+Output: 3
+Explanation: You cannot rob house 1 (money = 2) and then rob house 3 (money = 2),
+             because they are adjacent houses.
+Example 2:
+
+Input: [1,2,3,1]
+Output: 4
+Explanation: Rob house 1 (money = 1) and then rob house 3 (money = 3).
+             Total amount you can rob = 1 + 3 = 4.
+
+'''
+
+
+
+class Solution:
+    def rob(self, nums: List[int]) -> int:
+        if not nums: return 0
+        def judge_rob(numbers):
+            pre , cur = 0, 0
+            for i in numbers:
+                pre , cur = cur , max(pre+i , cur)
+            return cur
+        return max(judge_rob(nums[1:]), judge_rob(nums[:-1])) if len(nums) > 1 else nums[0]

Python/house-robber-iii.py

@@ -0,0 +1,49 @@
+'''
+The thief has found himself a new place for his thievery again. There is only one entrance to this area, called the "root." Besides the root, each house has one and only one parent house. After a tour, the smart thief realized that "all houses in this place forms a binary tree". It will automatically contact the police if two directly-linked houses were broken into on the same night.
+
+Determine the maximum amount of money the thief can rob tonight without alerting the police.
+
+Example 1:
+
+Input: [3,2,3,null,3,null,1]
+
+     3
+    / \
+   2   3
+    \   \
+     3   1
+
+Output: 7
+Explanation: Maximum amount of money the thief can rob = 3 + 3 + 1 = 7.
+Example 2:
+
+Input: [3,4,5,1,3,null,1]
+
+     3
+    / \
+   4   5
+  / \   \
+ 1   3   1
+
+Output: 9
+Explanation: Maximum amount of money the thief can rob = 4 + 5 = 9.
+'''
+
+
+
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution:
+    def rob(self, root: TreeNode) -> int:
+        def robHelper(root):
+            if not root:
+                return (0, 0)
+            left, right = robHelper(root.left), robHelper(root.right)
+            return (root.val + left[1] + right[1], max(left) + max(right))
+
+        return max(robHelper(root))

Python/house-robber.py

@@ -0,0 +1,30 @@
+'''
+
+You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed, the only constraint stopping you from robbing each of them is that adjacent houses have security system connected and it will automatically contact the police if two adjacent houses were broken into on the same night.
+
+Given a list of non-negative integers representing the amount of money of each house, determine the maximum amount of money you can rob tonight without alerting the police.
+
+Example 1:
+
+Input: [1,2,3,1]
+Output: 4
+Explanation: Rob house 1 (money = 1) and then rob house 3 (money = 3).
+             Total amount you can rob = 1 + 3 = 4.
+Example 2:
+
+Input: [2,7,9,3,1]
+Output: 12
+Explanation: Rob house 1 (money = 2), rob house 3 (money = 9) and rob house 5 (money = 1).
+             Total amount you can rob = 2 + 9 + 1 = 12.
+
+
+'''
+
+
+
+class Solution:
+    def rob(self, nums: List[int]) -> int:
+        pre , cur = 0,0
+        for i in nums:
+            pre , cur = cur , max(pre + i , cur)
+        return cur

README.md

@@ -278,7 +278,7 @@ Binary Search Manipulation](https://github.com/OnlyChristmas/leetcode#bit-manipu
 | 082 | [Remove Duplicates from Sorted List II](https://leetcode.com/problems/remove-duplicates-from-sorted-list-ii/) | [Python](./Python/remove-duplicates-from-sorted-list-ii.py) | O(n) | O(1) | Medium |
 | 083 | [Remove Duplicates from Sorted List](https://leetcode.com/problems/remove-duplicates-from-sorted-list/) | [Python](./Python/remove-duplicates-from-sorted-list.py) | O(n) | O(1) | Easy |
 | 092 | [Reverse Linked List II](https://leetcode.com/problems/reverse-linked-list-ii/) | [Python](./Python/reverse-linked-list-ii.py) |  |  | Medium |
-| 138 | [Copy List with Random Pointer](https://leetcode.com/problems/copy-list-with-random-pointer/) | [Python](./Python/copy-list-with-random-pointer.py) | O(n) | O(n) | Hard |
+| 138 | [Copy List with Random Pointer](https://leetcode.com/problems/copy-list-with-random-pointer/) | [Python](./Python/copy-list-with-random-pointer.py) | O(n) | O(1) | Medium |
 | 160 | [Intersection of Two Linked Lists](https://leetcode.com/problems/intersection-of-two-linked-lists/) | [Python](./Python/intersection-of-two-linked-lists.py) | O(n) | O(1) | Easy |
 | 203 | [Remove Linked List Elements](https://leetcode.com/problems/remove-linked-list-elements/) | [Python](./Python/remove-linked-list-elements.py) | O(n) | O(1) | Easy |
 | 206 | [Reverse Linked List](https://leetcode.com/problems/reverse-linked-list/) | [Python](./Python/reverse-linked-list.py) | O(n) | O(1) | Easy |
@@ -495,8 +495,8 @@ Binary Search Manipulation](https://github.com/OnlyChristmas/leetcode#bit-manipu
 | 089 | [Gray Code](https://leetcode.com/problems/gray-code/) | [Python](./Python/gray-code.py) |  |  | Medium |
 | 166 | [Fraction to Recurring Decimal](https://leetcode.com/problems/fraction-to-recurring-decimal/) | [Python](./Python/fraction-to-recurring-decimal.py) |  |  | Medium |
 | 168 | [Excel Sheet Column Title](https://leetcode.com/problems/excel-sheet-column-title/) | [Python](./Python/excel-sheet-column-title.py) |  |  | Easy |
-| 171 | [Excel Sheet Column Number](https://leetcode.com/problems/excel-sheet-column-number/) | [Python](./Python/excel-sheet-column-number.py) |  |  | Easy |
-| 172 | [Factorial Trailing Zeroes](https://leetcode.com/problems/factorial-trailing-zeroes/) | [Python](./Python/factorial-trailing-zeroes.py) |  |  | Easy |
+| 171 | [Excel Sheet Column Number](https://leetcode.com/problems/excel-sheet-column-number/) | [Python](./Python/excel-sheet-column-number.py) | O(n) | O(1) | Easy |
+| 172 | [Factorial Trailing Zeroes](https://leetcode.com/problems/factorial-trailing-zeroes/) | [Python](./Python/factorial-trailing-zeroes.py) | O(1) | O(1) | Easy |
 | 202 | [Happy Number](https://leetcode.com/problems/happy-number/) | [Python](./Python/happy-number.py) | O(n) | O(1) | Easy |
 | 204 | [Count Primes](https://leetcode.com/problems/count-primes/) | [Python](./Python/count-primes.py) | O(n) | O(n) | Easy |
 | 223 | [Rectangle Area](https://leetcode.com/problems/rectangle-area/) | [Python](./Python/rectangle-area.py) |  |  | Easy |
@@ -638,7 +638,7 @@ Binary Search Manipulation](https://github.com/OnlyChristmas/leetcode#bit-manipu
 | 298 | [Binary Tree Longest Consecutive Sequence](https://leetcode.com/problems/binary-tree-longest-consecutive-sequence/) | [Python](./Python/binary-tree-longest-consecutive-sequence.py) | O(n) | O(1) | Medium |
 | 327 | [Count of Range Sum](https://leetcode.com/problems/count-of-range-sum/) | [Python](./Python/count-of-range-sum.py) |  |  | Hard |
 | 333 | [Largest BST Subtree](https://leetcode.com/problems/largest-bst-subtree/) | [Python](./Python/largest-bst-subtree.py) |  |  | Medium |
-| 337 | [House Robber III](https://leetcode.com/problems/house-robber-iii/) | [Python](./Python/house-robber-iii.py) |  |  | Medium |
+| 337 | [House Robber III](https://leetcode.com/problems/house-robber-iii/) | [Python](./Python/house-robber-iii.py) | O(logn) | O(1) | Medium |
 | 395 | [Longest Substring with At Least K Repeating Characters](https://leetcode.com/problems/longest-substring-with-at-least-k-repeating-characters/) | [Python](./Python/longest-substring-with-at-least-k-repeating-characters.py) |  |  | Medium |
 | 404 | [Sum of Left Leaves](https://leetcode.com/problems/sum-of-left-leaves/) | [Python](./Python/sum-of-left-leaves.py) |  |  | Easy |
 | 437 | [Path Sum III](https://leetcode.com/problems/path-sum-iii/) | [Python](./Python/path-sum-iii.py) |  |  | Easy |
@@ -842,8 +842,8 @@ Binary Search Manipulation](https://github.com/OnlyChristmas/leetcode#bit-manipu
 | 152 | [Maximum Product Subarray](https://leetcode.com/problems/maximum-product-subarray/) | [Python](./Python/maximum-product-subarray.py) |  |  | Medium |
 | 174 | [Dungeon Game](https://leetcode.com/problems/dungeon-game/) | [Python](./Python/dungeon-game.py) |  |  | Hard |
 | 188 | [Best Time to Buy and Sell Stock IV](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iv/) | [Python](./Python/best-time-to-buy-and-sell-stock-iv.py) |  |  | Hard |
-| 198 | [House Robber](https://leetcode.com/problems/house-robber/) | [Python](./Python/house-robber.py) |  |  | Easy |
-| 213 | [House Robber II](https://leetcode.com/problems/house-robber-ii/) | [Python](./Python/house-robber-ii.py) |  |  | Medium |
+| 198 | [House Robber](https://leetcode.com/problems/house-robber/) | [Python](./Python/house-robber.py) | O(n) | O(1) | Easy |
+| 213 | [House Robber II](https://leetcode.com/problems/house-robber-ii/) | [Python](./Python/house-robber-ii.py) | O(n) | O(1) | Medium |
 | 221 | [Maximal Square](https://leetcode.com/problems/maximal-square/) | [Python](./Python/maximal-square.py) |  |  | Medium |
 | 256 | [Paint House](https://leetcode.com/problems/paint-house/) | [Python](./Python/paint-house.py) |  |  | Medium |
 | 265 | [Paint House II](https://leetcode.com/problems/paint-house-ii/) | [Python](./Python/paint-house-ii.py) |  |  | Hard |