Recover Binary Search Tree/ Surrounded Regions

Author: gavinfish

099 Recover Binary Search Tree.py

@@ -0,0 +1,48 @@
+'''
+Two elements of a binary search tree (BST) are swapped by mistake.
+
+Recover the tree without changing its structure.
+
+Note:
+A solution using O(n) space is pretty straight forward. Could you devise a constant space solution?
+'''
+
+# 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 __init__(self):
+        self.node1 = None
+        self.node2 = None
+        self.pre = None
+
+    def recoverTree(self, root):
+        """
+        :type root: TreeNode
+        :rtype: void Do not return anything, modify root in-place instead.
+        """
+        self.__scan(root)
+        self.node1.val, self.node2.val = self.node2.val, self.node1.val
+
+    def __scan(self, root):
+        if root is None:
+            return
+        self.__scan(root.left)
+        if self.pre is not None:
+            if root.val < self.pre.val:
+                if self.node1 is None:
+                    self.node1 = self.pre
+                    self.node2 = root
+                else:
+                    self.node2 = root
+        self.pre = root
+        self.__scan(root.right)
+
+
+if __name__ == "__main__":
+    None

130 Surrounded Regions.py

@@ -0,0 +1,71 @@
+'''
+Given a 2D board containing 'X' and 'O', capture all regions surrounded by 'X'.
+
+A region is captured by flipping all 'O's into 'X's in that surrounded region.
+
+For example,
+X X X X
+X O O X
+X X O X
+X O X X
+After running your function, the board should be:
+
+X X X X
+X X X X
+X X X X
+X O X X
+'''
+
+class Solution(object):
+    def solve(self, board):
+        """
+        :type board: List[List[str]]
+        :rtype: void Do not return anything, modify board in-place instead.
+        """
+        if not board or not board[0]:
+            return
+        n = len(board)
+        m = len(board[0])
+        queue = []
+        # Get all 'O' on edge
+        for i in range(n):
+            for j in range(m):
+                if ((i in (0, n - 1)) or (j in (0, m - 1))) and board[i][j] == 'O':
+                    queue.append((i, j))
+        # Mark all 'O' which can connect to 'O' on edge
+        while queue:
+            r, c = queue.pop(0)
+            if 0 <= r < n and 0 <= c < m and board[r][c] == 'O':
+                board[r][c] = 'M'
+                if r - 1 >= 0 and board[r - 1][c] == 'O':
+                    queue.append((r - 1, c))
+                if r + 1 < n and board[r + 1][c] == 'O':
+                    queue.append((r + 1, c))
+                if c - 1 >= 0 and board[r][c - 1] == 'O':
+                    queue.append((r, c - 1))
+                if c + 1 < m and board[r][c + 1] == 'O':
+                    queue.append((r, c + 1))
+        # Update characters
+        for i in range(n):
+            for j in range(m):
+                if board[i][j] == 'M':
+                    board[i][j] = 'O'
+                else:
+                    board[i][j] = 'X'
+
+
+if __name__ == "__main__":
+    board = [
+        ['X', 'X', 'X', 'X'],
+        ['X', 'O', 'O', 'X'],
+        ['X', 'X', 'O', 'X'],
+        ['X', 'O', 'X', 'X']
+    ]
+    expected_board = [
+        ['X', 'X', 'X', 'X'],
+        ['X', 'X', 'X', 'X'],
+        ['X', 'X', 'X', 'X'],
+        ['X', 'O', 'X', 'X']
+    ]
+    Solution().solve(board)
+    assert board == expected_board