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

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

难度中等539收藏分享切换为英文接收动态反馈

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

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

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

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

示例 1：

输入: heights = [[1,2,2,3,5],[3,2,3,4,4],[2,4,5,3,1],[6,7,1,4,5],[5,1,1,2,4]]
输出: [[0,4],[1,3],[1,4],[2,2],[3,0],[3,1],[4,0]]

示例 2：

输入: heights = [[2,1],[1,2]]
输出: [[0,0],[0,1],[1,0],[1,1]]

提示：

• m == heights.length
• n == heights[r].length
• 1 <= m, n <= 200
• 0 <= heights[r][c] <= 105

 1.解题思路

雨水的流动方向是从高到低，从矩阵的边界开始反向搜索寻找雨水流向边界的单元格，反向搜索时，每次只能移动到高度相同或更大的单元格。

由于矩阵的左边界和上边界是太平洋，矩阵的右边界和下边界是大西洋，因此从矩阵的左边界和上边界开始反向搜索即可找到雨水流向太平洋的单元格，从矩阵的右边界和下边界开始反向搜索即可找到雨水流向大西洋的单元格。

使用深度优先搜索实现反向搜索，搜索过程中需要记录每个单元格是否可以从太平洋反向到达以及是否可以从大西洋反向到达。反向搜索结束之后，遍历每个网格，如果一个网格既可以从太平洋反向到达也可以从大西洋反向到达，则该网格满足太平洋和大西洋都可以到达，将该网格添加到答案中。

2.代码实现

class Solution {
public:
vector<vector<int>> sum=vector<vector<int>>(200,vector<int>(200,0));
vector<vector<int>> sun=vector<vector<int>>(200,vector<int>(200,0));
vector<vector<int>> s;
void dfs1(vector<vector<int>>& heights,int i,int j){
    if(i==heights.size()||j==heights[0].size()){
        return;
    }
    if(sum[i][j]==0){
        sum[i][j]=1;
    }else{
        return;
    }
    
    if(i<heights.size()-1&&heights[i+1][j]>=heights[i][j]){
        dfs1(heights,i+1,j);
    }
    if(j<heights[0].size()-1&&heights[i][j+1]>=heights[i][j]){
        dfs1(heights,i,j+1);
    }
    if(j>0&&sum[i][j-1]==0&&heights[i][j-1]>=heights[i][j]){
        dfs1(heights,i,j-1);
    }
    if(i>0&&sum[i-1][j]==0&&heights[i-1][j]>=heights[i][j]){
        dfs1(heights,i-1,j);
    }
    return;
}
void dfs2(vector<vector<int>>& heights,int i,int j){
    if(i<0||j<0){
        return;
    }
    if(sun[i][j]==0){
        sun[i][j]=1;
    }else{
        return;
    }
    if(i>0&&heights[i-1][j]>=heights[i][j]){
        dfs2(heights,i-1,j);
    }
    if(j>0&&heights[i][j-1]>=heights[i][j]){
        dfs2(heights,i,j-1);
    }
    if(j<heights[0].size()-1&&sun[i][j+1]==0&&heights[i][j+1]>=heights[i][j]){
        dfs2(heights,i,j+1);
    }
    if(i<heights.size()-1&&sun[i+1][j]==0&&heights[i+1][j]>=heights[i][j]){
        dfs2(heights,i+1,j);
    }
    return;
}
    vector<vector<int>> pacificAtlantic(vector<vector<int>>& heights) {
        for(int i=0;i<heights.size();i++){
            dfs1(heights,i,0);
        }
        for(int j=0;j<heights[0].size();j++){
            dfs1(heights,0,j);
        }
        for(int j=heights[0].size()-1;j>=0;j--){
            dfs2(heights,heights.size()-1,j);
        }
        for(int i=heights.size()-1;i>=0;i--){
            dfs2(heights,i,heights[0].size()-1);
        }
        for(int i=0;i<heights.size();i++){
            for(int j=0;j<heights[0].size();j++){
                if(sum[i][j]==1&&sun[i][j]==1){
                    s.push_back({i,j});
                }
            }
        }
        return s;
    }
};

3.经验总结

3.1  逆向思维，可以从边界开始dfs,不需要判断每一个元素是否满足条件，大大提高了效率和精准度。

3.2  vector<vector<int>> sum=vector<vector<int>>(200,vector<int>(200,0));外部赋值法定义防止歧义。

3.3  s.push_back({i,j});定义好的二位向量直接每次添加两个元素变成n*2的数组。