130. 被圍繞的區域

題目來源：力扣（LeetCode）https://leetcode-cn.com/problems/surrounded-regions

題目

給定一個二維的矩陣，包含 'X' 和 'O'（字母 O）。

找到所有被 'X' 圍繞的區域，並將這些區域裡所有的 'O' 用 'X' 填充。

示例:

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

解釋:

被圍繞的區間不會存在於邊界上，換句話說，任何邊界上的 'O' 都不會被填充為 'X'。 任何不在邊界上，或不與邊界上的 'O'

解題思路

思路：DFS、BFS

首先先看題目，給定的二維矩陣中，包含 'X' 和 'O'（字母 O）。再看解釋部分，任何邊界上的 'O' 不會被填充為 'X'，那麼現在也就是說，其實有三個部分：

• 可形成包圍的 'X'；
• 被 'X' 包圍的 'O'；
• 未被 'X' 包圍的 'O'。

現在題目的要求是將被包圍的 'O'，轉變為 'X'。前面也說了，未被包圍的 'O'，是處於邊界上的，同時側面說明與邊界 'O' 相連的 'O' 又不會被 'X' 填充。

那麼我們可以根據這個性質，我們考慮從邊界開始擴散，先去標記不能被填充的 'O'

• 以邊界的 'O' 為起點，標記與之相連或者間接相連的字母 'O'；
• 當標記完上面部分的 'O'，此時開始遍歷矩陣，去判斷每個字母（注意：標記的為不會被替換的部分）：
  • 如果該字母是被標記的部分，那麼將其重新轉換為 'O'；
  • 如果該字母是未被標記的部門，那麼將其轉換為 'X'。

注意：題目要求的是原地修改，那麼我們標記的時候，將與邊界 'O' 相連的部分（包括邊界 'O'），標記為 'M'。

我們現在使用深度優先搜尋（DFS）和廣度優先搜尋（BFS）的方法來解決這個問題。具體的程式碼如下。

程式碼實現

#深度優先搜尋（DFS）
class Solution:
    def solve(self, board: List[List[str]]) -> None:
        """
        Do not return anything, modify board in-place instead.
        """
        if not board or len(board)==0:
            return

        def dfs(board, i, j):
            # 不處於矩陣內，或者如果已經標記的話，直接跳過
            if not (0<=i<m) or not (0<=j<n) or board[i][j] != 'O':
                return
            
            # 當確認為未標記的，並與邊界 'O' 直接間接相連的 'O' 時，標記為 'M'
            board[i][j] = 'M'
            # 向四個方位擴散
            # 上下左右
            dfs(board, i-1, j)
            dfs(board, i+1, j)
            dfs(board, i, j-1)
            dfs(board, i, j+1)
            

        m = len(board)
        n = len(board[0])

        # 從邊界的 'O' 開始搜尋
        for i in range(m):
            for j in range(n):
                # 先確認 i，j 是否處於邊界
                is_frontier = (i == 0 or j == 0 or i == m-1 or j == n-1)
                if is_frontier and board[i][j] == 'O':
                    dfs(board, i, j)
        
        # 遍歷二維陣列，將被標記為 'M' 的重新轉換為 'O'，未標記的，則轉換為 'X'
        for i in range(m):
            for j in range(n):
                if board[i][j] == 'O':
                    board[i][j] = 'X'
                if board[i][j] == 'M':
                    board[i][j] = 'O'

# 廣度優先搜尋（BFS）
class Solution:
    def solve(self, board: List[List[str]]) -> None:
        """
        Do not return anything, modify board in-place instead.
        """
        if not board or len(board) == 0:
            return
        
        m = len(board)
        n = len(board[0])

        from collections import deque
        queue = deque()

        # bfs 不同於 dfs 順著滿足條件的方向繼續搜尋
        # bfs 滿足條件的都要入佇列
        # 先將邊界的 'O' 入隊
        for i in range(m):
            # 這裡是二維矩陣的最左列與最右列
            if board[i][0] == 'O':
                queue.append((i, 0))
            if board[i][n-1] == 'O':
                queue.append((i, n-1))
        
        for j in range(n):
            # 這裡是二維矩陣的第一行和最後一行
            if board[0][j] == 'O':
                queue.append((0, j))
            if board[m-1][j] == 'O':
                queue.append((m-1, j))
        
        # 現在開始出隊，目前裡面的都是邊界的 'O'
        # 出隊的同時，進行標記，同時查詢與邊界 'O' 相連的部分入隊
        while queue:
            x, y = queue.popleft()
            board[x][y] = 'M'
            # 查詢相連部分
            for nx, ny in [(x-1, y), (x+1, y), (x, y-1), (x, y+1)]:
                if 0 <= nx < m and 0 <= ny < n and board[nx][ny] == 'O':
                    queue.append((nx, ny))
        
        # 同樣的，標記完後，遍歷整個二維矩陣，進行轉換
        for i in range(m):
            for j in range(n):
                if board[i][j] == 'O':
                    board[i][j] = 'X'
                if board[i][j] == 'M':
                    board[i][j] = 'O'

實現結果

歡迎關注

公眾號 【書所集錄】