LeetCode-回溯-Flood Fill

mid 79 单词搜索

注意：使用visit记录是否已使用过的字母，因为同一个单元格内的字母不允许被重复使用

    bool findExist(vector<vector<char>>& board, int i, int j, string word, int index, vector<vector<int>>& visit) {
        int row = board.size();
        int col = board[0].size();
        if (index == word.size()) return true;
        if (i < 0 || i >= row || j < 0 || j >= col || (visit[i][j] == 1) ||
            board[i][j] != word.at(index)) {
            return false;
        }
        visit[i][j] = 1;
        bool res = findExist(board, i-1, j, word, index+1, visit)
                || findExist(board, i+1, j, word, index+1, visit)
                || findExist(board, i, j-1, word, index+1, visit)
                || findExist(board, i, j+1, word, index+1, visit);
        visit[i][j] = 0;
        return res;
    }
    bool exist(vector<vector<char>>& board, string word) {
        int row = board.size();
        int col = board[0].size();
        vector<vector<int>> visit(row, vector<int>(col,0));
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                if (findExist(board, i, j, word, 0, visit)) {
                    return true;
                }
            }
        }
        return false;
    }

mid 200 岛屿数量

一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量
输入：grid = [
[“1”,“1”,“1”,“1”,“0”],
[“1”,“1”,“0”,“1”,“0”],
[“1”,“1”,“0”,“0”,“0”],
[“0”,“0”,“0”,“0”,“0”] ]
输出：1
和单词搜索不同，单词搜索在不匹配时，要回退visit标记，因为有可能在此点的字母有可能是目标word中间的字符；
计算岛屿数量不需要回退，一直往下遍历

    void dfs(vector<vector<char>>& grid, int i, int j) {
        //返回条件：当point不为1，表示已经是边界或已经遍历过
        //要需要把已经遍历到的point标记为2
        //并且需要排除非法情况：越界
        if (i < 0 || i >= grid.size() || j < 0 || j >= grid[0].size()
            || grid[i][j] != '1') {
            return;
        }
        grid[i][j] = '2';
        //遍历周围四个点，如果周围4个点都不为1，则就是边界最后一个点，返回到主函数中累加岛屿数量
        dfs(grid, i-1, j);
        dfs(grid, i, j-1);
        dfs(grid, i+1, j);
        dfs(grid, i, j+1);
        return;
    }
    int numIslands(vector<vector<char>>& grid) {
        int cnt = 0;
        for (int i = 0; i < grid.size(); i++) {
            for (int j = 0; j < grid[0].size(); j++) {
                if (grid[i][j] == '1') {
                    dfs(grid, i, j);
                    cnt++;
                }
            }
        }
        return cnt;
    }

mid 130 被围绕的区域

把任何不在边界且不与边界相连的O填充为X
注意：
1.换思路为找与边界相连的点，区别于岛屿数量是找与1相连的点，不然找与O相连的点会无法判断相邻O是不是边界O
2.注意dfs的入口，根据1的不同来设置入口（必须要入口）
此题的入口是外边界，如果不在主func中设置入口，在dfs里判断是否为外边界会导致中心要改的O退出，因为外边界依赖ij，只能作为入口（或在岛屿问题中dfs的入口：“是否为1”）
3.注意返回条件：①越界 ②已遍历过（标记） ③已遍历到所需值的边界O->O->X X即边界返回

    bool isBorder(vector<vector<char>>& board, int i, int j) {
        return (i == 0 || j == 0 || i == board.size()-1 || j == board[0].size()-1);
    }
    bool isNotValid(vector<vector<char>>& board, int i, int j) {
        return (i < 0 || j < 0 || i >= board.size() || j >= board[0].size());
    }
    // 岛屿问题按顺序的dfs搜索O并不能得知周边的点是不是边界点或与边界相通的点，因为下一个点还没有被标记
    // 换思路为用dfs搜索与边界连通的O并将其标记，这部分是不做改变的点，最后再遍历一边，把不做改变的点复位成O，把要改变的点改成X
    void dfs(vector<vector<char>>& board, int i, int j) {
        if (isNotValid(board, i, j)) return; //合法性判断
//        if (!isBorder(board, i , j)) return; //边界判断 不能放在dfs里面，只需要在入口处是筛选从边界进入即可，不然对位于中心的0会认为不是边界就退出
        if (board[i][j] == 'X' || board[i][j] == 'b') return;

        board[i][j] = 'b'; //边界处的O，标记
        // dfs递归此边界点周围4个点，如果是O就继续标记，否则返回
        dfs(board, i-1, j);
        dfs(board, i, j-1);
        dfs(board, i+1, j);
        dfs(board, i, j+1);
        return;
    }

    void solve(vector<vector<char>>& board) {
        for (int i = 0; i < board.size(); i++) {
            for (int j = 0; j < board[0].size(); j++) {
                if (isBorder(board, i, j)) { //作为dfs遍历的入口，边界判断 不能放在dfs里面，只需要在入口处是筛选从边界进入即可，不然对位于中心的0会认为不是边界就退出
                    dfs(board, i, j);
                }

            }
        }
        for (int i = 0; i < board.size(); i++) {
            for (int j = 0; j < board[0].size(); j++) {
                if (board[i][j] == 'b') {
                    board[i][j] = 'O';
                } else if (board[i][j] == 'O') {
                    board[i][j] = 'X';
                }
            }
        }
        return;
    }

733 图像渲染

    bool isNotValid(vector<vector<int>>& image, int i, int j) {
        return (i < 0 || j < 0 || i >= image.size() || j >= image[0].size());
    }
    void dfs(vector<vector<int>>& image, int i, int j, int originColor, int newColor,
             vector<vector<int>>& visit) {
        if(isNotValid(image, i, j) || visit[i][j] == 1 || image[i][j] != originColor) return;
        image[i][j] = newColor;
        visit[i][j] = 1;
        dfs(image, i-1, j, originColor, newColor, visit);
        dfs(image, i, j-1, originColor, newColor, visit);
        dfs(image, i+1, j, originColor, newColor, visit);
        dfs(image, i, j+1, originColor, newColor,visit);
        return;
    }
    vector<vector<int>> floodFill(vector<vector<int>>& image, int sr, int sc, int color) {
        vector<vector<int>> visit(image.size(), vector<int>(image[0].size(),0));
        dfs(image, sr, sc, image[sr][sc], color, visit);
        return image;
    }