LeetCode之被围困的区域

Leetcode中存在被围困区域，或者相连区域的一类题。今天就总结一下，一种方法解决该问题。这种方法就是使用递归实现。

733. 图像渲染
有一幅以二维整数数组表示的图画，每一个整数表示该图画的像素值大小，数值在 0 到 65535 之间。

给你一个坐标 (sr, sc) 表示图像渲染开始的像素值（行 ，列）和一个新的颜色值 newColor，让你重新上色这幅图像。

为了完成上色工作，从初始坐标开始，记录初始坐标的上下左右四个方向上像素值与初始坐标相同的相连像素点，接着再记录这四个方向上符合条件的像素点与他们对应四个方向上像素值与初始坐标相同的相连像素点，……，重复该过程。将所有有记录的像素点的颜色值改为新的颜色值。

最后返回经过上色渲染后的图像。

输入:
image = [[1,1,1],[1,1,0],[1,0,1]]
sr = 1, sc = 1, newColor = 2
输出: [[2,2,2],[2,2,0],[2,0,1]]
解析:
在图像的正中间，(坐标(sr,sc)=(1,1)),
在路径上所有符合条件的像素点的颜色都被更改成2。
注意，右下角的像素没有更改为2，
因为它不是在上下左右四个方向上与初始点相连的像素点。

class Solution {
public:

    void dfs(vector<vector<int>>& board, int x, int y,int k,int newColor) {
        int n=board.size(),m=board[0].size();
        //确定返回条件
        if (x < 0 || x >= n || y < 0 || y >= m || board[x][y] != k) {
            return;
        }
        //替换
        board[x][y] = newColor;
        //向四个方向延伸
        dfs(board, x + 1, y, k, newColor);
        dfs(board, x - 1, y, k, newColor);
        dfs(board, x, y + 1, k, newColor);
        dfs(board, x, y - 1, k, newColor);
    }

    vector<vector<int>> floodFill(vector<vector<int>>& image, int sr, int sc, int newColor) {
        int k=image[sr][sc];
        //这一个判断条件很关键，如果原来和要替换的相同，则不变！！
        if(k!=newColor) dfs(image,sr,sc,k,newColor);

        return image;
    }
};

130. 被围绕的区域
给定一个二维的矩阵，包含 ‘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’，所以可以先找到不被围困的区域，再把围困的区域替换。
本题和上一题不同，上一题是从点向四个方向延伸，本文是从四个边出发，找到相应点再进行延伸，，最终还是点的延伸。。

class Solution {
public:
    int n, m;

    void dfs(vector<vector<char>>& board, int x, int y) {
        if (x < 0 || x >= n || y < 0 || y >= m || board[x][y] != 'O') {
            return;
        }
        //将不被包围的’O'先进行替换
        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) {
        n = board.size();
        if (n == 0) {
            return;
        }
        m = board[0].size();
        for (int i = 0; i < n; i++) {
        //左右两条边上点的延伸
            dfs(board, i, 0);
            dfs(board, i, m - 1);
        }
        for (int i = 1; i < m - 1; i++) {
        //上下两条边上点的延伸
            dfs(board, 0, i);
            dfs(board, n - 1, i);
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (board[i][j] == 'A') {
                    board[i][j] = 'O';
                } else if (board[i][j] == 'O') {
                    board[i][j] = 'X';
                }
            }
        }
    }
};