【LittleXi】959. 由斜杠划分区域

题目链接

前情提要

这个题感觉是非常经典的在矩阵上应用并查集寻找连通块的题、

核心思路

将每个块拆分为6个，然后进行连接

解题思路

将每个正方形分为6份（不分为4份的原因是每个小块的index太难算了，尽管6份的情况下index也很难算）
然后根据grid[i][j]的情况分类讨论进行连接
最后统计连通分量的数量就好啦

AC代码

class Solution {
    
    
public:
    int fa[100005];
    void init(int n)
    {
    
    
        fa[n] = n;
    }
    int find(int i)
    {
    
    
        if (fa[i] == i)
            return i;
        fa[i] = find(fa[i]);
        return fa[i];
    }
    void unionn(int x, int y)
    {
    
    
        int fa1 = find(x);
        int fa2 = find(y);
        fa[fa1] = fa2;
    }
    int regionsBySlashes(vector<string>& grid) {
    
    
        int n = grid.size();
        int mm = 3 * n;
        int nn = 2 * n;
        for (int i = 0; i < 10000; i++)
        {
    
    
            init(i);
        }
        //并查集连点
        for (int i = 0; i < n; i++)
        {
    
    
            for (int j = 0; j < n; j++)
            {
    
    
                vector<int> id = {
    
     6 * n * i + 2 * j,6 * n * i + 2 * j + 1,
6 * n * i + 2*n + 2 * j,6 * n * i + 2*n + 2 * j + 1,
6 * n * i + 4 * n + 2 * j,6 * n * i + 4 * n + 2 * j + 1 };
                if (grid[i][j] == ' ')
                {
    
    
                    for (int i = 0; i < 5; i++)
                    {
    
    
                        unionn(id[i], id[i + 1]);
                    }
                }
                if (grid[i][j] == '/')
                {
    
    
                    unionn(id[0], id[1]);
                    unionn(id[0], id[2]);
                    unionn(id[3], id[5]);
                    unionn(id[4], id[5]);

                }
                if (grid[i][j] == '\\')
                {
    
    

                    unionn(id[0], id[1]);
                    unionn(id[1], id[3]);
                    unionn(id[2], id[4]);
                    unionn(id[4], id[5]);
                }
                if (j < n - 1 )
                    unionn(id[3], 6 * n * i + 2*n + 2 * j + 2);      
                if (i < n - 1)
                    unionn(id[5], 6 * n * i + 6 * n + 2 * j + 1);
            }
        }
        unordered_set<int> use;
        for (int i = 0; i < 6 * n * n; i++)
        {
    
    
            use.insert(find(i));
        }
        return use.size();
    }
};