leetcode417- Pacific Atlantic Water Flow- medium

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).

算法：BFS。

找所有可以走到P的：初始化最左边最上面都是可以到P的。然后从每个点开始向外BFS。如果是1.在边界内，2.比之前大，3.原来没标为可以过，就可以标为可行而且推入Q。 最后就得到了所有可以走到P的点。

同理可以找到所有可以走到A的。再遍历一次取交叉即可。

实现：

class Solution {
    public List<int[]> pacificAtlantic(int[][] matrix) {
        List<int[]> result = new ArrayList<>();
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return result;
        }
        
        boolean[][] canP = new boolean[matrix.length][matrix[0].length];
        boolean[][] canA = new boolean[matrix.length][matrix[0].length];
        
        Queue<Integer[]> q = new LinkedList<>();
        for (int i = 0; i < matrix.length; i++) {
            canP[i][0] = true;
            //isVisited[i][0] = true;
            // 确认语法
            Integer[] temp = {i, 0};
            q.offer(temp);
        }
        for (int j = 1; j < matrix[0].length; j++) {
            canP[0][j] = true;
            Integer[] temp = {0,j};
            q.offer(temp);
        }
        bfs(q, canP, matrix);
        
        q.clear();
        for (int i = 0; i < matrix.length; i++) {
            canA[i][matrix[0].length - 1] = true;
            Integer[] temp = {i, matrix[0].length - 1};
            q.offer(temp);
        }
        for (int j = 0; j < matrix[0].length - 1; j++) {
            canA[matrix.length - 1][j] = true;
            Integer[] temp = {matrix.length - 1, j};
            q.offer(temp);
        }
        bfs(q, canA, matrix);
        
        
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[0].length; j++) {
                if (canP[i][j] && canA[i][j]) {
                    int[] temp = {i, j};
                    result.add(temp);
                }
            }
        }
        return result;
    }
    
    private void bfs(Queue<Integer[]> q, boolean[][] canP, int[][] matrix) {
        int[] dx = {-1, 0, 1, 0};
        int[] dy = {0, -1, 0, 1};
        
        while (!q.isEmpty()) {
            Integer[] crt = q.poll();
            for (int i = 0; i < 4; i++) {
                int newX = crt[0] + dx[i];
                int newY = crt[1] + dy[i];
                if (!isInBound(matrix, newX, newY) || canP[newX][newY] || matrix[newX][newY] < matrix[crt[0]][crt[1]]) {
                    continue;
                }
                canP[newX][newY] = true;
                Integer[] temp = {newX, newY};
                q.offer(temp);
            }
        }
    }
    
    private boolean isInBound(int[][] matrix, int x, int y) {
        return x >= 0 && x < matrix.length && y >= 0 && y < matrix[0].length;
    }
}