力扣每日一题2022-04-27中等题：太平洋大西洋水流问题

---

题目描述

太平洋大西洋水流问题

---

思路

DFS

根据题意，要同时能流向太平洋和大西洋，雨水只能从高留到低，所以可以从一个单元格开始，通过深度优先搜索模拟雨水的流动，就可以判断雨水能否从该单元格流向海洋。
但是每个单元格作为起点开始模拟的话，需要重复遍历单元格，导致时间复杂度较高。
为了降低时间复杂度，可以从矩阵的边界反向搜索寻找雨水能流到边界的单元格，反向搜索时，只找高度相同或更高的单元格。从左上两边界开始遍历的是可以流向太平洋的单元格，从右下两边界开始遍历的是可以流向大西洋的单元格。所以使用深度优先搜索反向搜索，搜索过程中记录每个单元格是否可以从太平洋反向到达，或者是否可以从大西洋反向到达。反向搜索结束后，遍历所有网格，如果一个网格可以从太平洋反向到达也可以从大西洋反向到达，则该网格可以到达太平洋和大西洋，将坐标加入结果集。

Python实现

class Solution:
    def pacificAtlantic(self, heights: List[List[int]]) -> List[List[int]]:
        m, n = len(heights), len(heights[0])

        def search(points):
            visited = set()
            def dfs(x, y):
                if (x, y) in visited:
                    return
                visited.add((x, y))
                for nx, ny in ((x, y+1), (x, y-1), (x+1, y), (x-1, y)):
                    if 0 <= nx < m and 0 <= ny < n and heights[nx][ny] >= heights[x][y]:
                        dfs(nx, ny)
            for x, y in points:
                dfs(x, y)
            return visited
        
        pacific = [(0, i) for i in range(n)] + [(i, 0) for i in range(1, m)]
        atlantic = [(m-1, i) for i in range(n)] + [(i, n-1) for i in range(m-1)]
        return list(map(list, search(pacific) & search(atlantic)))

Java实现

class Solution {
    static int[][] dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
    int[][] heights;
    int m, n;

    public List<List<Integer>> pacificAtlantic(int[][] heights) {
        this.heights = heights;
        this.m = heights.length;
        this.n = heights[0].length;
        boolean[][] pacific = new boolean[m][n];
        boolean[][] atlantic = new boolean[m][n];
        for (int i = 0; i < m; i++) {
            dfs(i, 0, pacific);
        }
        for (int j = 1; j < n; j++) {
            dfs(0, j, pacific);
        }
        for (int i = 0; i < m; i++) {
            dfs(i, n - 1, atlantic);
        }
        for (int j = 0; j < n - 1; j++) {
            dfs(m - 1, j, atlantic);
        }
        List<List<Integer>> result = new ArrayList<List<Integer>>();
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (pacific[i][j] && atlantic[i][j]) {
                    List<Integer> cell = new ArrayList<Integer>();
                    cell.add(i);
                    cell.add(j);
                    result.add(cell);
                }
            }
        }
        return result;
    }

    public void dfs(int row, int col, boolean[][] ocean) {
        if (ocean[row][col]) {
            return;
        }
        ocean[row][col] = true;
        for (int[] dir : dirs) {
            int newRow = row + dir[0], newCol = col + dir[1];
            if (newRow >= 0 && newRow < m && newCol >= 0 && newCol < n && heights[newRow][newCol] >= heights[row][col]) {
                dfs(newRow, newCol, ocean);
            }
        }
    }
}