【leetcode】图---中等（1）841. 钥匙和房间_BFS有向图（2）**959. 由斜杠划分区域_建模_并查集（3）990. 等式方程的可满足性_建模

本文链接：https://blog.csdn.net/LanXinYue98/article/details/107604350

这篇博客通过LeetCode的841和959题，介绍了如何使用并查集解决房间解锁问题和由斜杠划分区域的问题，通过实例解析并查集的应用和建模过程，展示了解题思路和C++实现的性能优化。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

841、有 N 个房间，开始时你位于 0 号房间。每个房间有不同的号码：0，1，2，...，N-1，并且房间里可能有一些钥匙能使你进入下一个房间。

在形式上，对于每个房间 i 都有一个钥匙列表 rooms[i]，每个钥匙 rooms[i][j] 由 [0,1，...，N-1] 中的一个整数表示，其中 N = rooms.length。钥匙 rooms[i][j] = v 可以打开编号为 v 的房间。

最初，除 0 号房间外的其余所有房间都被锁住。

你可以自由地在房间之间来回走动。

如果能进入每个房间返回 true，否则返回 false。

示例 1：

输入: [[1],[2],[3],[]]
输出: true
解释:
我们从 0 号房间开始，拿到钥匙 1。
之后我们去 1 号房间，拿到钥匙 2。
然后我们去 2 号房间，拿到钥匙 3。
最后我们去了 3 号房间。
由于我们能够进入每个房间，我们返回 true。

示例 2：

输入：[[1,3],[3,0,1],[2],[0]]
输出：false
解释：我们不能进入 2 号房间。

提示：

   1 <= rooms.length <= 1000
   0 <= rooms[i].length <= 1000
   所有房间中的钥匙数量总计不超过 3000。

// BFS, 有向图
class Solution {
public:
    bool canVisitAllRooms(vector<vector<int>>& rooms) {
        int n = rooms.size();
        vector<bool> mark(n, false);
        queue<int> q;
        q.push(0); mark[0] = true;
        int cnt = 1;
        while(!q.empty()){
            int cur = q.front();
            q.pop();
            for(auto &i:rooms[cur]){
                if(!mark[i]){
                    q.push(i); mark[i] = true;
                    cnt++;
                }
            }
        }
        if(cnt == n) return true;
        else return false;
    }
};

结果：

执行用时：16 ms, 在所有 C++ 提交中击败了87.48% 的用户

内存消耗：9.7 MB, 在所有 C++ 提交中击败了100.00% 的用户

图像建模：将不熟悉的转为，并查集找连通区域！

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

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

返回区域的数目。

示例 3：

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

https://leetcode-cn.com/problems/regions-cut-by-slashes/solution/tu-jie-suan-fa-san-chong-xiang-xi-jie-fa-by-godwei/

（1）并查集思想。

初始，四周一圈的格点连通（红色线），而内部格点孤立，只有一个区域。
逐格子添加斜杠。首先添加绿色斜杠，连接 0 和 5 格点，此时两个点不在一个连通块，没有产生区域。
然后添加蓝色斜杠，连接 2 和 5 格点，两个点在同一个连通块里，产生了一个新的区域（灰色部分）。
遍历所有斜杠。

先确定左上角p = (n + 1) * i + j，再根据‘/’ 还是‘\\’ , 确定v1,v2,找二者所在集合，若同集合，则分割数加一。

// 图像建模，并查集
class Solution {
public:
    vector<int> vec;
    int findRoot(int x){
        if(vec[x] == -1) return x;
        else{
            int t = findRoot(vec[x]);
            vec[x] = t;
            return t;
        }
    }

    int regionsBySlashes(vector<string>& grid) {
        int n = grid.size();
        vec.resize((n + 1) * (n + 1), -1); // 每个点初始化为 -1
        // 初始化四边为一个集合,根为0
        for(int i = 0; i < n + 1; i++)
            vec[i] = vec[(n + 1) * n + i] = vec[i * (n + 1)] = vec[(n + 1) * (i + 1) - 1] = 0; 
        vec[0] = -1;
        int ans = 1, p, v1, v2;
        for(int i = 0; i < n; i++){
            string str = grid[i];
            for(int j = 0; j < n; j++){
                p = (n + 1) * i + j; // 每个格子左上角
                if(str[j] == '/'){
                    v1 = p + 1;
                    v2 = p + n + 1;
                }else if(str[j] == '\\'){
                    v1 = p;
                    v2 = p + n + 1 + 1;
                }else continue;
                v1 = findRoot(v1);
                v2 = findRoot(v2);
                if(v1 == v2) ans++;
                else vec[max(v1, v2)] = min(v1, v2);
            }
        }

        return ans;
    }
};

