LeetCode 417. Pacific Atlantic Water Flow

原题链接在这里：https://leetcode.com/problems/pacific-atlantic-water-flow/

题目：

Given an m x n matrix of non-negative integers representing the height of each unit cell in a continent, the "Pacific ocean" touches the left and top edges of the matrix and the "Atlantic ocean" touches the right and bottom edges.

Water can only flow in four directions (up, down, left, or right) from a cell to another one with height equal or lower.

Find the list of grid coordinates where water can flow to both the Pacific and Atlantic ocean.

Note:

1. The order of returned grid coordinates does not matter.
2. Both m and n are less than 150.

Example:

Given the following 5x5 matrix:

  Pacific ~   ~   ~   ~   ~ 
       ~  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  *
          *   *   *   *   * Atlantic

Return:

[[0, 4], [1, 3], [1, 4], [2, 2], [3, 0], [3, 1], [4, 0]] (positions with parentheses in above matrix).

题解：

能流淌到左边界 和 上边界的就是能流到Pacific. 那么反过来左边界 和 上边界的点反过来, 往高走 能到达的点就都是能流到Pacific的点.

从左边界和上边界所有点BFS 能visit到的点都是能流到Pacific的点.

同理, 从右边界和下边界所有点BFS能visit道德点都是能留到Atlantic的点. 若有交集 就是 能流到both Pacific and Atlantic的点.

Time Complexity: O(m*n). m = matrix.length. n = matrix[0].length.

Space: O(m*n).

AC Java:

class Solution {
    public List<int[]> pacificAtlantic(int[][] matrix) {
        List<int []> res = new ArrayList<int []>();
        if(matrix == null || matrix.length == 0|| matrix[0].length == 0){
            return res;
        }
        
        int m = matrix.length;
        int n = matrix[0].length;
        int [][] dirs = {{0, -1}, {0, 1}, {-1, 0}, {1, 0}};
        
        // 左上BFS
        boolean [][] visitedUpLeft = new boolean[m][n];
        LinkedList<int []> que = new LinkedList<int []>();
        for(int i = 0; i<m; i++){
            if(!visitedUpLeft[i][0]){
                visitedUpLeft[i][0] = true;
                que.add(new int[]{i, 0});
            }
        }
        
        for(int j = 0; j<n; j++){
            if(!visitedUpLeft[0][j]){
                visitedUpLeft[0][j] = true;
                que.add(new int[]{0, j});
            }
        }
        
        while(!que.isEmpty()){
            int [] cur = que.poll();
            for(int [] dir : dirs){
                int x = cur[0] + dir[0];
                int y = cur[1] + dir[1];
                if(x<0 || x>=m || y<0 || y>=n || visitedUpLeft[x][y] || matrix[x][y]<matrix[cur[0]][cur[1]]){
                    continue;
                }
                
                visitedUpLeft[x][y] = true;
                que.add(new int[]{x, y});
            }
        }
        
        // 右下BFS
        boolean [][] visitedLowRight = new boolean[m][n];
        for(int i = 0; i<m; i++){
            if(!visitedLowRight[i][n-1]){
                visitedLowRight[i][n-1] = true;
                que.add(new int[]{i, n-1});
            }
        }
        
        for(int j = 0; j<n; j++){
            if(!visitedLowRight[m-1][j]){
                visitedLowRight[m-1][j] = true;
                que.add(new int[]{m-1, j});
            }
        }
        
        while(!que.isEmpty()){
            int [] cur = que.poll();
            if(visitedUpLeft[cur[0]][cur[1]]){
                res.add(cur);
            }
            
            for(int [] dir : dirs){
                int x = cur[0] + dir[0];
                int y = cur[1] + dir[1];
                if(x<0 || x>=m || y<0 || y>=n || visitedLowRight[x][y] || matrix[x][y]<matrix[cur[0]][cur[1]]){
                    continue;
                }
                
                visitedLowRight[x][y] = true;
                que.add(new int[]{x, y});
            }
        }
        
        return res;
    }
}