52-zjzjgxw-小歪

1st/homework_1/id_52/addTwoSum_52.py

@@ -0,0 +1,21 @@
+class Solution:
+    def twoSum(self, nums, target):
+        """
+        :type nums: List[int]
+        :type target: int
+        :rtype: List[int]
+        """
+        if len(nums) <= 0:
+            return None
+        dic = {}
+        for i in range(len(nums)):
+            if nums[i] in dic:
+                return [dic[nums[i]], i]
+            else:
+                dic[target-nums[i]] = i
+
+sol = Solution()
+nums = [1, 3, 5, 6]
+target = 4
+res = sol.twoSum(nums, target)
+print(res)

1st/homework_2/id_52/3Sum_52.py

@@ -0,0 +1,30 @@
+class Solution(object):
+    def threeSum(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: List[List[int]]
+        """
+        if len(nums) < 3:
+            return []
+        nums.sort()
+        res = []
+        for i in range(len(nums)-2):
+            if i > 0 and nums[i] == nums[i-1]:
+                continue
+            l = i + 1
+            r = len(nums) - 1
+            while l < r:
+                s = nums[i] + nums[l] + nums[r]
+                if s < 0:
+                    l += 1
+                elif s > 0:
+                    r -= 1
+                else:
+                    res.append([nums[i], nums[l], nums[r]])
+                    while l < r and nums[l] == nums[l+1]:
+                        l += 1
+                    while l < r and nums[r] == nums[r-1]:
+                        r -= 1
+                    l += 1
+                    r -= 1
+        return res

1st/homework_3/id_52/4Sum_52.py

@@ -0,0 +1,25 @@
+def fourSum(self, nums, target):
+    def findNsum(nums, target, N, result, results):
+        if len(nums) < N or N < 2 or target < nums[0]*N or target > nums[-1]*N:  # early termination
+            return
+        if N == 2: # two pointers solve sorted 2-sum problem
+            l,r = 0,len(nums)-1
+            while l < r:
+                s = nums[l] + nums[r]
+                if s == target:
+                    results.append(result + [nums[l], nums[r]])
+                    l += 1
+                    while l < r and nums[l] == nums[l-1]:
+                        l += 1
+                elif s < target:
+                    l += 1
+                else:
+                    r -= 1
+        else: # recursively reduce N
+            for i in range(len(nums)-N+1):
+                if i == 0 or (i > 0 and nums[i-1] != nums[i]):
+                    findNsum(nums[i+1:], target-nums[i], N-1, result+[nums[i]], results)
+
+    results = []
+    findNsum(sorted(nums), target, 4, [], results)
+    return results

1st/homework_4/id_52/sortColors_52.py

@@ -0,0 +1,19 @@
+class Solution(object):
+    def sortColors(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: void Do not return anything, modify nums in-place instead.
+        """
+        if len(nums) == 0:
+            return
+        low, mid, high = 0, 0, len(nums)-1
+        while mid <= high:
+            if nums[mid] == 0:
+                nums[mid], nums[low] = nums[low], nums[mid]
+                low += 1
+                mid += 1
+            elif nums[mid] == 1:
+                mid += 1
+            elif nums[mid] == 2:
+                nums[mid], nums[high] = nums[high], nums[mid]
+                high -= 1

1st/homework_5/id_52/maxSubArray_52.py

@@ -0,0 +1,13 @@
+class Solution(object):
+    def maxSubArray(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+        if len(nums) == 0:
+            return 0
+        curSum, maxSum = nums[0], nums[0]
+        for num in nums[1:]:
+            curSum = max(num, curSum+num)
+            maxSum = max(maxSum, curSum)
+        return maxSum

1st/homework_6/id_52/removeDuplicatesII_52.py

@@ -0,0 +1,23 @@
+class Solution(object):
+    def removeDuplicates(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+        if len(nums) <= 2:
+            return len(nums)
+        top = 0
+        times = 1
+        for i in range(1, len(nums)):
+            if nums[i] == nums[top]:
+                times += 1
+                if times <= 2:
+                    top += 1
+                    nums[top] = nums[i]
+                else:
+                    times += 1
+            else:
+                times = 1
+                top += 1
+                nums[top] = nums[i]
+        return top+1

1st/homework_7/id_52/longestConsecutive_52.py

@@ -0,0 +1,25 @@
+class Solution(object):
+    def longestConsecutive(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+        if not nums:
+            return 0
+        buff_dict = {}
+        res = 0
+        for i in nums:
+            if i in buff_dict:
+                continue
+            else:
+                left, right = 0, 0
+                if i-1 in buff_dict:
+                    left = buff_dict[i-1]
+                if i+1 in buff_dict:
+                    right = buff_dict[i+1]
+                longest = left + right + 1
+                buff_dict[i] = longest
+                buff_dict[i-left] = longest
+                buff_dict[i+right] = longest
+                res = max(res, longest)
+        return res

1st/homework_8/id_52/rotateImg_52.py

@@ -0,0 +1,11 @@
+class Solution(object):
+    def rotate(self, matrix):
+        """
+        :type matrix: List[List[int]]
+        :rtype: void Do not return anything, modify matrix in-place instead.
+        """
+        for i in range(len(matrix)):
+            for j in range(0, i):
+                matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]
+        for i in range(len(matrix)):
+            matrix[i].reverse()

1st/homework_9/id_52/countNumbersWithUniqueDigits_52.py

@@ -0,0 +1,19 @@
+class Solution(object):
+    def countNumbersWithUniqueDigits(self, n):
+        """
+        :type n: int
+        :rtype: int
+        """
+        if n == 0:
+            return 1
+        if n == 1:
+            return 10
+        total = 10
+        pre = 9
+        availableNumber = 9
+        while n > 1:
+            pre *= availableNumber
+            availableNumber -= 1
+            n -= 1
+            total += pre
+        return total

2nd/homework_1/id_52/minDepth_52.py

@@ -0,0 +1,22 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def minDepth(self, root):
+        """
+        :type root: TreeNode
+        :rtype: int
+        """
+        if root is None:
+            return 0
+        if root.left is None:
+            return 1 + self.minDepth(root.right)
+        if root.right is None:
+            return 1 + self.minDepth(root.left)
+        leftDepth = self.minDepth(root.left)
+        rightDepth = self.minDepth(root.right)
+        return 1 + min(leftDepth, rightDepth)

2nd/homework_2/id_52/isSymmetric_52.py

@@ -0,0 +1,22 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def isSymmetricHelp(self, left, right):
+        if left is None or right is None:
+            return left == right
+        if left.val != right.val:
+            return False
+        return self.isSymmetricHelp(left.left, right.right) and self.isSymmetricHelp(left.right, right.left)
+    def isSymmetric(self, root):
+        """
+        :type root: TreeNode
+        :rtype: bool
+        """
+        if root is None:
+            return True
+        return self.isSymmetricHelp(root.left, root.right)

2nd/homework_3/id_52/flatten_52.py

@@ -0,0 +1,22 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+
+    pre = None
+    def flatten(self, root):
+        """
+        :type root: TreeNode
+        :rtype: void Do not return anything, modify root in-place instead.
+        """
+        if root is None:
+            return
+        self.flatten(root.right)
+        self.flatten(root.left)
+        root.right = self.pre
+        root.left = None
+        self.pre = root

2nd/homework_4/id_52/spiralOrder_52.py

@@ -0,0 +1,28 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+class Solution(object):
+    def spiralOrder(self, matrix):
+        """
+        :type matrix: List[List[int]]
+        :rtype: List[int]
+        """
+        ret = []
+        while matrix:
+            ret += matrix.pop(0)
+            if matrix and matrix[0]:
+                for row in matrix:
+                    ret.append(row.pop())
+            if matrix:
+                ret += matrix.pop()[::-1]
+            if matrix and matrix[0]:
+                for row in matrix[::-1]:
+                    ret.append(row.pop(0))
+        return ret
+
+sol = Solution()
+arr = [[1,2,3],[4,5,6],[7,8,9]]
+print(sol.spiralOrder(arr))

2nd/homework_5/id_52/recoverTree_52.py

@@ -0,0 +1,33 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    first = None
+    second = None
+    pre = None
+    def midTraverse(self, root):
+        if root is None:
+            return
+        self.midTraverse(root.left)
+        if self.pre is not None:
+            if self.first is None and self.pre.val > root.val:
+                self.first = self.pre
+            if self.first is not None and self.pre.val > root.val:
+                self.second = root
+        self.pre = root
+        self.midTraverse(root.right)
+
+    def recoverTree(self, root):
+        """
+        :type root: TreeNode
+        :rtype: void Do not return anything, modify root in-place instead.
+        """
+        if root is None:
+            return
+        self.midTraverse(root)
+        self.first.val, self.second.val = self.second.val, self.first.val
+