160

Author: RealHacker

binary_tree_inorder_traversal.py

@@ -0,0 +1,30 @@
+# 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 inorderTraversal(self, root):
+        """
+        :type root: TreeNode
+        :rtype: List[int]
+        """
+        stack = [root]
+        result = []
+        while stack:
+            item = stack.pop()
+            if item is None:
+                continue
+            if isinstance(item, TreeNode):
+                if not item.left and not item.right:
+                    result.append(item.val)
+                else:
+                    stack.append(item.right)
+                    stack.append(item.val)
+                    stack.append(item.left)
+            else:
+                result.append(item)
+        return result
+        

dungeon_game.py

@@ -0,0 +1,36 @@
+class Solution(object):
+    def calculateMinimumHP(self, dungeon):
+        """
+        :type dungeon: List[List[int]]
+        :rtype: int
+        """
+        if not dungeon:
+            return 0
+        N = len(dungeon)
+        M = len(dungeon[0])
+        matrix = []
+        for i in range(N):
+            row = [0]*M
+            matrix.append(row)
+        matrix[N-1][M-1] = 1 if dungeon[N-1][M-1]>=0 else -dungeon[N-1][M-1]+1
+        for n in range(M+N-1, -1, -1):
+            for x in range(N):
+                y = n-x
+                if y <0 or y>=M:
+                    continue
+                candidates=[]
+                if x+1<N:
+                    candidates.append(matrix[x+1][y])
+                if y+1<M:
+                    candidates.append(matrix[x][y+1])
+                if not candidates: continue
+                min_need = min(candidates)
+                if dungeon[x][y]>=0:
+                    if dungeon[x][y]>=min_need:
+                        matrix[x][y]=1
+                    else:
+                        matrix[x][y]=min_need-dungeon[x][y]
+                else:
+                    matrix[x][y] = min_need-dungeon[x][y]
+        return matrix[0][0]
+            

gas_station.py

@@ -0,0 +1,19 @@
+class Solution(object):
+    def canCompleteCircuit(self, gas, cost):
+        """
+        :type gas: List[int]
+        :type cost: List[int]
+        :rtype: int
+        """
+        diffs = [gas[i]-cost[i] for i in range(len(gas))]
+        least = 0
+        min_index = 0
+        sum = 0
+        for i, diff in enumerate(diffs):
+            if sum <least:
+                least = sum
+                min_index = i
+            sum = sum+diff
+        if sum<0:
+            return -1
+        return min_index

partition_list.py

@@ -0,0 +1,51 @@
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution(object):
+    def partition(self, head, x):
+        """
+        :type head: ListNode
+        :type x: int
+        :rtype: ListNode
+        """
+        cursor= head
+        precursor = None
+        head1 = tail1 = None
+        head2 = tail2 = None
+        
+        while cursor:
+            if cursor.val < x:
+                if not head1:
+                    head1 = cursor
+                    tail1 = cursor
+                else:
+                    tail1.next = cursor
+                    tail1 = tail1.next
+                if tail2:
+                    tail2.next = cursor.next
+            else:
+                if not head2:
+                    head2 = cursor
+                tail2 = cursor
+            cursor = cursor.next
+        if tail1:
+            tail1.next = None
+        if tail2:
+            tail2.next = None
+        if not head1:
+            return head2
+        else:
+            tail1.next = head2
+            return head1
+            
+                
+                
+                
+                
+                
+                
+                
+                

swap_nodes_in_pairs.py

@@ -0,0 +1,33 @@
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution(object):
+    def swapPairs(self, head):
+        """
+        :type head: ListNode
+        :rtype: ListNode
+        """
+        if not head or not head.next:
+            return head
+        
+        newHead = None
+        tail = None
+        p1 = head
+        p2 = head.next
+        while p1 and p2:
+            p1.next = p2.next
+            p2.next = p1
+            if newHead:
+                tail.next = p2
+            else:
+                newHead = p2
+            tail = p1
+            
+            p1 = p1.next
+            if p1:
+                p2 = p1.next
+                
+        return newHead