417. Pacific Atlantic Water Flow

问题：

给定一个二维数组，代表一块大陆的海拔，

数组左边和上边为太平洋，右边和下边为大西洋，

对于大陆上的每一个点，有水向海拔=<自己的方向流动，求既能流进太平洋，又能流进大西洋的坐标位置。

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

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

　　

解法：BFS，DFS

解法一：BFS

思想：使用两个queue，分别记录：太平洋Pcf_q，大西洋Atl_q

逆着水流，从沿岸开始，向海拔高的地方进行遍历，当有水流过，则记录水流数组Pcf，Atl对应cell为true。否则为false。

BFS遍历整个大陆后，

对比两个水流数组Pcf，Atl

同样的cell中，都为true，则符合题意。

代码参考：

class Solution {
public:
    int m,n;
    void bfs(queue<pair<int,int>>& q, vector<vector<bool>>& visited, vector<vector<int>>& matrix) {
        int dir[5] = {1,0,-1,0,1};
        int cur_i, cur_j, x, y;
        while(!q.empty()) {
            int sz = q.size();
            for(int i=0; i<sz; i++) {
                cur_i = q.front().first;
                cur_j = q.front().second;
                q.pop();
                for(int j=1; j<5; j++) {
                    x = cur_i+dir[j-1];
                    y = cur_j+dir[j];
                    if(x<0 || x>=n || y<0 || y>=m 
                       || visited[x][y] || matrix[x][y]<matrix[cur_i][cur_j]) continue;
                    q.push({x,y});
                    visited[x][y]=true;
                }
            }
        }
        return;
    }
    vector<vector<int>> pacificAtlantic(vector<vector<int>>& matrix) {
        vector<vector<int>> res;
        queue<pair<int,int>> Pcf_q, Atl_q;
        n = matrix.size();
        if(n==0) return res;
        m = matrix[0].size();
        vector<vector<bool>> Pcf(n,vector<bool>(m,false));
        vector<vector<bool>> Atl(Pcf);//visited
        //add board to queue
        for(int i=0; i<n; i++) {
            Pcf_q.push({i,0});//left
            Pcf[i][0] = true;
            Atl_q.push({i,m-1});//right
            Atl[i][m-1] = true;
        }
        for(int j=0; j<m; j++) {
            Pcf_q.push({0,j});//up
            Pcf[0][j] = true;
            Atl_q.push({n-1,j});//bottom
            Atl[n-1][j] = true;
        }
        bfs(Pcf_q, Pcf, matrix);
        bfs(Atl_q, Atl, matrix);
        for(int i=0; i<n; i++) {
            for(int j=0; j<m; j++) {
                if(Pcf[i][j] && Atl[i][j]) res.push_back({i,j});
            }
        }
        return res;
    }
};

解法二：DFS

思想：

逆着水流，从沿岸开始，向海拔高的地方进行遍历，

• 从左边+上边所有边缘点开始，向大陆内部DFS遍历，所遍历过满足条件的cell，都是可以流入Pcf太平洋的。
• 从右边+下边所有边缘点开始，向大陆内部DFS遍历，所遍历过满足条件的cell，都是可以流入Atl大西洋的。

DFS：

• 状态：到当前点（i , j）为止，水流都可流过，到达Pcf或Atl
• 选择：四个方向：dir={{0,1},{1,0},{0,-1},{-1,0}}，其中满足：除去非法：
  • 超出边缘x<0 || x>=n || y<0 || y>=m
  • or 访问过 visited[x][y] == true
  • or 海拔低于当前点：matrix[x][y]<matrix[i][j]
• 递归退出：在以上选择的时候，最终无可选择即可退出。因此无需多加一步递归退出判断。

当有水流过，则记录水流数组Pcf，Atl对应cell为true。否则为false。

BFS遍历整个大陆后，

对比两个水流数组Pcf，Atl

同样的cell中，都为true，则符合题意。

代码参考：

class Solution {
public:
    int m,n;
    void dfs(vector<vector<bool>>& visited, int i, int j, vector<vector<int>>& matrix) {
        int dir[5] = {1,0,-1,0,1};
        int x, y;
        visited[i][j] = true;
        for(int d=1; d<5; d++) {
            x = i+dir[d-1];
            y = j+dir[d];
            if(x<0 || x>=n || y<0 || y>=m 
            || visited[x][y] || matrix[x][y]<matrix[i][j]) continue;
            dfs(visited, x, y, matrix);
        }
        return;
    }
    vector<vector<int>> pacificAtlantic(vector<vector<int>>& matrix) {
        vector<vector<int>> res;
        n = matrix.size();
        if(n==0) return res;
        m = matrix[0].size();
        vector<vector<bool>> Pcf(n,vector<bool>(m,false));
        vector<vector<bool>> Atl(Pcf);//visited
        //Start DFS from board:
        for(int i=0; i<n; i++) {
            dfs(Pcf, i, 0, matrix);//left
            dfs(Atl, i, m-1, matrix);//right
        }
        for(int j=0; j<m; j++) {
            dfs(Pcf, 0, j, matrix);//up
            dfs(Atl, n-1, j, matrix);//bottom
        }
        for(int i=0; i<n; i++) {
            for(int j=0; j<m; j++) {
                if(Pcf[i][j] && Atl[i][j]) res.push_back({i,j});
            }
        }
        return res;
    }
};