LeetCode刷题笔记（Pacific Atlantic Water Flow）

刚刚刷了一道题，代码编写很顺畅，但因为bug有点多导致调试了很长时间，下面就和大家分享一下经验吧！

题目如下：

题意分析：

给定一个表示陆地单元高度的m*n矩阵，其中左上方表示是太平洋，右下方是大西洋。水可以朝四个方向（上、下、左、右）从高陆地单元流向低陆地单元，请找到既能流向太平洋又能流向大西洋的所有陆地单元坐标。

方法一（DFS递归法）

与之前那道Surrounded Regions很类似，将所有的边缘陆地单元当作起点开始遍历搜索，然后用Pacific_visited记录从左边与上边能到达的点（能到达则记为true），用Atlantic_visited记录从右边与下边能到达的点，最后，既能流向太平洋又能流向大西洋的所有陆地单元即为Pacific_visited与Atlantic_visited均记录为 true的陆地单元，返回这些陆地单元的坐标即可。

解题代码如下：

class Solution{
private:
    vector<vector<int>> res;
    int row;
    int col;
    int d[4][2] = {{-1,0},{0,-1},{1,0},{0,1}};

    void findpacificAtlantic( vector<vector<int>>& matrix, int pre, vector<vector<bool>>& visited, int startx, int starty ){
        visited[startx][starty] = true;

        for ( int i = 0; i < 4; i ++ ) {

            int newx = startx + d[i][0];
            int newy = starty + d[i][1];
            if ( newx >= 0 && newx < row && newy >= 0 && newy < col && !visited[newx][newy] && matrix[newx][newy] >= pre )
            {
             findpacificAtlantic( matrix, matrix[newx][newy], visited, newx ,newy );
        }

      }
    return;
   }

public:
    vector<vector<int>> pacificAtlantic(vector<vector<int>>& matrix){
        row = matrix.size();
        if ( row == 0 ) return res;
        col = matrix[0].size();

        vector<vector<bool>> Pacific_visited(row, vector<bool>(col, false));
        vector<vector<bool>> Atlantic_visited(row, vector<bool>(col, false));

        for (int i = 0; i < row; i++) {
            findpacificAtlantic( matrix, matrix[i][0], Pacific_visited, i ,0 );
            findpacificAtlantic( matrix, matrix[i][col-1], Atlantic_visited, i ,col-1 );
        }

        for (int i = 0; i < col; i++) {
            findpacificAtlantic( matrix, matrix[0][i], Pacific_visited, 0 ,i );
            findpacificAtlantic( matrix, matrix[row-1][i], Atlantic_visited, row-1 ,i );
        }

        for (int i = 0; i < row; i ++) {
            for (int j = 0; j < col; j ++) {
                if (Pacific_visited[i][j] && Atlantic_visited[i][j])
                    res.push_back({i,j});
            }

        }
        return res;

    }
};

提交后的结果如下：

 

方法二（BFS法）

广度优先遍历（层序遍历）BFS一般会采用一个队列来辅助遍历，将左边与上边的点存入q1中用于从太平洋开始层序遍历，将右边与下边的点存入q2中用于从大西洋开始层序遍历，然后用Pacific_visited记录从左边与上边能到达的点（能到达则记为true），用Atlantic_visited记录从右边与下边能到达的点，遍历结束后还是找Pacific_visited和Atlantic_visited均标记为true的陆地单元坐标加入结果res中并返回即可。

class Solution {
public:
    vector<vector<int>> pacificAtlantic(vector<vector<int>>& matrix) {
        vector<vector<int>> res;
        int row = matrix.size();
        if ( row == 0 ) return res;
        int col = matrix[0].size();
        queue<pair<int, int>> q1, q2;
        vector<vector<bool>> Pacific_visited(row, vector<bool>(col, false)), Atlantic_visited = Pacific_visited;
        for (int i = 0; i < row; ++i) {
            q1.push({i, 0});
            q2.push({i, col - 1});
            Pacific_visited[i][0] = true;
            Atlantic_visited[i][col - 1] = true;
        }
        for (int i = 0; i < col; ++i) {
            q1.push({0, i});
            q2.push({row - 1, i});
            Pacific_visited[0][i] = true;
            Atlantic_visited[row - 1][i] = true;
        }
        findpacificAtlantic(matrix, Pacific_visited, q1);
        findpacificAtlantic(matrix, Atlantic_visited, q2);
        for (int i = 0; i < row; ++i) {
            for (int j = 0; j < col; ++j) {
                if (Pacific_visited[i][j] && Atlantic_visited[i][j]) {
                    res.push_back({i, j});
                }
            }
        }
       return res;
    }
    void findpacificAtlantic(vector<vector<int>>& matrix, vector<vector<bool>>& visited, queue<pair<int, int>>& q) {
        vector<vector<int>> dirs{{0,-1},{-1,0},{0,1},{1,0}};
        int row = matrix.size();
        int col = matrix[0].size();
        while (!q.empty()) {
            auto t = q.front(); q.pop();
            for (auto dir : dirs) {
                int newx = t.first + dir[0], newy = t.second + dir[1];
                if (newx < 0 || newx >= row || newy < 0 || newy >= col || visited[newx][newy] || matrix[newx][newy] < matrix[t.first][t.second]) continue;
                visited[newx][newy] = true;
                q.push({newx, newy});
            }
        }
    }
};

提交后的结果如下：

 

 

 

日积月累，与君共进，增增小结，未完待续。