leetcode 中的图论

岛屿数量(连通块)

https://leetcode.cn/problems/number-of-islands/description/?envType=study-plan-v2&envId=top-100-liked
给你一个由 '1'（陆地）和 '0'（水）组成的的二维网格，请你计算网格中岛屿的数量。

岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。

此外，你可以假设该网格的四条边均被水包围。

示例 1：
输入：grid = [
["1","1","1","1","0"],
["1","1","0","1","0"],
["1","1","0","0","0"],
["0","0","0","0","0"]
]
输出：1

示例 2：
输入：grid = [
["1","1","0","0","0"],
["1","1","0","0","0"],
["0","0","1","0","0"],
["0","0","0","1","1"]
]
输出：3

提示：
m == grid.length
n == grid[i].length
1 <= m, n <= 300
grid[i][j] 的值为 '0' 或 '1'

class Solution {
public:
    int vis[310][310];
    int dx[4]={0,0,1,-1};
    int dy[4]={-1,1,0,0};
    int ans=0,n,m;
    void dfs(vector<vector<char>>& grid,int x,int y,int p){
        vis[x][y]=p;
        for(int i=0;i<4;i++){
            int xx=x+dx[i];
            int yy=y+dy[i];
            if(xx>=0&&xx<n&&yy>=0&&yy<m&&vis[xx][yy]==0&&grid[xx][yy]=='1'){
                dfs(grid,xx,yy,p);
            }
        }
    }
    int numIslands(vector<vector<char>>& grid) {
        n=grid.size();
        m=grid[0].size();
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                if(!vis[i][j]&&grid[i][j]=='1'){
                    ans++;
                    dfs(grid,i,j,ans);
                }
            }
        }
        return ans;
    }
};

钥匙和房间

https://leetcode.cn/problems/keys-and-rooms/description/?envType=study-plan-v2&envId=graph-theory
有\(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。

示例 2：

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

提示：

n == rooms.length
2 <= n <= 1000
0 <= rooms[i].length <= 1000
1 <= sum(rooms[i].length) <= 3000
0 <= rooms[i][j] < n
所有 rooms[i] 的值 互不相同

这个可以是DFS，或者BFS
DFS:

class Solution {
public:
    vector<int> vis;
    int num;
    void dfs(vector<vector<int>> & rooms, int x)
    {
        vis[x] = true;
        num++;
        for(auto& it : rooms[x])
        {
            if(!vis[it])
            {
                dfs(rooms, it);
            }
        }
    }
    bool canVisitAllRooms(vector<vector<int>>& rooms) {
        int n = rooms.size();
        num = 0;
        vis.resize(n);
        dfs(rooms, 0);
        return num == n;
    }
};

BFS:

class Solution {
public:
    
    bool canVisitAllRooms(vector<vector<int>>& rooms) {
        int n=rooms.size();
        int vis[n];
        for(int i=0;i<n;i++){
            vis[i]=0;
        }
        vector<int>edge[n];
        for(int i=0;i<n;i++){
            for(int j=0;j<rooms[i].size();j++){
                edge[i].push_back(rooms[i][j]);
            }
        }
        queue<int>q;
        q.push(0);
        vis[0]=1;
        while(!q.empty()){
            int u=q.front();
            q.pop();
            vis[u]=1;
            for(int i=0;i<rooms[u].size();i++){
                if(!vis[rooms[u][i]]) q.push(rooms[u][i]);
            }
        }
        int flag=1;
        for(int i=0;i<n;i++){
            if(!vis[i]){
                flag=0;
            }
        }
        if(flag){
            return true;
        }
        else{
            return false;
        }
    }
};