public class Solution {
    int[][] directions = new int[][]{{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
    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 n = matrix.length, m = matrix[0].length;
        boolean[][] pVisited = new boolean[n][m];
        boolean[][] aVisited = new boolean[n][m];
        for (int i=0; i<n; i++) {
            //pacific
            dfs(matrix, i, 0, pVisited);
            //atlatic
            dfs(matrix, i, m-1, aVisited);
        }
        
        for (int j=0; j<m; j++) {
            //pacific
            dfs(matrix, 0, j, pVisited);
            //atlatic
            dfs(matrix, n-1, j, aVisited);
        }
        
        for (int i=0; i<n; i++) {
            for (int j=0; j<m; j++) {
                if (pVisited[i][j] && aVisited[i][j])
                    res.add(new int[]{i, j});
            }
        }
        return res;
    }
    
    public void dfs(int[][] matrix, int i, int j, boolean[][] visited) {
        int n = matrix.length, m = matrix[0].length;
        visited[i][j] = true;
        for (int[] dir : directions) {
            int row = dir[0] + i;
            int col = dir[1] + j;
            if (row>=0 && row<n && col>=0 && col<m && !visited[row][col] && matrix[i][j]<=matrix[row][col]) 
                dfs(matrix, row, col, visited);
        }
    }
}

public class Solution {
    int[][]dir = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};
    public List<int[]> pacificAtlantic(int[][] matrix) {
        List<int[]> res = new LinkedList<>();
        if(matrix == null || matrix.length == 0 || matrix[0].length == 0){
            return res;
        }
        int n = matrix.length, m = matrix[0].length;
        //One visited map for each ocean
        boolean[][] pacific = new boolean[n][m];
        boolean[][] atlantic = new boolean[n][m];
        Queue<int[]> pQueue = new LinkedList<>();
        Queue<int[]> aQueue = new LinkedList<>();
        for(int i=0; i<n; i++){ //Vertical border
            pQueue.offer(new int[]{i, 0});
            aQueue.offer(new int[]{i, m-1});
            pacific[i][0] = true;
            atlantic[i][m-1] = true;
        }
        for(int i=0; i<m; i++){ //Horizontal border
            pQueue.offer(new int[]{0, i});
            aQueue.offer(new int[]{n-1, i});
            pacific[0][i] = true;
            atlantic[n-1][i] = true;
        }
        bfs(matrix, pQueue, pacific);
        bfs(matrix, aQueue, atlantic);
        for(int i=0; i<n; i++){
            for(int j=0; j<m; j++){
                if(pacific[i][j] && atlantic[i][j])
                    res.add(new int[]{i,j});
            }
        }
        return res;
    }
    public void bfs(int[][]matrix, Queue<int[]> queue, boolean[][]visited){
        int n = matrix.length, m = matrix[0].length;
        while(!queue.isEmpty()){
            int[] cur = queue.poll();
            for(int[] d:dir){
                int x = cur[0]+d[0];
                int y = cur[1]+d[1];
                if(x<0 || x>=n || y<0 || y>=m || visited[x][y] || matrix[x][y] < matrix[cur[0]][cur[1]]){
                    continue;
                }
                visited[x][y] = true;
                queue.offer(new int[]{x, y});
            } 
        }
    }
}