C++ DFS 与 BFS

1. DFS 深度优先算法（Depth First Search）

过程：对每一个可能的分支路径深入到不能再深入为止，如果遇到死路就往回退，回退过程中如果遇到没探索过的支路，就进入该支路继续深入，每个节点只能访问一次。

2. BFS 广度优先算法 （Breadth First Search）

过程：从根节点开始，沿着树(图)的宽度遍历节点。如果所有节点均被访问，则算法中止。

(5条消息) DFS与BFS算法_风止_的博客-CSDN博客_bfs和dfs算法

LK130. 被围绕的区域：

给一个 m x n 的矩阵 board ，由若干字符 'X' 和 'O' ，找到所有被 'X' 围绕的区域，并将这些区域里所有的 'O' 用 'X' 填充。

解题：

（1）DFS

int m, n;

void dfs(vector<vector<char>>& board, int x, int y) {
    if (x < 0 || x >= m || y < 0 || y >= n || board[x][y] != 'O') {
        return;
    }
    board[x][y] = 'A';
    dfs(board, x - 1, y);
    dfs(board, x + 1, y);
    dfs(board, x, y - 1);
    dfs(board, x, y + 1);
}

void solve(vector<vector<char>>& board) {
    m = board.size();
    n = board[0].size();

    if (m == 0 || n == 0)
        return;

    for (int i = 0; i < m; i++) {
        dfs(board, i, 0);
        dfs(board, i, n - 1);
    }

    for (int i = 1; i < n - 1; i++) {
        dfs(board, 0, i);
        dfs(board, m - 1, i);
    }

    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (board[i][j] == 'A')
                board[i][j] = 'O';
            else if (board[i][j] == 'O') {
                board[i][j] = 'X';
            }
        }
    }
    return;
}

（2）BFS

const int iter[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
int m, n;
    
void solve(vector<vector<char>>& board) {
    m = board.size();
    n = board[0].size();

    if (m == 0 || n == 0)
        return;
        
    queue<pair<int, int>> path;

    for (int i = 0; i < m; i++) {
        if (board[i][0] == 'O') {
            board[i][0] = 'A';
            path.emplace(i, 0);
        }
        if (board[i][n - 1] == 'O') {
            board[i][n - 1] = 'A';
            path.emplace(i, n - 1);
        }
    }
    for (int i = 1; i < n - 1; i++) {
        if (board[0][i] == 'O') {
            board[0][i] = 'A';
            path.emplace(0, i);
        }
        if (board[m - 1][i] == 'O') {
            board[m - 1][i] = 'A';
            path.emplace(m - 1, i);
        }
    }

    while (!path.empty()) {
        auto [x, y] = path.front();
        path.pop();

        for (int i = 0; i < 4; i++) {
            int xx = x + iter[i][0];
            int yy = y + iter[i][1];
            if (xx >= 0 && xx < m && yy >= 0 && yy < n && board[xx][yy] == 'O') {
                board[xx][yy] = 'A';
                path.emplace(xx, yy);
            } 
        }
    }

    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (board[i][j] == 'A')
                board[i][j] = 'O';
            else if (board[i][j] == 'O') {
                board[i][j] = 'X';
            }
        }
    }
    return;
}