算法|图论 3

LeetCode 130- 被围绕的区域

题目链接:力扣(LeetCode)官网 - 全球极客挚爱的技术成长平台

题目描述:给你一个 m x n 的矩阵 board ,由若干字符 'X' 和 'O' ,找到所有被 'X' 围绕的区域,并将这些区域里所有的 'O' 用 'X' 填充。

解题思路(思路一是自己的思路,思路二题解思路,不过用两种遍历方式写出来)

思路一(深度优先遍历):

我的思路:是开辟一个二维数组,存储二元组,来记录那些下标,首先是一个一维数组,每次记录我们当前遍历岛屿的下标,当被环绕的时候压入到二维数组中,否则直接清空。类似将所有岛屿都淹没,然后再看哪些岛屿没被包围再还原成陆地。

  1. 首先确定递归函数的参数,返回值。覆盖那些被环绕的区域,我们直接设置两个全局变量vec(存储所有需要还原的海洋)和tmp(存储当前我们遍历的这片岛屿的下标),flag表示是否被包围,这样可以不用写太多参数传递。返回值就是void,参数需要图和一个x和y来记录当前在哪个岛屿。下次从这个岛屿开始走的。
  2. 确定终止条件,本题按我们的逻辑,先进入循环再判断是否应该终止,那么终止条件就是:当超出网格范围(这里还需要把flag 设置为false,表示没被包围) 或 该岛屿已经是海洋 就终止。
  3. 单层处理逻辑,每次将当前岛屿淹没(这里也就是设置为'X'),然后将其下标压入tmp(为什么有tmp,是因为我们不知道当前的这片岛屿马上是否要恢复,也就是变成'O'所以需要一个临时的,当我们确定要恢复的时候就将其压入到vec中)。
