homework-3

Author: zhangbingxu

3rd/homework_1/id_100/BinaryTreeZigzagLevelOrderTraversal_100.py

@@ -0,0 +1,32 @@
+# 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 zigzagLevelOrder(self, root):
+        """
+        :type root: TreeNode
+        :rtype: List[List[int]]
+        """
+
+        self.result = []
+        self.travel(root, 0)
+        return self.result
+
+    def travel(self, curr, level):
+        result = self.result
+        if not curr:
+            return
+        elif len(result) <= level:
+            result.append([curr.val])
+        elif level % 2 == 0:
+            result[level].extend([curr.val])
+        else:
+            result[level].insert(0, curr.val)
+
+        self.travel(curr.left, level + 1)
+        self.travel(curr.right, level + 1)

3rd/homework_10/id_100/BinaryTreeMaximumPathSum_100.py

@@ -0,0 +1,26 @@
+# 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 maxPathSum(self, root):
+        """
+        :type root: TreeNode
+        :rtype: int
+        """
+
+        self.max = root.val
+        self.maxPath(root)
+        return self.max
+
+    def maxPath(self, root):
+        if not root:
+            return 0
+        left = max(0, self.maxPath(root.left))
+        right = max(0, self.maxPath(root.right))
+        self.max = max(self.max, left + right + root.val)
+        return max(left, right) + root.val

3rd/homework_11/id_100/PathSumII_100.py

@@ -0,0 +1,31 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+# path + [root.val]  vs  path.append() ???
+
+
+class Solution(object):
+    def pathSum(self, root, sum):
+        """
+        :type root: TreeNode
+        :type sum: int
+        :rtype:   [List[int]]
+        """
+
+        result = []
+        self.findPath(root, sum, [], result)
+        return result
+
+    def findPath(self, root, rest, path, result):
+        if not root:
+            return
+        if not root.left and not root.right and root.val == rest:
+            result.append(path + [root.val])
+        self.findPath(root.left, rest - root.val,
+                    path + [root.val], result)
+        self.findPath(root.right, rest - root.val,
+                    path + [root.val], result)

3rd/homework_2/id_100/WordSearchII_100.py

@@ -0,0 +1,39 @@
+class Solution(object):
+    def findWords(self, board, words):
+        """
+        :type board: List[List[str]]
+        :type words: List[str]
+        :rtype: List[str]
+        """
+        trie = self.makeTrieTree({}, words)
+        self.res = set()
+        self.used = [[False] * len(board[0]) for _ in range(len(board))]
+        for i in range(len(board)):
+            for j in range(len(board[0])):
+                self.dfs(board, i, j, trie, '')
+        return list(self.res)
+
+    def dfs(self, board, i, j, trie, pre):
+        if '#' in trie:
+            self.res.add(pre)
+        if i < 0 or i >= len(board) or j < 0 or j >= len(board[0]):
+            return
+
+        if not self.used[i][j] and board[i][j] in trie:
+            self.used[i][j] = True
+            self.dfs(board, i + 1, j, trie[board[i][j]], pre + board[i][j])
+            self.dfs(board, i - 1, j, trie[board[i][j]], pre + board[i][j])
+            self.dfs(board, i, j + 1, trie[board[i][j]], pre + board[i][j])
+            self.dfs(board, i, j - 1, trie[board[i][j]], pre + board[i][j])
+            self.used[i][j] = False
+
+    def makeTrieTree(self, trie, words):
+        for word in words:
+            t = trie
+            for letter in word:
+                if letter not in t:
+                    t[letter] = {}
+                t = t[letter]
+            t['#'] = '#'
+
+        return trie

3rd/homework_3/id_100/PathSum_100.py

@@ -0,0 +1,25 @@
+# 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 hasPathSum(self, root, sum):
+        """
+        :type root: TreeNode
+        :type sum: int
+        :rtype: bool
+        """
+
+        if not root:
+            return False
+
+        if not root.left and not root.right and sum == root.val:
+            return True
+
+        sum = sum - root.val
+
+        return self.hasPathSum(root.left, sum) or self.hasPathSum(root.right, sum)

