Leetcode959. Regions Cut By Slashes由斜杠划分区域

在由 1 x 1 方格组成的 N x N 网格 grid 中，每个 1 x 1 方块由 /、\ 或空格构成。这些字符会将方块划分为一些共边的区域。

（请注意，反斜杠字符是转义的，因此 \ 用 "\\" 表示。）。

返回区域的数目。

示例 1：

输入： [   " /",   "/ " ] 输出：2 解释：2x2 网格如下：

示例 2：

输入： [   " /",   " " ] 输出：1 解释：2x2 网格如下：

示例 3：

输入： [   "\\/",   "/\\" ] 输出：4 解释：（回想一下，因为 \ 字符是转义的，所以 "\\/" 表示 \/，而 "/\\" 表示 /\。） 2x2 网格如下：

示例 4：

输入： [   "/\\",   "\\/" ] 输出：5 解释：（回想一下，因为 \ 字符是转义的，所以 "/\\" 表示 /\，而 "\\/" 表示 \/。） 2x2 网格如下：

示例 5：

输入： [   "//",   "/ " ] 输出：3 解释：2x2 网格如下：

提示：

1. 1 <= grid.length == grid[0].length <= 30
2. grid[i][j] 是 '/'、'\'、或 ' '。

思路转换一下，然后再搜索就可以了。

最开始是将大小 * 2，但是在{"//", "/ "};这个案列中就错误了，仔细想想为什么。

然后换成 * 3的就可以了。

class Solution {
public:
    vector<vector<bool> > Map;
    vector<vector<bool> > Visit;
    int dx[4] = {1,-1,0,0};
    int dy[4] = {0,0,1,-1};
    int N;
    int regionsBySlashes(vector<string>& grid)
    {
        N = grid.size();
        Map = vector<vector<bool> >(N * 3, vector<bool>(N * 3, false));
        Visit = vector<vector<bool> >(N * 3, vector<bool>(N * 3, false));
        int cntAns = 0;
        for(int i = 0; i < N; i++)
        {
            for(int j = 0; j < grid[i].size(); j++)
            {
                if(grid[i][j] == '\\')
                {
                    Map[3 * i][3 * j] = true;
                    Map[3 * i + 1][3 * j + 1] = true;
                    Map[3 * i + 2][3 * j + 2] = true;
                }
                else if(grid[i][j] == '/')
                {
                    Map[3 * i][3 * j + 2] = true;
                    Map[3 * i + 1][3 * j + 1] = true;
                    Map[3 * i + 2][3 * j] = true;
                }
            }
        }
        /*
        for(int i = 0; i < 3 * N; i++)
        {
            for(int j = 0; j < 3 * N; j++)
            {
                cout << Map[i][j] << (j == 3 * N - 1? '\n' : ' ');
            }
        }
        //*/
        for(int i = 0; i < 3 * N; i++)
        {
            for(int j = 0; j < 3 * N; j++)
            {
                if(Map[i][j] == false && Visit[i][j] == false)
                {
                    cntAns++;
                    BFS(i , j);
                }
            }
        }
        return cntAns;
    }

    void BFS(int x, int y)
    {
        queue<pair<int, int> > q;
        q.push(make_pair(x, y));
        Visit[x][y] = true;
        while(!q.empty())
        {
            int i = q.front().first;
            int j = q.front().second;
            q.pop();
            for(int k = 0; k < 4; k++)
            {
                int ii = i + dx[k];
                int jj = j + dy[k];
                if(ii < 0 || ii >= 3 * N || jj < 0 || jj >= 3 * N)
                    continue;
                if(Visit[ii][jj] == true || Map[ii][jj] == true)
                    continue;
                Visit[ii][jj] = true;
                q.push(make_pair(ii, jj));
            }
        }
    }
};

方法二：

并查集（未想出，带更新）