417. 太平洋大西洋水流问题

典型的搜索算法，不过这次搜索的目标有两个，到达太平洋和大西洋。需要写两个dfs递归函数。

算法流程

1. 遍历图中所有点，调用深度递归函数。
2. 如果该点既能到达太平洋又能够到达大西洋。那么将这个点加入结果集。
3. 返回结果集合

这里的递归算是深度优先遍历的模板步骤吧。不过这里标记是否访问用了一个小技巧，修改原数组，因为河流高度不能为0，所以将访问过的点记录为-1，表示已经访问。

递归流程

1. 边界判定：判定越界以及是否访问
2. 返回条件：点处于边界
3. 递归工作：搜索高度比目前高度低的邻近节点，调用dfs。有一个点能够到达边界就返回true。
4. 返回结果：如果自己或者四周任意节点能够到达边界，返回true。

算法复杂度

• 时间复杂度：$O(m^2{n}^2)$，非常可怕，$m,n$分别为矩形长和宽，是，需要$mn$次调用递归函数，每个递归都要耗费$O(mn)$时间
• 空间复杂度：$O(mn)$，堆栈递归最大深度规模为图的大小。

// 其实就是求可以从高流到低的流向四方的河流
// 其实就是求可以从高流到低的流向四方的河流
class Solution {
    int[][] matrix;
    // 用来保存行走的方向
    final int[] dir = new int[]{0, 1, 0, -1, 0};

    public List<List<Integer>> pacificAtlantic(int[][] matrix) {
        if(matrix == null || matrix.length == 0)
            return new LinkedList();
        List<List<Integer>> res = new LinkedList();
        this.matrix = matrix;
        // 遍历所有点，调用深度递归
        for(int i = 0; i < matrix.length; i++){
            for(int j = 0; j < matrix[i].length; j++){
                if(dfsP(i, j) && dfsA(i, j)){
                    res.add(Arrays.asList(i, j));
                }
            }
        }
        return res;
    }
    // 判定（x,y）能否到达太平洋
    private boolean dfsP(int x, int y){
        if(!check(x, y))
            return false;
        if(x == 0 || y == 0)
            return true;
        
        int temp = matrix[x][y];
        matrix[x][y] = -1;
        boolean res = false;

        for(int i = 0; i < 4; i++){
            int newX = x + dir[i];
            int newY = y + dir[i + 1];

            if(check(newX, newY) && matrix[newX][newY] <= temp && dfsP(newX, newY)){
                res = true;
                break;
            }
        }

        matrix[x][y] = temp;
        return res;
    }
     // 判定（x,y）能否到达大西洋
    private boolean dfsA(int x, int y){
        if(!check(x, y))
            return false;
        if(x == matrix.length - 1 || y == matrix[0].length - 1)
            return true;
        
        int temp = matrix[x][y];
        matrix[x][y] = -1;
        boolean res = false;
        // 遍历下一个可以到达的点，调用dfs
        for(int i = 0; i < 4; i++){
            int newX = x + dir[i];
            int newY = y + dir[i + 1];
            
            if(check(newX, newY) && matrix[newX][newY] <= temp && dfsA(newX, newY)){
                res = true;
                break;
            }
        }
        matrix[x][y] = temp;
        return res;
    }

    // 判定边界
    private boolean check(int x, int y){
        if(x < 0 || y < 0 || x >= matrix.length || y >= matrix[0].length || matrix[x][y] == -1)
            return false;
        return true;
    }
}

不过这里还有另外一种解法，那就是从边界往里面灌水。以前是当前点出发，判断它是否能够到达某一边界。这里恰好相反，是从边界点出发，逆向推导能够到达边界的点。

算法流程

1. 分别对左右两侧调用太平洋递归函数$reachPacific(x,y)$和大西洋递归函数$reachAtlantic(x,y)$。这两个递归函数会从边界出发，遍历一切它们可以抵达的比他们高的点。并且将遍历过的节点标记为true。
2. 分别对上下两侧调用$reachPacific(x,y)$和$reachAtlantic(x,y)$
3. 遍历图，将同时能够到达太平洋和大西洋的点记录。

递归工作

1. 边界判定：判定越界以及是否访问
2. 返回条件：将当前点标记为访问过
3. 递归工作：搜索高度比目前高度高的邻近节点，递归调用dfs。

算法复杂度

• 时间复杂度：$O(mn)$，看起来有点奇怪，既然对四周的节点都调用了递归函数，也就是调用了$2(m+n)$次，而调用一次递归函数的时间复杂度是$O(mn)$，那么时间复杂度应该是$O(mn(m+n))$。不过这里并不是每个点都会有这么高的递归深度，调用第一个边界节点的时候，它的递归深度就足以把所有边界节点标记为访问了。这样，其他边界节点因为被访问过，就不会进行递归了。
• 空间复杂度：$O(mn)$，堆栈递归最大深度规模为图的大小。

// 其实就是求可以从高流到低的流向四方的河流
class Solution {
    int[][] matrix;
    // 用来保存行走的方向
    final int[] dir = new int[]{0, 1, 0, -1, 0};
    boolean[][] reachA;
    boolean[][] reachP;

    public List<List<Integer>> pacificAtlantic(int[][] matrix) {
        if(matrix == null || matrix.length == 0)
            return new LinkedList();
        List<List<Integer>> res = new LinkedList();
        this.matrix = matrix;
        reachA = new boolean[matrix.length][matrix[0].length];
        reachP = new boolean[matrix.length][matrix[0].length];

        for(int i = 0; i < matrix.length; i++){
            reachPacific(i, 0);
            reachAtlantic(i, matrix[0].length - 1);
        }

        for(int i = 0; i < matrix[0].length; i++){
            reachPacific(0, i);
            reachAtlantic(matrix.length - 1, i);
        }

        for(int i = 0; i < matrix.length; i++){
            for(int j = 0; j < matrix[0].length; j++){
                if(reachA[i][j] && reachP[i][j]){
                    res.add(Arrays.asList(i, j));
                }
            }
        }

        return res;
    }

    private void reachPacific(int x, int y){
        if(!check(x, y) || reachP[x][y])
            return;
        reachP[x][y] = true;
        
        for(int i = 0; i < 4; i++){
            int newX = x + dir[i];
            int newY = y + dir[i + 1];
            
            if(!check(newX, newY))
                continue;
            if(matrix[newX][newY] >= matrix[x][y])
                reachPacific(newX, newY);
        }
    }

    private void reachAtlantic(int x, int y){
        if(!check(x, y) || reachA[x][y])
            return;
        reachA[x][y] = true;
        
        for(int i = 0; i < 4; i++){
            int newX = x + dir[i];
            int newY = y + dir[i + 1];
            if(!check(newX, newY))
                continue;
            if(matrix[newX][newY] >= matrix[x][y])
                reachAtlantic(newX, newY);
        }
    }

    private boolean check(int x, int y){
        if(x < 0 || y < 0 || x > matrix.length - 1 || y > matrix[0].length - 1)
            return false;
        return true;
    }
}