問題描述

給定一個二維的矩陣，包含'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'。如果兩個元素在水平或垂直方向相鄰，則稱它們是“相連”的。

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

解答

/*
本題給定的矩陣中有三種元素：

字母 X；
被字母 X 包圍的字母 O；
沒有被字母 X 包圍的字母 O。
本題要求將所有被字母 X 包圍的字母 O都變為字母 X ，但很難判斷哪些 O 是被包圍的，哪些 O 不是被包圍的。

注意到題目解釋中提到：任何邊界上的 O 都不會被填充為 X。 我們可以想到，所有的不被包圍的 O 都直接或間接與邊界上的 O 相連。我們可以利用這個性質判斷 O 是否在邊界上，具體地說：

對於每一個邊界上的 O，我們以它為起點，標記所有與它直接或間接相連的字母 O；
最後我們遍歷這個矩陣，對於每一個字母：
如果該字母被標記過，則該字母為沒有被字母 X 包圍的字母 O，我們將其還原為字母 O；
如果該字母沒有被標記過，則該字母為被字母 X 包圍的字母 O，我們將其修改為字母 X。
 
*/
class Solution {
    boolean[][] visited;
    public void mark(int row, int column, int x, int y, char board[][]){
        if(x<0 || x==row || y<0 || y==column || board[x][y]!='O' || visited[x][y])return;
        board[x][y] = 'M';
        visited[x][y] = true;
        mark(row, column, x+1, y, board);
        mark(row, column, x
 
-1, y, board);
        mark(row, column, x, y+1, board);
        mark(row, column, x, y-1, board);
        visited[x][y] = false;
    }
    public void solve(char[][] board) {
        int row = board.length;
        if(row <= 1)return;
        int column = board[0].length;
        if(column <= 1)return;

        visited = new boolean[row][column];
        
        for(int i=0;i<row;i++){//mark第一列
            if(board[i][0] == 'O')mark(row, column, i, 0, board);
        }
        for(int j=1;j<column;j++){//mark第一行
            if(board[0][j] == 'O')mark(row, column, 0, j, board);
        }
        for(int j=1;j<column;j++){//mark最後一行
            if(board[row-1][j] == 'O')mark(row, column, row-1, j, board);
        }
        for(int i=0;i<row-1;i++){//mark最後一列
            if(board[i][column-1] == 'O')mark(row, column, i, column-1, board);
        }
        for(int i=0;i<row;i++){
            for(int j=0;j<column;j++){
                if(board[i][j] == 'O')board[i][j] = 'X';
                if(board[i][j] == 'M')board[i][j] = 'O';
            }
        }
    }
}
/*儲存座標，但是太低效
class Solution {
    Map<String, Integer> visited;
    Map<String, Integer> invailed;
    public int flood(int row, int column, int x, int y, char[][] board){
        if(board[x][y] == 'X' || visited.containsKey(x+","+y) || invailed.containsKey(x+","+y))return 0;
        visited.put(x+","+y, 1);
        //System.out.println(x+"-->"+y+"comes");
        if(x == 0 || x == row-1 || y == 0 || y == column-1){
            visited.remove(x+","+y);
            if(board[x][y] == 'O')return -1;
            else return 0;
        }else{
            board[x][y] = 'X';
            int sum = 0;
            sum += flood(row, column, x+1, y, board);
            sum += flood(row, column, x-1, y, board);
            sum += flood(row, column, x, y+1, board);
            sum += flood(row, column, x, y-1, board);
            //System.out.println(x+","+y+"-->"+sum);
            return sum;
        }
    }
    public void solve(char[][] board) {
        int row = board.length;
        if(row <= 1)return;
        int column = board[0].length;
        if(column <= 1)return;
        visited = new HashMap<String, Integer>();
        invailed = new HashMap<String, Integer>();
        for(int i=1;i<row-1;i++){
            for(int j=1;j<column-1;j++){
                if(board[i][j] == 'X' || invailed.containsKey(i+","+j))continue;
                int sum = flood(row, column, i, j, board);
                //System.out.println(i+" "+j+"-->"+sum);
                if(sum < 0){
                    for(Map.Entry<String, Integer> entry:visited.entrySet()){
                        String[] coordination = entry.getKey().split(",");
                        board[Integer.parseInt(coordination[0])][Integer.parseInt(coordination[1])] = 'O';
                        //System.out.println(x+"-->"+y+board[x][y]+"origin:"+entry.getKey());
                    }
                    invailed.putAll(visited);
                }
                visited.clear();
            }
        }
        invailed.clear();
    }
}
*/
/*超時。。。
class Solution {
    boolean[][] visited;
    public int flood(int row, int column, int x, int y, char[][] board){
        if(board[x][y] == 'X' || visited[x][y])return 0;
        visited[x][y] = true;
        if(x == 0 || x == row-1 || y == 0 || y == column-1){
            visited[x][y] = false;
            if(board[x][y] == 'O')return -1;
            else return 0;
        }else{
            int sum = 0;
            sum += flood(row, column, x+1, y, board);
            sum += flood(row, column, x-1, y, board);
            sum += flood(row, column, x, y+1, board);
            sum += flood(row, column, x, y-1, board);
            visited[x][y] = false;
            //System.out.println(x+","+y+"   "+sum+"-->"+visited[x][y]);
            return sum;
        }
    }
    public void solve(char[][] board) {
        int row = board.length;
        if(row <= 1)return;
        int column = board[0].length;
        if(column <= 1)return;
        visited = new boolean[row][column];
        for(int i=1;i<row-1;i++){
            for(int j=1;j<column-1;j++){
                if(board[i][j] == 'X' || visited[i][j])continue;
                int sum = flood(row, column, i, j, board);
                if(sum == 0)board[i][j] = 'X';
            }
        }
    }
}
*/