算法|图论 1 广度深度-CSDN博客

本文链接：https://blog.csdn.net/m0_47893709/article/details/132895823

LeetCode 695- 岛屿的最大面积

题目描述：给你一个有 n 个节点的 有向无环图（DAG），请你找出所有从节点 0 到节点 n-1 的路径并输出（不要求按特定顺序）

graph[i] 是一个从节点 i 可以访问的所有节点的列表（即从节点 i 到节点 graph[i][j]存在一条有向边）。

解题思路

首先确定递归函数的参数，返回值。本题要路径，我们直接设置两个全局变量result和path，这样可以不用写太多参数传递。返回值就是void，参数需要图和一个start。start来标记我们当前走到了哪个节点，下次从这个节点开始走的。
确定终止条件，本题是到特定点的路径，所以path的最后一个数值为特定节点就终止。即start == graph.size()-1

单层处理逻辑，每次将当前节点中能通向的路径都走一遍，也就是将其全部都递归一遍。

class Solution {
public:
    vector<int> path;
    vector<vector<int>> result;
    void traversal(vector<vector<int>>& graph,int start){
        if(start == graph.size()-1){
            result.push_back(path);
            //return ;
        }
        for(int i=0;i<graph[start].size();i++){
            path.push_back(graph[start][i]);
            traversal(graph,graph[start][i]);
            path.pop_back();
        }
    }
    vector<vector<int>> allPathsSourceTarget(vector<vector<int>>& graph) {
        path.push_back(0);
        traversal(graph,0);
        return result;
    }
};

总结：

递归的应用

LeetCode 200- 岛屿数量

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

题目描述：给你一个由 '1'（陆地）和 '0'（水）组成的的二维网格，请你计算网格中岛屿的数量。

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

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

解题思路

思路一（深度优先遍历）：

首先确定递归函数的参数，返回值。本题不需要这些。
确定终止条件，本题按我们的逻辑，先进入循环再判断是否应该终止，那么终止条件就是：当超出网格范围就终止。

单层处理逻辑，每次我们将当前节点的岛屿的值设置为0，模拟为被淹没，并且去淹没当前节点的上下左右相邻的节点。为1的节点为陆地状态。


class Solution {
public:
    int numIslands(vector<vector<char>>& grid) {
        int islandNum = 0;
        for (int i = 0; i < grid.size(); i++) {
            for (int j = 0; j < grid[0].size(); j++) {
                //如果是陆地，那就进行深度优先遍历，不断淹没陆地
                if (grid[i][j] == '1') {
                    dfs(grid, i, j);
                    islandNum++;
                }
            }
        }
        return islandNum;
    }
public:
    void dfs(vector<vector<char>>& grid, int i, int j) {
        //这里是先进递归，后判断是否符合条件，不符合直接return，符合才会向更深处递归。
        if (i < 0 || j < 0  || i >= grid.size() || j >= grid[0].size() ||  grid[i][j] != '1') return;
        grid[i][j] = '0';
        dfs(grid, i + 1, j);
        dfs(grid, i - 1, j);
        dfs(grid, i, j + 1);
        dfs(grid, i, j - 1);
    }
};

思路二（广度优先遍历）：

用队列模拟广度优先，首先入队第一个遇到的陆地，然后遍历其上下左右的空间，是陆地就入队且淹没，非陆地就不操作，不断进行，直到全部变为海洋为止。

class Solution {
public:
    int dir[4][2] = {0,1,1,0,-1,0,0,-1};//定义四个方向的走向，这个4x2的矩阵就是代表4个方向
    int numIslands(vector<vector<char>>& grid) {
        int res = 0;
        int n = grid.size(),m = grid[0].size();
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                if(grid[i][j] == '1'){//当遇到陆地时，进行广度优先遍历
                    bfs(grid,i,j);//广度优先结束后，说明刚刚淹没一片陆地，res++，
                    res ++;		  //若下次还有陆地要淹，则res会继续++
                } 
            }
        }
        return res;
    }
    void bfs(vector<vector<char>> &grid,int x,int y){
        queue<pair<int,int>> que;//队列模拟广度优先，其中存储的是对组，为x，y坐标
        que.push({x,y});//首先压入传进来的岛屿的位置
        grid[x][y] = '0';//将其淹没
        while(!que.empty()){//若队列不为空，则一直循环
            pair<int,int> cur = que.front();//取出头部的陆地坐标
            que.pop();
            int curx = cur.first;//赋值给当前x，y坐标
            int cury = cur.second;
            //对四个方向进行遍历，也就是对当前陆地的一周进行遍历，如果有陆地，那就入队。
            for(int i=0;i<4;i++){
                int nextx = curx + dir[i][0];
                int nexty = cury + dir[i][1];
                //如果当前走的一步没有越界，且是陆地，则将其入队，然后淹没。
                if(nextx < 0 || nexty < 0 || nextx >= grid.size() || nexty >= grid[0].size() ||grid[nextx][nexty] != '1') continue;
                    que.push({nextx,nexty});
                    grid[nextx][nexty] = '0';
            }
        }
    }
};

总结：