class Solution {
public:
    bool flag = true; //表示是否被环绕(只要相连的岛屿有一个在边界就不是被环绕的),被环绕就不用撤回修改
    vector>> vec;//存所有岛屿下标,其中全都是要变回'O'的
    vector> tmp; //保存当前遍历这片岛屿的下标,一会可能填充。
    void dfs(vector> &grid,int x,int y){
        if(x < 0 || y < 0 || x >= grid.size() || y >= grid[0].size()){
            flag = false;//表示没有被环绕
            return ;
        }
        if(grid[x][y] == 'X') return;
        tmp.push_back({x,y});//压入当前岛屿的下标
        grid[x][y] = 'X';
        dfs(grid,x+1,y);
        dfs(grid,x-1,y);
        dfs(grid,x,y+1);
        dfs(grid,x,y-1);
    }
    void solve(vector>& grid) {
        int m = grid.size(),n = grid[0].size();
        for(int i=0;i

思路二(广度优先遍历):

比较猛的一个思路:本题我们可以看到,只有和边界相连的O不会变,其余的都得变成X,那么我们可以将与边界相连的所有O全部变成一个特定符号如'-',这样,其中所有的'-'都是与边界相连的,马上会再变成'O'。而这个时候图中所有的'O'都是被包围的,全都变为'X'即可。

class Solution {
public:
    int dir[4][2] = {0,1,1,0,-1,0,0,-1};
    void bfs(vector> &grid,int x,int y){
        queue> que;
        que.push({x,y});
        grid[x][y] = '-';//将与边界相连的全部变为'-'
        //广度优先遍历
        while(!que.empty()){
            pair cur = que.front();
            que.pop();
            for(int i=0;i<4;i++){
                int nextx = cur.first + dir[i][0];
                int nexty = cur.second + dir[i][1];
                if(nextx < 0 || nexty < 0 || nextx >= grid.size() || nexty >= grid[0].size() ||grid[nextx][nexty] != 'O') continue;
                que.push({nextx,nexty});
                grid[nextx][nexty] = '-';
            }

        }
    }
    void solve(vector>& grid) {
        int row = grid.size(),col = grid[0].size();
        for(int i=0;i

总结:

  • 深搜和广搜的问题,广搜里面写的那个思路很清奇,还是得多看题目的提示,可以减少一点时间和空间的损耗。

LeetCode 417- 太平洋大西洋水流问题

题目链接:力扣(LeetCode)官网 - 全球极客挚爱的技术成长平台

题目描述:有一个 m × n 的矩形岛屿,与 太平洋大西洋 相邻。 “太平洋” 处于大陆的左边界和上边界,而 “大西洋” 处于大陆的右边界和下边界。

这个岛被分割成一个由若干方形单元格组成的网格。给定一个 m x n 的整数矩阵 heights , heights[r][c] 表示坐标 (r, c) 上单元格 高于海平面的高度

岛上雨水较多,如果相邻单元格的高度 小于或等于 当前单元格的高度,雨水可以直接向北、南、东、西流向相邻单元格。水可以从海洋附近的任何单元格流入海洋。

返回网格坐标 result 的 2D 列表 ,其中 result[i] = [ri, ci] 表示雨水从单元格 (ri, ci) 流动 既可流向太平洋也可流向大西洋

解题思路

首先明确本题题意,意思就是雨水高的地方能往雨水低的地方流,要我们求出能流向两大洋的点坐标。

思路一(深度优先遍历):

这题总体思路就是遍历边界点(也就是能直接流进大洋的点),再逆流遍历,因为雨水往低处流,我们逆流遍历就可以找到所有大于边界的雨水高度的点,这些点就是可以直接流进大洋的点

  1. 首先确定递归函数的参数,返回值。参数我们需要设置一个isvisited来表示这个点能不能走到其中一个大洋中去。还有x,y坐标来表示当前遍历到的点的位置
  2. 确定终止条件,本题按我们的逻辑,先进入循环再判断是否应该终止,那么终止条件就是:当超出网格范围 当前遍历的是海洋 就跳过。不过这里需要注意,这道题目我们这里的逻辑是逆流而上,所以下一次要去的节点的雨水高度 小于 我们当前节点的雨水高度的时候也直接跳过。
  1. 单层处理逻辑,每次进入递归,我们就将访问设置为true,代表可以直接流进大洋。不过在处理遍历的时候有点麻烦,需要注意m和n各表示的是什么,别弄混了。
class Solution {
private:
    int dir[4][2] = {-1, 0, 0, -1, 1, 0, 0, 1}; // 保存四个方向

    // 从低向高遍历,注意这里visited是引用,即可以改变传入的pacific和atlantic的值
    void dfs(vector>& heights, vector>& visited, int x, int y) {
        if (visited[x][y]) return;
        visited[x][y] = true;
        for (int i = 0; i < 4; i++) { // 向四个方向遍历
            int nextx = x + dir[i][0];
            int nexty = y + dir[i][1];
            // 超过边界
            if (nextx < 0 || nextx >= heights.size() || nexty < 0 || nexty >= heights[0].size()) continue;
            // 高度不合适,注意这里是从低向高判断
            if (heights[x][y] > heights[nextx][nexty]) continue;

            dfs (heights, visited, nextx, nexty);
        }
        return;
    }
public:

    vector> pacificAtlantic(vector>& heights) {
        vector> result;
        int n = heights.size();
        int m = heights[0].size(); // 这里不用担心空指针,题目要求说了长宽都大于1

        // 记录从太平洋边出发,可以遍历的节点
        vector> pacific = vector>(n, vector(m, false));

        // 记录从大西洋出发,可以遍历的节点
        vector> atlantic = vector>(n, vector(m, false));

        // 从最上最下行的节点出发,向高处遍历
        for (int i = 0; i < n; i++) {
            dfs (heights, pacific, i, 0); // 遍历最上行,接触太平洋
            dfs (heights, atlantic, i, m - 1); // 遍历最下行,接触大西洋
        }

        // 从最左最右列的节点出发,向高处遍历
        for (int j = 0; j < m; j++) {
            dfs (heights, pacific, 0, j); // 遍历最左列,接触太平洋
            dfs (heights, atlantic, n - 1, j); // 遍历最右列,接触大西洋
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                // 如果这个节点,从太平洋和大西洋出发都遍历过,就是结果
                if (pacific[i][j] && atlantic[i][j]) result.push_back({i, j});
            }
        }
        return result;
    }
};

总结:

  • 逆流而上的操作,主要是根据边界来想到了这个思路。

你可能感兴趣的:(算法,图论,深度优先)