LeetCode 959. 由斜杠划分区域--放大图像+BFS搜索

959. 由斜杠划分区域

在由 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 <= grid.length == grid[0].length <= 30
grid[i][j] 是 '/'、'\'、或 ' '。

题解

比较简单的思路，就是直接把图像放大，比如‘/’放大就是
001
010
100
同理‘\’放大就是
100
010
001
那么就会构成一个比较大的图像，我们对这个图像进行BFS搜索，就可以很方便的知道有多少个以0构成的不同区域。

AC代码

class Solution {
public:
    struct Node
    {
        int x,y;
    };
    queue<Node>q;
    bool mp[310][310];
    int xx[4]={0,0,1,-1};
    int yy[4]={1,-1,0,0};
    bool vis[310][310];
    int n;
    void bfs(int X,int Y)
    {
        while(!q.empty())q.pop();
        Node t;
        t.x=X,t.y=Y;
        q.push(t);
        while(!q.empty())
        {
            t=q.front();
            q.pop();
            for(int i=0;i<4;i++)
            {
                Node w;
                w.x=t.x+xx[i];
                w.y=t.y+yy[i];
                if(w.x<0||w.x>=3*n||w.y<0||w.y>=3*n)continue;
                if(vis[w.x][w.y]==false&&mp[w.x][w.y]==0)
                {
                    vis[w.x][w.y]=true;
                    q.push(w);
                }
            }
        }
    }
    int regionsBySlashes(vector<string>& grid) 
    {
        memset(mp,0,sizeof(mp));
        memset(vis,0,sizeof(vis));
        n=grid.size();
        cout<<n<<endl;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                if(grid[i][j]=='\\')
                {
                    mp[3*i][3*j]=1;
                    mp[3*i+1][3*j+1]=1;
                    mp[3*i+2][3*j+2]=1;
                }
                else if(grid[i][j]=='/')
                {
                    mp[3*i][3*j+2]=1;
                    mp[3*i+1][3*j+1]=1;
                    mp[3*i+2][3*j]=1;
                }
            }
        }
        int ans=0;
        for(int i=0;i<3*n;i++)
        {
            for(int j=0;j<3*n;j++)
            {
                if(mp[i][j]==0&&vis[i][j]==false)
                {
                    ans++;
                    bfs(i,j);
                }
            }
        }
        return ans;
    }
};