太平洋大西洋水流问题

一起养成写作习惯！这是我参与「掘金日新计划 · 4 月更文挑战」的第26天，点击查看活动详情。

题目描述

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

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

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

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

示例

输入: 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]]

输入: 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] <= 10^5

DFS

根据提示结合示例中的图来看，我们需要找到的是岛屿中的若干最高点，在这些点落下的雨水只能向四周扩散开。

如果单纯的一个个点进行比较，会耗费较多的时间。如果可以从岛屿的四边，反向推演，想着中间的高点汇聚，这样也可以求得我们所需的结果，同时还减少了一些不必要的判断。

class Solution {
    List<List<Integer>> ans = new ArrayList<>();
    int[][] map;
    boolean[][] ocean, a, p;
    public List<List<Integer>> pacificAtlantic(int[][] heights) {
        a = new boolean[heights.length][heights[0].length];
        p = new boolean[heights.length][heights[0].length];
        map = heights; ocean = a;
        for (int i = 0; i < heights.length; ++i){
            // 第0列
            dfs(i, 0);
        }     
        for (int i = 0; i < heights[0].length; ++i){
            // 第0行
            dfs(0, i); 
        }
        ocean = p;
        for (int i = 0; i < heights.length; ++i){
            // 第n-1列
            dfs(i, heights[0].length - 1); 
        }
        for (int i = 0; i < heights[0].length; ++i){
            // 第m行  
            dfs(heights.length - 1, i); 
        }
        return ans;
    }

    public void dfs(int i, int j) { 
        if (ocean[i][j]){
            return;
        }
        // 遍历过的位置打上标记
        ocean[i][j] = true;
        if (a[i][j] && p[i][j]){
            // 最高点，加入结果集
            ans.add(Arrays.asList(i, j));
        }
        // 向下延伸
        if (i + 1 < map.length && map[i][j] <= map[i + 1][j]){
             dfs(i + 1, j);
        }
        // 向上延伸
        if (i - 1 >= 0 && map[i][j] <= map[i - 1][j]){
            dfs(i - 1, j);
        }
        // 向右延伸
        if (j + 1 < map[0].length && map[i][j] <= map[i][j + 1]){
            dfs(i, j + 1);
        }
        // 向左延伸
        if (j - 1 >= 0 && map[i][j] <= map[i][j - 1]){
            dfs(i, j - 1);
        }
    }
}