題目

給定一個二維的矩陣，包含 ‘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’ 相連的 ‘O’ 最終都會被填充為 ‘X’。如果兩個元素在水平或垂直方向相鄰，則稱它們是“相連”的。

解題思路

思路：DFS、BFS

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

可形成包圍的 ‘X’；
被 ‘X’ 包圍的 ‘O’；
未被 ‘X’ 包圍的 ‘O’。

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

那麼我們可以根據這個性質，我們考慮從邊界開始擴散，先去標記不能被填充的 ‘O’，也就是與邊界 ‘O’ 相連的部分，那麼剩下的 ‘O’ 則會被包圍轉變為 ‘X’。具體的做法如下：

以邊界的 ‘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'

結果大家可以自己動手實現一下哦！

Python實戰操作：解題之被圍繞的區域

相關文章