二維平面上使用回溯算法

二維平面上使用回溯算法

LeetCode79 單詞搜索

給定一個二維網格和一個單詞，找出該單詞是否存在於網格中。

單詞必須按照字母順序，通過相鄰的單元格內的字母構成，其中“相鄰”單元格是那些水平相鄰或垂直相鄰的單元格。同一個單元格內的字母不允許被重複使用。

board =
[
  ['A','B','C','E'],
  ['S','F','C','S'],
  ['A','D','E','E']
]

給定 word = "ABCCED", 返回 true
給定 word = "SEE", 返回 true
給定 word = "ABCB", 返回 false

來源：力扣（LeetCode 79）

class Solution {
    boolean[][] isVisited;
    //爲了移動方便設置的偏移量數組
    int[][] d={{0,1},{1,0},{0,-1},{-1,0}};

    public boolean inArea(int newx,int newy,char[][] board){
        return newx>=0&&newx<board.length&&newy>=0&&newy<board[0].length;
    }

    //從board[startx][starty]開始  去找從index開始的所有字母在board當中能不能被找見
    public boolean searchWord(char[][] board,String word,int startx,int starty,int index){

        //index表示單詞的下標索引
        //這個if表示單詞的全部字母找到
        if(word.length()-1==index){
            return board[startx][starty]==word.charAt(index);
        }
        
        if(board[startx][starty]==word.charAt(index)){
            isVisited[startx][starty]=true;
            for(int i=0;i<4;i++){
                int newx=startx+d[i][0];
                int newy=starty+d[i][1];
                //如果新的座標沒有被訪問過而且沒有越界
                if(inArea(newx,newy,board)&&!isVisited[newx][newy]){
                   if(searchWord(board,word,newx,newy,index+1))
                        return true;
                }
            }
            //如果上下左右都沒有 回溯
            isVisited[startx][starty]=false;
        }

        return false;

    }
    public boolean exist(char[][] board, String word) {
        isVisited=new boolean[board.length][board[0].length];
        //循環遍歷這個二維數組的每一個位置去search
        for(int i=0;i<board.length;i++){
            for(int j=0;j<board[i].length;j++){
                if(searchWord(board,word,i,j,0))
                    return true;
            }
        }
        //雙重循環把所有位置遍歷完成之後 依然沒有找到 說明該網格沒有這個單詞
        return false;
    }
}

LeetCode200 島嶼數量

給你一個由 ‘1’（陸地）和 ‘0’（水）組成的的二維網格，請你計算網格中島嶼的數量。

島嶼總是被水包圍，並且每座島嶼只能由水平方向或豎直方向上相鄰的陸地連接形成。

此外，你可以假設該網格的四條邊均被水包圍。

輸入:
11000
11000
00100
00011
輸出: 3
解釋: 每座島嶼只能由水平和/或豎直方向上相鄰的陸地連接而成。

輸入:
11110
11010
11000
00000
輸出: 1

class Solution {
    int[][] move={{0,1},{1,0},{0,-1},{-1,0}};
    int m,n;
    boolean[][] visited;
    public boolean inArea(int x,int y){
        return x>=0&&x<m&&y>=0&&y<n;
    }
    
    //從grid[x][y]開始進行floodfill算法
    //把和這個1水平或豎直方向相連的所有地區標記成一塊
    public void dfs(char[][] grid,int x,int y){
        visited[x][y]=true;
        for(int i=0;i<4;i++){
            int newx=x+move[i][0];
            int newy=y+move[i][1];
            if(inArea(newx,newy)&&!visited[newx][newy]&&grid[newx][newy]=='1'){
                dfs(grid,newx,newy);
            }
        }
        return;
    }
    public int numIslands(char[][] grid) {
        m=grid.length;
        if(m==0) return 0;
        n=grid[0].length;
        visited=new boolean[m][n];
        //定義res存儲這個地圖有多少個島嶼
        int res=0;
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(grid[i][j]=='1'&&!visited[i][j]){
                    res+=1;
                    //每次找到一個地區之後 把和該地區相連的所有1地區
                    //全部標記成爲一塊區域 這些地區組成1塊島嶼
                    //dfs的任務就是把和這個1水平或豎直方向相連的所有地區標記成一塊
                    dfs(grid,i,j);
                }
            }
        }
        return res;
    }
}

LeetCode130 被圍繞的區域

給定一個二維的矩陣，包含 ‘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 130）

class Solution {
    int[][] move={{0,1},{1,0},{0,-1},{-1,0}};
    int m,n;
    boolean[][] visited;
    public boolean inArea(int x,int y){
        return x>=0&&x<m&&y>=0&&y<n;
    }

    public void dfs(char[][] board,int x,int y,boolean[][] visited){
        visited[x][y]=true;
        //找這個位置的上下左右四個方向
        for(int i=0;i<4;i++){
            int newx=x+move[i][0];
            int newy=y+move[i][1];
            if(inArea(newx,newy)&&!visited[newx][newy]&&board[newx][newy]=='O'){
                dfs(board,newx,newy,visited);
            }
        }
        return;
    }

    public void solve(char[][] board) {
        //m表示行
        m=board.length;
        if(m==0)
            return;
        //n表示列
        n=board[0].length;
        

        visited=new boolean[m][n];
    
        if(m==0||m==0)
            return;

        for(int i=0;i<n;i++){
            //第一行
            if(board[0][i]=='O') dfs(board,0,i,visited);
            //最後一行
            if(board[m-1][i]=='O') dfs(board,m-1,i,visited);
        }

        for(int j=0;j<m;j++){
            //最左列
            if(board[j][0]=='O') dfs(board,j,0,visited);
            //最右列
            if(board[j][n-1]=='O') dfs(board,j,n-1,visited);
        }

        //通過以上的4個if 把邊界上的O和與邊界上的O相鄰的所有的O找到
        //並且把他們標記爲true

        //雙重循環遍歷整個數組 如果board[i][j]的元素爲O而且這個O不在邊界 不和邊界的O相鄰
        //那麼此時的O就是我們要替換成X的O 我們替換即可
        for(int i=0;i<m;i++){
            for( int j=0;j<n;j++){
                if(board[i][j]=='O'&&!visited[i][j]){
                    board[i][j]='X';
                }
            }
        }
        return;
    }
}

---