leetcode 130. Surrounded Regions 典型的深度优先遍历DFS + 矩阵遍历

Given a 2D board containing ‘X’ and ‘O’ (the letter O), capture all regions surrounded by ‘X’.

A region is captured by flipping all ‘O’s into ‘X’s in that surrounded region.

For example,
X X X X
X O O X
X X O X
X O X X
After running your function, the board should be:

X X X X
X X X X
X X X X
X O X X

从矩形最外面一圈开始逐渐向里拓展。 若 O 是在矩形最外圈，它肯定不会被 X 包围，与它相连（邻）的 O 也就不可能被 X 包围，也就不会被替换，所以我们的工作主要是找出：
1）最外圈的 O
2）与最外圈的 O 相连的 O
3） 将上述找到的元素替换为某种标识符，代码中使用“#”
4.）最后按先行后列的顺序遍历矩形，找到没有被替换为 O 的元素，它们就是被 X 完全包围的需要被替换为 X 的元素；同时，标记为 # 的元素是没有被 X 包围的元素，此时将它们变回原来的 O

这道题的亮点是从问题的对立面来考虑做得，是很经典的DFS深度优先遍历的做法，很棒

代码如下：

import java.util.Stack;

class Point
{
    int row;
    int col;
    Point(int a,int b)
    {
        row = a;
        col =b;
    }
}

/*
 * 这个用来学习BFS和DFS很有用
 * 
 * 本题是要求把所有的内部的O替换为X，但是矩阵边界的O不算，
 * 本题是从反面来考虑的，把所有不能替换的O使用*来做一个标记
 * 
 * 本题是通过stack来完成深度优先遍历的，使用BFS或者递归去做
 * 是同样的做法
 * 
 * */
public class Solution
{
    public void solve(char[][] board) 
    {
        if(board==null || board.length<=0)
            return;

        int row = board.length;
        int col = board[0].length;
        if(row<=2 || col<=2)
            return;
        boolean [][]visit = new boolean[row][col];

        for(int i=0;i<row;i++)
        {
            for(int j=0;j<col;j++)
            {
                if(board[i][j]=='O')
                {
                    if(i==0||i==row-1 ||j==0||j==col-1)
                        dfs(visit,board,i,j,row,col);
                }
            }
        }

        for(int i=0;i<row;i++)
        {
            for(int j=0;j<col;j++)
            {
                if(board[i][j]=='*')
                    board[i][j]='O';
                else if(board[i][j]=='O')
                    board[i][j]='X';
            }
        }
    }

    private void dfs(boolean [][]visit,char[][] board, int x, int y, int row, int col) 
    {
        board[x][y]='*';
        Stack<Point> stack = new Stack<>();
        stack.push(new Point(x,y));
        visit[x][y]=true;

        while(stack.empty()==false)
        {
            Point top = stack.peek();
            stack.pop();
            if(top.row>0 && board[top.row-1][top.col]=='O' && visit[top.row-1][top.col]==false)
            {
                board[top.row-1][top.col]='*';
                visit[top.row-1][top.col]=true;
                stack.push(new Point(top.row-1, top.col));
            }

            if(top.row+1<row && board[top.row+1][top.col]=='O' && visit[top.row+1][top.col]==false)
            {
                board[top.row+1][top.col]='*';
                visit[top.row+1][top.col]=true;
                stack.push(new Point(top.row+1, top.col));
            }

            if(top.col>0 && board[top.row][top.col-1]=='O' && visit[top.row][top.col-1]==false)
            {
                board[top.row][top.col-1]='*';
                visit[top.row][top.col-1]=true;
                stack.push(new Point(top.row, top.col-1));
            }

            if(top.col+1<col && board[top.row][top.col+1]=='O' && visit[top.row][top.col+1]==false)
            {
                board[top.row][top.col+1]='*';
                visit[top.row][top.col+1]=true;
                stack.push(new Point(top.row, top.col+1));
            }   
        }
    }
}

下面是C++的做法，就是做一个DFS深度优先遍历，不过这道题我们是反其道而行之，通过寻找不符合条件的O，标记为*，然后把剩下的O填充为X即可完成本体的所有要求

代码如下：

#include <iostream>
#include <vector>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <queue>
#include <stack>
#include <string>
#include <climits>
#include <algorithm>
#include <sstream>
#include <functional>
#include <bitset>
#include <numeric>
#include <cmath>
#include <regex>
#include <iomanip>
#include <cstdlib>
#include <ctime>

using namespace std;



class Solution 
{
public:
    void solve(vector<vector<char>>& b) 
    {
        if (b.size() <= 0)
            return;
        int row = b.size(), col = b[0].size();
        vector<vector<bool>> visit(row, vector<bool>(col, false));
        for (int i = 0; i < row; i++)
        {
            for (int j = 0; j < col; j++)
            {
                if (i == 0 || i == row - 1 || j == 0 || j == col - 1)
                    dfs(b,visit, i, j);
            }
        }

        for (int i = 0; i < row; i++)
        {
            for (int j = 0; j < col; j++)
            {
                if (b[i][j] == 'O')
                    b[i][j] = 'X';
                else if(b[i][j] == '*')
                    b[i][j] = 'O';
            }
        }
    }

    void dfs(vector<vector<char>>& b, vector<vector<bool>>& visit, int x, int y)
    {
        int row = b.size(), col = b[0].size();
        if (x < 0 || x >= row || y < 0 || y >= col || visit[x][y] == true || b[x][y] != 'O')
            return;
        else
        {
            visit[x][y] = true;
            b[x][y] = '*';
            dfs(b, visit, x - 1, y);
            dfs(b, visit, x + 1, y);
            dfs(b, visit, x, y - 1);
            dfs(b, visit, x, y + 1);
        }
    }
};