LeetCode算法题解：417. 太平洋大西洋水流问题

题目

1、题目描述

   有一个 $m\times n$ 的矩形岛屿，与 太平洋 和 大西洋 相邻。 “太平洋” 处于大陆的左边界和上边界，而 “大西洋” 处于大陆的右边界和下边界。
   这个岛被分割成一个由若干方形单元格组成的网格。给定一个 $mxn$ 的整数矩阵 heights， heights[r][c]表示坐标 (r, c)上单元格 高于海平面的高度 。
   岛上雨水较多，如果相邻单元格的高度 小于或等于 当前单元格的高度，雨水可以直接向北、南、东、西流向相邻单元格。水可以从海洋附近的任何单元格流入海洋。
   返回 网格坐标 result 的 2D列表 ，其中 result[i] = [ri, ci]表示雨水可以从单元格 (ri, ci)流向 太平洋和大西洋 。

2、原题链接

417. 太平洋大西洋水流问题

解题报告

1、解题思路

   $(1)$ 从岛屿出发往四个方向走看是否能走到两个洋。
   $(2)$ 反向分析
      $(2.1)$ 从边界向内标记所有地块，标记被哪个洋走过。
      $(2.2)$ 返回所有被两个洋都标记的地块，就是能流向两个洋的地块。

2、解题方法

   BFS；队列；

2、代码详解

class Solution {
public:
    bool Hash[201][201][2];
    void bfs(vector<vector<int>>& heights, int heightsSize, int heightsColSize, int x, int y, int oce){
        int DIR[4][2] = {
            {0,1},
            {1,0},
            {0,-1},
            {-1,0}
        };
        int nx, ny;
        queue<pair<int, int>> qu;
        qu.emplace(x, y);
        Hash[x][y][oce] = true;
        while(!qu.empty()){
            auto [x, y] = qu.front();
            qu.pop();
            for(int i = 0; i < 4; ++i){
                nx = x;
                ny = y;
                nx += DIR[i][0];
                ny += DIR[i][1];
                if(nx < 0 || nx >= heightsSize || ny < 0 || ny >= heightsColSize){
                    nx -= DIR[i][0];
                    ny -= DIR[i][1];
                    continue;
                }
                if(!Hash[nx][ny][oce] && heights[x][y] <= heights[nx][ny]){
                    qu.emplace(nx, ny);
                    Hash[nx][ny][oce] = true;
                }
            }
        }
    }
    vector<vector<int>> pacificAtlantic(vector<vector<int>>& heights) {
        vector<vector<int>> ret;
        vector<int> num;
        memset(Hash, false, sizeof(Hash));
        int i, j;
        int m = heights.size(), n = heights[0].size();
        for (i = 0; i < m; ++i){
            bfs(heights, m, n, i, 0, 1);
            bfs(heights, m, n, i, n - 1, 0);
        }
        for (i = 0; i < n; ++i){
            bfs(heights, m, n, 0, i, 1);
            bfs(heights, m, n, m-1, i, 0);
        }
        for(i = 0; i < m; ++i){
            for(j = 0; j < n; ++j){
                if(Hash[i][j][0] && Hash[i][j][1]){
                    num.push_back(i);
                    num.push_back(j);
                    ret.push_back(num);
                    num.clear();
                }
            }
        }
        return ret;
    }
};

总结

   矩阵找路径问题：可以用广度优先遍历来解决。