day 10

Author: Your Name

130SurroundedRegions.py

@@ -0,0 +1,64 @@
+# Given an m x n matrix board containing 'X' and 'O', capture all regions that are 4-directionally surrounded by 'X'.
+
+# A region is captured by flipping all 'O's into 'X's in that surrounded region.
+
+# [["X","X","X","X"],
+#  ["X","O","O","X"],
+#  ["X","X","O","X"],
+#  ["X","O","X","X"]]
+
+
+# [["X","X","X","X"],
+#  ["X","X","X","X"],
+#  ["X","X","X","X"],
+#  ["X","O","X","X"]]
+
+
+[["X","X","X"],
+ ["X","O","X"],
+ ["X","X","X"]]
+ 
+class Solution(object):
+    def solve(self, board):
+        """
+        :type board: List[List[str]]
+        :rtype: None Do not return anything, modify board in-place instead.
+        """
+        visited = set()
+        movement = [(0, -1), (0, 1), (1, 0), (-1, 0)]
+        rowSize = len(board)
+        colSize = len(board[0])
+        def helper(startx, starty):
+            queue = []
+            currentVisited = set()
+            queue.append((startx, starty))
+            currentVisited.add((startx, starty))
+            flag = True
+            while queue:
+                curr = queue.pop(0)
+                for step in movement:
+                    newx = curr[0] + step[0]
+                    newy = curr[1] + step[1]
+                    if newx == -1 or newx == rowSize or newy == -1 or newy == colSize:
+                        flag = False
+                    else:
+                        if board[newx][newy] == 'O' and (newx, newy) not in currentVisited:
+                            currentVisited.add((newx, newy))
+                            visited.add((newx, newy))
+                            queue.append((newx, newy))
+            if flag:
+                # surrounded by 'o'
+                for cell in currentVisited:
+                    board[cell[0]][cell[1]] = 'X'
+            
+        for i in range(rowSize):
+            for j in range(colSize):
+                if (i,j) not in visited and board[i][j] == 'O':
+                    helper(i, j)
+        return board
+
+sol = Solution()
+res = sol.solve([["X","X","X"],
+ ["X","O","X"],
+ ["X","X","X"]])
+print(res)

150EvaluateReversePolishNotation.py

@@ -27,6 +27,5 @@ def evalRPN(self, tokens):
         return stack[0]
 
 sol = Solution()
-res = sol.evalRPN(["10","6","9","3","+","-11","*","/","*","17","+","5","+"]
-)
+res = sol.evalRPN(["10","6","9","3","+","-11","*","/","*","17","+","5","+"])
 print(res)

200NumberofIslands.py

@@ -0,0 +1,60 @@
+# Given an m x n 2D binary grid grid which represents a map of '1's (land) and '0's (water), return the number of islands.
+
+# An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. You may assume all four edges of the grid are all surrounded by water.
+
+ 
+
+# Example 1:
+
+# Input: grid = [
+#   ["1","1","1","1","0"],
+#   ["1","1","0","1","0"],
+#   ["1","1","0","0","0"],
+#   ["0","0","0","0","0"]
+# ]
+# Output: 1
+
+class Solution(object):
+    def numIslands(self, grid):
+        """
+        :type grid: List[List[str]]
+        :rtype: int
+        """
+        rowSize = len(grid)
+        colSize = len(grid[0])
+        move = [(0, -1), (0, 1), (-1, 0), (1, 0)]
+        visited = set()
+        count = 0
+        def helper(startx, starty):
+            # up y--
+            # down y++
+            # left x--
+            # right x++
+            queue = []
+            queue.append((startx, starty))
+            visited.add((startx, starty))
+            while queue:
+                curr = queue.pop(0)
+                currx = curr[0]
+                curry = curr[1]
+                for step in move:
+                    newx = currx + step[0]
+                    newy = curry + step[1]
+                    if (newx, newy) not in visited and newx > -1 and newx < rowSize and newy > -1 and newy < colSize and grid[newx][newy] == '1':
+                        queue.append((newx, newy))  
+                        visited.add((newx, newy)) 
+        for i in range(rowSize):
+            for j in range(colSize):
+                if grid[i][j] == '1' and (i, j) not in visited:
+                    helper(i, j)
+                    count += 1
+        return count
+sol = Solution()
+res = sol.numIslands(grid = [
+  ["1","1","1","1","0"],
+  ["1","1","0","1","0"],
+  ["1","1","0","0","0"],
+  ["0","0","0","0","0"]
+])
+print(res)
+