结果：

执行用时：8 ms, 在所有 C++ 提交中击败了94.08% 的用户

内存消耗：9.8 MB, 在所有 C++ 提交中击败了100.00% 的用户

（2）dfs

首先将每个格子划分成 3 x 3 的更小的网格，然后对角线上填充 1 来表示斜杠，其余地方全部填充 0 。
那么问题就转化为了求一个 3N x 3N 的网格上的 0 的连通块一共有几块，用普通的 dfs 搜一遍。

// dfs n*n --> 3n*3n，查0的连通区域数
class Solution {
public:
    vector<vector<int>> vec;
    int n;
    int step[4][2] = {{0,1},{0,-1},{1,0},{-1,0}};
    void dfs(int x, int y){  // 0 1 遍历后，将0变2
        vec[x][y] = 2;
        for(int i = 0; i < 4; i++){          
            int nx = x + step[i][0];
            int ny = y + step[i][1];
            if(nx >= 0 && nx < 3 * n && ny >= 0 && ny < 3 * n && vec[nx][ny] == 0) dfs(nx, ny);    
        }
    }
    int regionsBySlashes(vector<string>& grid) {
        n = grid.size();
        vec.resize(3 * n);
        for(auto &i:vec) i.resize(3 * n, 0);
        // 3n * 3n 网格初始胡
        for(int i = 0; i < n; i++){
            for(int j = 0; j < n; j++){
                if(grid[i][j] == '\\') vec[3*i][3*j] = vec[3*i+1][3*j+1] = vec[3*i+2][3*j+2] = 1;
                else if(grid[i][j] == '/') vec[3*i][3*j+2] = vec[3*i+1][3*j+1] = vec[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(vec[i][j] == 0) ans++, dfs(i, j);
        return ans;
    }
};

结果：

执行用时：32 ms, 在所有 C++ 提交中击败了25.09% 的用户

内存消耗：11.6 MB, 在所有 C++ 提交中击败了100.00% 的用户

990、给定一个由表示变量之间关系的字符串方程组成的数组，每个字符串方程 equations[i] 的长度为 4，并采用两种不同的形式之一："a==b" 或 "a!=b"。在这里，a 和 b 是小写字母（不一定不同），表示单字母变量名。

只有当可以将整数分配给变量名，以便满足所有给定的方程时才返回 true，否则返回 false。

示例 1：

输入：["a==b","b!=a"]
输出：false
解释：如果我们指定，a = 1 且 b = 1，那么可以满足第一个方程，但无法满足第二个方程。没有办法分配变量同时满足这两个方程。

建模，并查集。a!=b式子，保存a,b入数组，用于后续判断是否成立。a==b,调用unite函数，合并两个集合。

在遍历所有等式后，对不等式进行判断，a,b是否属于同一个集合，仅当findRoot(a)==findRoot(b)，结果为false。

// 建模
// 并查集
class Solution {
public:
    vector<int> tree;
    int findRoot(int x){
        if(tree[x] == -1) return x;
        else {
            int t = findRoot(tree[x]);
            tree[x] = t;
            return t;
        }
    }
    void unite(int x, int y){
        x = findRoot(x);
        y = findRoot(y);
        if(x != y) tree[x] = y;
    }

    bool equationsPossible(vector<string>& equations) {
        tree.resize(30, -1);
        vector<pair<int, int>> vec;
        for(auto &str:equations){
            if(str[1] == '!') vec.push_back({str[0] - 'a', str[3] - 'a'});
            else unite(str[0] - 'a', str[3] - 'a');
        }
        for(auto &i:vec){
            int x = findRoot(i.first);
            int y = findRoot(i.second);
            if(x == y) return false;
        }
        return true;
    }
};

结果：

执行用时：4 ms, 在所有 C++ 提交中击败了98.52% 的用户

内存消耗：11.3 MB, 在所有 C++ 提交中击败了50.00% 的用户