[leetcode] Surrounded Regions

原题链接：https://leetcode.com/problems/surrounded-regions/

解题思路：

1、本题考查了对数据结构的理解，数据结构中由两种字符组成，题目将输入的数据结构定位vector向量类型，实际上也可以是字符数组，区别只是数据的表现形式不同而已。

2、理解题目被包围的含义，是指上、下、左、右，如果都有‘X’字符，则表明‘O’字符被包围（斜方向的字符不考虑）。

3、利用BFS算法，从数据结构的边缘开始遍历，如果是‘O’，则对该字符进行标定，如替换为字符‘E’，再探索该字符的四个方向，为了减少if判断分支的个数，定义二维数组[2][4]，分别对应四个方向向量，最后，遍历整个数据，遇到字符'O'的，替换为‘X’，遇到‘E’的，替换为‘O’。

二维数组定义方法：

（1）代码中变量含义如图所示；

（2）对于（i, j）处的字符，右、左、上、下位置，即为（i+1, j+0）、（i-1, j+0）、（i+0, j+1）、（i+0, j-1），由此可以将二维数组定义为axis[2][4] = {{1, -1, 0, 0}, {0, 0, 1, -1}}

C++代码：

class Solution {
public:
    void solve(vector<vector<char>>& board) {
        int horSize = board.size();
        if(horSize == 0)
            return ;
        int innSize = board[0].size();
        
        for(int i = 0; i < horSize; i++)
        {
            if(board[i][0] == 'O')
            {
                board[i][0] = 'E';
                process(i,0,board);
            }
            
            if(board[i][innSize-1] == 'O')
            {
                board[i][innSize-1] = 'E';
                process(i,innSize-1, board);
            }
        }
        
        for(int j = 0; j < innSize; j++)
        {
            if(board[0][j] == 'O')
            {
                board[0][j] = 'E';
                process(0,j,board);
            }
            
            if(board[horSize-1][j] == 'O')
            {
                board[horSize-1][j] = 'E';
                process(horSize-1,j, board);
            }
        }
        
        for(int i = 0; i<horSize; i++)
        {
            for(int j = 0; j < innSize; j++)
            {
                if(board[i][j] == 'O')
                    board[i][j] = 'X';
                if(board[i][j] == 'E')
                    board[i][j] = 'O';
                
            }
        }
        
    }
    
    void process(int i, int j, vector<vector<char>>& board)
    {
        int horSize = board.size();
        int innSize = board[0].size();
        
        pair<int, int> ele(i,j);
        pair<int, int> tmp;
        queue<pair<int,int>> Qu;
        Qu.push(ele);
        int hor,ver;
        int axis[2][4] = {{1,-1,0,0},{0,0,1,-1}};
        int dectorHor,dectorVer;
        
        while(!Qu.empty())
        {
            
            tmp = Qu.front();
            Qu.pop();
            
            hor = tmp.first;
            ver = tmp.second;
            for(int j = 0; j < 4; j++)
            {
                dectorHor = hor + axis[0][j];
                dectorVer = ver + axis[1][j];
                if((0 <= dectorHor) && (dectorHor < horSize-1) && (0 <= dectorVer) && (dectorVer < innSize-1) && (board[dectorHor][dectorVer] == 'O'))
                {
                    board[dectorHor][dectorVer] = 'E';
                    Qu.push(make_pair(dectorHor,dectorVer));
                }
                
            }
        }
    }
};

由于平时工作使用Python比较多，process函数中的if 分支判断，直接写成了连续的关系运算符比较。程序运行后，无输出任何结果，第一反应是怀疑process函数中修改的代码有问题了，但想不出来是什么原因，所以，只好在VS上加断点一步步调试，最终才找到问题原因。~简直是不容易啊，不过，也更深入的理解了C++的关系运算符和逻辑运算符的使用~

效率：

PS：在探索四个方向上，使用if分支判断时，代码运行时间更长，结果显示：Your runtime beats 38.9% of cpp submissions.