[LeetCode] 130. Surrounded Regions 包围区域

 1.DFS  

       这道题让将矩阵中被'X'包围的不接触边框的'O组成的连通份量用'X'替换，显然能够使用DFS的方法解答，直接的想法是，遍历二维矩阵，遇到‘O’使用DFS判断由'O'组成的连通份量有没有接触到边框，

没有接触到DFS返回true，并将'O组成的连通份量用'X'替换；不然返回false，不替换。在使用DFS遍历'O'连通份量的过程当中使用数组保存遍历路径。此种方法容易出错。代码以下：

/*
 * @Descripttion: 
 * @version: 
 * @Author: wangxf
 * @Date: 2020-04-14 20:38:54
 * @LastEditors: Do not edit
 * @LastEditTime: 2020-04-20 23:19:05
 */
/*
 * @lc app=leetcode.cn id=130 lang=cpp
 *
 * [130] 被围绕的区域
 */

// @lc code=start
#include<bits/stdc++.h>
using namespace std;
class Solution {
public:
    void solve(vector<vector<char>>& board) {
         if(board.empty()||board.size()<1) return;
         vector<vector<char>> flag =  board;
         raw_len = board.size();
         col_len = board[0].size();
         for(int i = 0;i<raw_len;++i)
            for(int j = 0;j<col_len;++j)
            {
                flag[i][j]='N';//未访问
            }
         for(int i = 0;i<raw_len;++i)
            for(int j = 0;j<col_len;++j)
            {
                if(board[i][j]=='O'){
                    vector<pair<int,int> > pathVec;
                    pathVec.clear();
                    bool isModify = dfs(board,flag,pathVec,i,j);
                    if(isModify)
                    {
                        vector<pair<int,int> >::iterator ite = pathVec.begin();
                        for(;ite!=pathVec.end();++ite){
                            int x = ite->first;
                            int y = ite->second;
                            board[x][y]='X';
                        }
                    }
                }
            }
        return;
    }
    bool dfs(vector<vector<char> >& board,vector<vector<char> >& flag,
             vector<pair<int,int> >& pathVec,int i,int j)
    {
         if(!(i>=0&&i<raw_len&&j>=0&&j<col_len)){//放在函数最开始，避免数组下标越界
             return false;
         } 
         bool status = true;
         if(board[i][j]=='O'&&flag[i][j]=='N'){//没有被访问过的‘O’节点
            flag[i][j]='Y';//标记访问
            pair<int,int> point = make_pair(i,j);
            pathVec.push_back(point);//记录一次dfs过程当中的路径
            if(i==0||j==0){//遇到边界，不填充
                status=false;
            }
            int dx[4]={0,0,-1,1};
            int dy[4]={1,-1,0,0};
            for(int k=0;k<4;++k){
                status=(status&dfs(board,flag,pathVec,i+dx[k],j+dy[k]));
            }
            return status;
         }
        return status; 
    }
private:
    int raw_len;
    int col_len;
};
// @lc code=end

     另外一种比较巧妙一点的DFS方法是扫矩阵的四条边，若是有O，则用 DFS 遍历，将全部连着的O都变成另外一个字符，好比 $，这样剩下的O都是被包围的，而后将这些O变成X，把$变回O就好了。代码以下：

class Solution {
public:
    void solve(vector<vector<char> >& board) {
        for (int i = 0; i < board.size(); ++i) {
            for (int j = 0; j < board[i].size(); ++j) {
                if ((i == 0 || i == board.size() - 1 || j == 0 || j == board[i].size() - 1) && board[i][j] == 'O')
                    solveDFS(board, i, j);
            }
        }
        for (int i = 0; i < board.size(); ++i) {
            for (int j = 0; j < board[i].size(); ++j) {
                if (board[i][j] == 'O') board[i][j] = 'X';
                if (board[i][j] == '$') board[i][j] = 'O';
            }
        }
    }
    void solveDFS(vector<vector<char> > &board, int i, int j) {
        if (board[i][j] == 'O') {
            board[i][j] = '$';
            if (i > 0 && board[i - 1][j] == 'O') 
                solveDFS(board, i - 1, j);
            if (j < board[i].size() - 1 && board[i][j + 1] == 'O') 
                solveDFS(board, i, j + 1);
            if (i < board.size() - 1 && board[i + 1][j] == 'O') 
                solveDFS(board, i + 1, j);
            if (j > 0 && board[i][j - 1] == 'O') 
                solveDFS(board, i, j - 1);
        }
    }
};

2.并查集