3rd/homework_4/id_100/LinkedListCycleII_100.py

@@ -0,0 +1,30 @@
+# Definition for singly-linked list.
+class ListNode(object):
+    def __init__(self, x):
+        self.val = x
+        self.next = None
+
+
+class Solution(object):
+    def detectCycle(self, head):
+        """
+        :type head: ListNode
+        :rtype: ListNode
+        """
+
+        if not head:
+            return None
+
+        fast, slow, entr = head, head, head
+
+        while (fast.next and fast.next.next and slow.next):
+            fast = fast.next.next
+            slow = slow.next
+
+            if fast == slow:
+                while(slow != entr):
+                    slow = slow.next
+                    entr = entr.next
+                return entr
+
+        return None

3rd/homework_5/id_100/GenerateParentheses_100.py

@@ -0,0 +1,20 @@
+class Solution(object):
+    def generateParenthesis(self, n):
+        """
+        :type n: int
+        :rtype: List[str]
+        """
+        self.list = []
+        self.max = n
+        self.backtrack('', 0, 0)
+        return self.list
+
+    def backtrack(self, str, open, close):
+        if len(str) == self.max * 2:
+            self.list.append(str)
+            return
+
+        if open < self.max:
+            self.backtrack(str + '(', open + 1, close)
+        if close < open:
+            self.backtrack(str + ')', open, close + 1)

3rd/homework_6/id_100/ValidSudoku_100.py

@@ -0,0 +1,26 @@
+class Solution(object):
+    def isValidSudoku(self, board):
+        """
+        :type board: List[List[str]]
+        :rtype: bool
+        """
+
+        if not board:
+            return False
+
+        m, n = len(board), len(board[0])
+        check_row = [[0 for i in range(9)] for j in range(9)]
+        check_col = [[0 for i in range(9)] for j in range(9)]
+        check_box = [[0 for i in range(9)] for j in range(9)]
+
+        for i in range(m):
+            for j in range(n):
+                if not board[i][j] == '.':
+                    num = int(board[i][j]) - 1
+                    k = i / 3 * 3 + j / 3  # ??
+                    if check_row[i][num] or check_col[j][num] or check_box[k][num]:
+                        return False
+
+                    check_row[i][num] = check_col[j][num] = check_box[k][num] = 1
+
+        return True

3rd/homework_7/id_100/FindLargestValueinEachTreeRow_100.py

@@ -0,0 +1,29 @@
+# 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 largestValues(self, root):
+        """
+        :type root: TreeNode
+        :rtype: List[int]
+        """
+        
+        self.list = []
+        self.findDfs(root, 0)
+        return 
+
+
+    def findDfs(self, node, level):
+        if not node: return None
+
+        if level == len(self.list):
+            self.list.append(node.val)
+        else:
+            self.list[level] = max(self.list[level], node.val)
+
+        self.findDfs(node.left, level + 1)
+        self.findDfs(node.right, level + 1)

3rd/homework_8/id_100/N-Queens_100.py

@@ -0,0 +1,34 @@
+class Solution(object):
+    def solveNQueens(self, n):
+        """
+        :type n: int
+        :rtype: List[List[str]]
+        """
+        board = [['.' for i in range(n)] for j in range(n)]
+        self.res = []
+        self.dfs(board, 0)
+        return self.res
+
+    def dfs(self, board, index):
+        if index == len(board):
+            self.res.append(self.construct(board))
+            return
+
+        for i in range(len(board)):
+            if self.validate(board, i, index):
+                board[i][index] = 'Q'
+                self.dfs(board, index + 1)
+                board[i][index] = '.'
+
+    def validate(self, board, x, y):
+        for i in range(len(board)):
+            for j in range(len(board[0])):
+                if board[i][j] == 'Q' and (x + j == y + i or x + y == i + j or x == i):
+                    return False
+        return True
+
+    def construct(self, board):
+        ll = []
+        for i in range(len(board)):
+            ll.append(''.join(board[i]))
+        return ll