12.10

Author: huangyt39

140.py

@@ -0,0 +1,26 @@
+class Solution:
+    """
+    @param a: A 32bit integer
+    @param b: A 32bit integer
+    @param n: A 32bit integer
+    @return: An integer
+    """
+    def fastPower(self, a, b, n):
+        # write your code here
+        # (x1 + x2)**n == x1**n + x1**(n-1)*x2 + ... + x2**n
+        # a**n = (x1*b + x2)**n
+        # a**n % b = x2**n % b
+        return self.Power(a,b,n,1)
+    
+    def Power(self, a, b, n, m):
+        if a >= b:
+            return self.Power(a%b, b, n, m)
+        else:
+            if a <= 1 or n <= 1:
+                return (a**n*m)%b
+            if n%2 == 0:
+                return self.Power(a**2, b, n//2, m)
+            else:
+                return self.Power(a**2, b, n//2, m*a)
+                
+                # 3751 9723 2723 4713 

174.py

@@ -0,0 +1,37 @@
+"""
+Definition of ListNode
+class ListNode(object):
+    def __init__(self, val, next=None):
+        self.val = val
+        self.next = next
+"""
+
+class Solution:
+    """
+    @param head: The first node of linked list.
+    @param n: An integer
+    @return: The head of linked list.
+    """
+    def removeNthFromEnd(self, head, n):
+        # write your code here
+        if head == None or n < 0:
+            return head
+        
+        lf, rg = head, head
+        for i in range(n):
+            rg = rg.next
+            
+        if rg == None:
+            delNode = head
+            head = head.next
+            del delNode
+            return head
+            
+        while rg.next != None:
+            rg = rg.next
+            lf = lf.next
+        
+        delNode = lf.next
+        lf.next = delNode.next
+        del delNode
+        return head

245.py

@@ -0,0 +1,34 @@
+"""
+Definition of TreeNode:
+class TreeNode:
+    def __init__(self, val):
+        self.val = val
+        self.left, self.right = None, None
+"""
+
+class Solution:
+    """
+    @param T1: The roots of binary tree T1.
+    @param T2: The roots of binary tree T2.
+    @return: True if T2 is a subtree of T1, or false.
+    """
+    def isSubtree(self, T1, T2):
+        # write your code here
+        return self.isSubtreeWithFlag(T1, T2, 1)
+        
+    def isSubtreeWithFlag(self, T1, T2, flag):
+        if flag:
+            if not T2:
+                return True
+            if not T1:
+                return False
+        if not T2 and not T1:
+            return True
+        if not T2 or not T1:
+            return False
+        flag = 0
+        
+        if T1.val != T2.val:
+            return self.isSubtreeWithFlag(T1.left, T2, flag) or self.isSubtreeWithFlag(T1.right, T2, flag)
+        else:
+            return self.isSubtreeWithFlag(T1.left, T2, flag) or self.isSubtreeWithFlag(T1.right, T2, flag) or (self.isSubtreeWithFlag(T1.left, T2.left, flag) and self.isSubtreeWithFlag(T1.right, T2.right, flag))

371.py

@@ -0,0 +1,22 @@
+class Solution:
+    """
+    @param n: An integer
+    @return: An array storing 1 to the largest number with n digits.
+    """
+    def numbersByRecursion(self, n):
+        # write your code here
+        if n <= 0:
+            return []
+        if n == 1:
+            return [i for i in range(10)][1:]
+            
+        n_1 = self.numbersByRecursion(n-1)
+        if(n-1 == 1):
+            n_1.insert(0,0)
+        res = []
+        for i in range(10):
+            res += [i*(10**(n-1))]*(10**(n-1))
+            for j in range(10**(n-1)):
+                res[-j] += n_1[-j]
+        
+        return res[1:]

372.py

@@ -0,0 +1,29 @@
+"""
+Definition of ListNode
+class ListNode(object):
+
+    def __init__(self, val, next=None):
+        self.val = val
+        self.next = next
+"""
+
+
+class Solution:
+    """
+    @param: node: the node in the list should be deletedt
+    @return: nothing
+    """
+    def deleteNode(self, node):
+        # write your code here
+        if node == None:
+            return
+        
+        nextnode = node.next
+        if nextnode == None:
+            node = None
+        else:
+            tmp = nextnode
+            node.val = nextnode.val
+            node.next = nextnode.next
+            del tmp
+        return

373.py

@@ -0,0 +1,24 @@
+class Solution:
+    """
+    @param: nums: an array of integers
+    @return: nothing
+    """
+    def partitionArray(self, nums):
+        # write your code here
+        if len(nums) <= 1:
+            return 
+        
+        start, end = 0, len(nums)-1
+        while start < end:
+            while nums[start]%2 == 1:
+                start += 1
+            while nums[end]%2 == 0:
+                end -= 1
+            if start >= end:
+                return
+            else:
+                tmp = nums[start]
+                nums[start] = nums[end]
+                nums[end] = tmp
+        return
+            

376.py

@@ -0,0 +1,35 @@
+"""
+Definition of TreeNode:
+class TreeNode:
+    def __init__(self, val):
+        self.val = val
+        self.left, self.right = None, None
+"""
+
+
+class Solution:
+    """
+    @param: root: the root of binary tree
+    @param: target: An integer
+    @return: all valid paths
+    """
+    def binaryTreePathSum(self, root, target):
+        # write your code here
+        res = []
+        self.binaryTreePath(root, target, [], res)
+        
+        return res
+        
+    def binaryTreePath(self, root, target, arr, res):
+        if not root:
+            return
+        
+        target -= root.val
+        arr.append(root.val)
+        if target == 0 and (not root.left and not root.right):
+            res.append(arr)
+            return
+        else:
+            self.binaryTreePath(root.left, target, arr[:], res)
+            self.binaryTreePath(root.right, target, arr[:], res)
+            return