LC841. 钥匙和房间---邻接表---DFS/BFS

题目描述

有 n 个房间，房间按从 0 到 n - 1 编号。最初，除 0 号房间外的其余所有房间都被锁住。你的目标是进入所有的房间。然而，你不能在没有获得钥匙的时候进入锁住的房间。

当你进入一个房间，你可能会在里面找到一套不同的钥匙，每把钥匙上都有对应的房间号，即表示钥匙可以打开的房间。你可以拿上所有钥匙去解锁其他房间。

给你一个数组 rooms 其中 rooms[i] 是你进入 i 号房间可以获得的钥匙集合。如果能进入 所有 房间返回 true，否则返回 false。

示例 1：

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

代码

#include <iostream>
#include <vector>
#include <string>
#include <queue>

using namespace std;

class Solution_DFS {
public:
    // 定义DFS函数
    void dfs(int curRoom, vector<vector<int>>& rooms, vector<bool>& check) {
        // 标记当前房间curRoom为已检查过
        check[curRoom] = true;
        // 遍历从当前房间能进入的所有其他房间nxtRoom
        for (int nxtRoom : rooms[curRoom]) {
            // 如果下一个房间nxtRoom还没有检查过
            if (!check[nxtRoom]) {
                // 对下一个房间nxtRoom进行DFS
                dfs(nxtRoom, rooms, check);
            }
        }
    }

    bool canVisitAllRooms(vector<vector<int>>& rooms) {
        int n = rooms.size();
        // 构建检查列表
        vector<bool> check(n, false);
        // 从0开始进行深搜
        dfs(0, rooms, check);
        // 检查是否所有房间都进入了
        for (bool c : check) {
            if (!c) {
                return false;
            }
        }
        return true;
    }
};

class Solution_BFS {
public:
    bool canVisitAllRooms(vector<vector<int>>& rooms) {
        int n = rooms.size(); // 获得房间数量
        vector<bool> check(n, false); // 构建检查列表
        queue<int> q; // 构建队列
        q.push(0); // 将起始房间0加入队列
        check[0] = true; // 标记起始房间0为已经检查过

        // 进行BFS
        while (!q.empty()) {
            int curRoom = q.front(); // 弹出队头元素，获得BFS进行到的当前房间curRoom
            q.pop();
            // 遍历所有从当前房间curRoom能够到达的下一个房间nxtRoom
            for (int nxtRoom : rooms[curRoom]) {
                // 下一个房间nxtRoom必须没有检查过
                if (!check[nxtRoom]) {
                    // 将nxtRoom修改为已经检查过，并将nxtRoom加入队列
                    check[nxtRoom] = true;
                    q.push(nxtRoom);
                }
            }
        }

        // 检查是否所有房间都进入了，返回答案
        for (bool c : check) {
            if (!c) {
                return false;
            }
        }
        return true;
    }
};

vector<int> split(string params_str) {
    vector<int> p;
    while (params_str.find(",") != string::npos) {
        int found = params_str.find(",");
        p.push_back(stoi(params_str.substr(0, found)));
        params_str = params_str.substr(found + 1);
    }
    p.push_back(stoi(params_str));
    return p;
}

vector<vector<int>> v;
vector<int> p;
vector<vector<int>> split_2_dimention(string s) {
    s += "  ";//防止最后一个]后面没有元素所导致的越界
    while (s.find("]") != string::npos) {
        int found_right = s.find("]");
        string s1 = s.substr(1, found_right - 1);
        p = split(s1);
        v.push_back(p);
        s = s.substr(found_right + 2);//取第二个vector，这里可能会越界
        p.clear();
    }
    return v;
}

int main() {
    string input_str;
    cin >> input_str;//rooms = [[1],[2],[3],[0]]
    vector<vector<int>> rooms;
    rooms = split_2_dimention(input_str.substr(1, input_str.size() - 2));
    Solution_DFS a;
    cout << boolalpha << a.canVisitAllRooms(rooms) << endl;
}

DFS复杂度分析

时间复杂度：O(n+m)，其中 n 是房间的数量，m 是所有房间中的钥匙数量的总数。

空间复杂度：O(n)，其中 n 是房间的数量。主要为栈空间的开销。

BFS复杂度分析

时间复杂度：O(n+m)，其中 n 是房间的数量，m 是所有房间中的钥匙数量的总数。

空间复杂度：O(n)，其中 n 是房间的数量。主要为队列的开销。