【leetcode】【medium】417. Pacific Atlantic Water Flow​​​​​​​

417. Pacific Atlantic Water Flow

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

题目链接：https://leetcode-cn.com/problems/pacific-atlantic-water-flow/

 

思路

做这道题又翻车了，思维过程和区域反转那道题一样，又想遍历一次就ok。于是是以下代码：

class Solution {
public:
// 遍历情况：-1-正在遍历，0-未遍历过,1-只能通向pacific,2-只能通向atlantic,3-都能通向，4-都不能通向
vector<vector<int>> visit;  
vector<vector<int>> res;
int num;
int len;
    vector<vector<int>> pacificAtlantic(vector<vector<int>>& matrix) {
        num = matrix.size();
        if(!num) return res;
        len = matrix[0].size();
        visit = vector<vector<int>>(num, vector<int>(len, 0));
        for(int i=0; i<num; ++i){
            for(int j=len-1; j>=0; --j){
                if(visit[i][j]==0){
                    toOcean(i, j, matrix);
                }
            }
        }
        return res;
    }
    // 取位置的海洋流通状态
    int toOcean(int i, int j, vector<vector<int>> & matrix){
        int cnt = visit[i][j];  
        if(cnt!=0) return visit[i][j];  // 已遍历过
        cnt = 0;
        cnt = inOcean(i, j);    // 初始：点在海洋的状态；后序：点到海洋的状态
        if(cnt==3) {
            visit[i][j] = 3;
            res.push_back(vector<int>{i, j});
            return 3;
        }
        int fcnt = 0;   // 点流动收集的状态
        visit[i][j] = -1;
        if(flow(i, j, 1, matrix)) {
            fcnt = toOcean(i-1, j, matrix); 
            if(fcnt==3 || (cnt==1 && fcnt==2) || (cnt==2 && fcnt==1)){
                visit[i][j] = 3;
                res.push_back(vector<int>{i, j});
                return 3;
            }else {
                if(cnt==0 && fcnt!=4){
                    cnt = fcnt;
                }
                fcnt = 0;
            }
        }
        if(flow(i, j , 2, matrix)){
            fcnt = toOcean(i, j+1, matrix);
            if(fcnt==3 || (cnt==1 && fcnt==2) || (cnt==2 && fcnt==1)){
                visit[i][j] = 3;
                res.push_back(vector<int>{i, j});
                return 3;
            }else {
                if(cnt==0 && fcnt!=4){
                    cnt = fcnt;
                }
                fcnt = 0;
            }
        }
        if(flow(i, j, 3, matrix)){
            fcnt = toOcean(i+1, j, matrix);
            if(fcnt==3 || (cnt==1 && fcnt==2) || (cnt==2 && fcnt==1)){
                visit[i][j] = 3;
                res.push_back(vector<int>{i, j});
                return 3;
            }else {
                if(cnt==0 && fcnt!=4){
                    cnt = fcnt;
                }
                fcnt = 0;
            }
        if(flow(i, j, 4, matrix)){
            fcnt = toOcean(i, j-1, matrix);
            if(fcnt==3 || (cnt==1 && fcnt==2) || (cnt==2 && fcnt==1)){
                visit[i][j] = 3;
                res.push_back(vector<int>{i, j});
                return 3;
            }else {
                if(cnt==0 && fcnt!=4){
                    cnt = fcnt;
                }
                fcnt = 0;
            }
        }
        visit[i][j] = (cnt==0)?4:cnt;
        return cnt;
    }
    // 判断此方向能否流动：位置存在 + 地形限制
    bool flow(int i, int j, int dir, vector<vector<int>> &matrix){
        switch (dir){
            case 1:{
                return i-1>=0 && matrix[i-1][j]<=matrix[i][j];
            }
            case 2:{
                return j+1<len && matrix[i][j+1]<=matrix[i][j];
            }
            case 3:{
                return i+1<num && matrix[i+1][j]<=matrix[i][j];
            }
            default:{
                return j-1>=0 && matrix[i][j-1]<=matrix[i][j];
            }
        }
    }
    // 判断在哪个海洋里：0-不在，1-pacific，2-atlantic，3-都在
    int inOcean(int i, int j){
        int cnt = 0;
        if(i==0 || j==0){
            cnt = 1;
        }
        if(i==num-1 || j==len-1){
            
            cnt = (cnt==1)?3:2;
        }
        return cnt;
    }
};

出现的问题也和上道题一样，也是遍历顺序的原因，导致可能在信息不全的情况下误判了，又不能回头改了。

所以，思路还是得从4条边界上的位置出发去遍历，从可到达的位置逆流向中间。

class Solution {
public:
// 遍历情况：0-未遍历过, 1-只能通向pacific, 2-只能通向atlantic, 3-都能通向
vector<vector<int>> visit;  
vector<vector<int>> res;
int num;
int len;
    vector<vector<int>> pacificAtlantic(vector<vector<int>>& matrix) {
        num = matrix.size();
        if(!num) return res;
        len = matrix[0].size();
        visit = vector<vector<int>>(num, vector<int>(len, 0));
        int is[] = {0, num-1}, js[] = {0, len-1};
        for(int i=0; i<2; ++i){
            for(int j=len-1; j>=0; --j){
                if(visit[is[i]][j]==0){
                    toOcean(is[i], j, matrix, 0);
                }
            }
        }
        for(int j=0; j<2; ++j){
            for(int i=1; i<num-1; ++i){
                if(visit[i][js[j]]==0){
                    toOcean(i, js[j], matrix, 0);
                }
            }
        }
        return res;
    }
    // 逆流
    void toOcean(int i, int j, vector<vector<int>> & matrix, int stat){
        int cnt = visit[i][j];
        bool flag = false;
        if(cnt==0){
            flag = true;
            cnt = inOcean(i, j);
        }
        if(cnt!=stat && (cnt!=3 || flag)){
            if(stat==3 || cnt==3 || (cnt==1 && stat==2) || (cnt==2 && stat==1)){
                cnt = 3;
                res.push_back(vector<int>{i, j});
            }else if(cnt==0){
                cnt = stat;
            }
            visit[i][j] = cnt;

            if(flow(i, j, 1, matrix)) {
                toOcean(i-1, j, matrix, cnt); 
            }
            if(flow(i, j , 2, matrix)){
                toOcean(i, j+1, matrix, cnt);
            }
            if(flow(i, j, 3, matrix)){
                toOcean(i+1, j, matrix, cnt);
            }
            if(flow(i, j, 4, matrix)){
                toOcean(i, j-1, matrix, cnt);
            }
        }
        return;
    }
    // 判断此方向能否逆向流动：位置存在 + 地形限制
    bool flow(int i, int j, int dir, vector<vector<int>> &matrix){
        switch (dir){
            case 1:{
                return i-1>=0 && matrix[i-1][j]>=matrix[i][j];
            }
            case 2:{
                return j+1<len && matrix[i][j+1]>=matrix[i][j];
            }
            case 3:{
                return i+1<num && matrix[i+1][j]>=matrix[i][j];
            }
            default:{
                return j-1>=0 && matrix[i][j-1]>=matrix[i][j];
            }
        }
    }
    // 判断在哪个海洋里：0-不在，1-pacific，2-atlantic，3-都在
    int inOcean(int i, int j){
        int cnt = 0;
        if(i==0 || j==0){
            cnt = 1;
        }
        if(i==num-1 || j==len-1){
            
            cnt = (cnt==1)?3:2;
        }
        return cnt;
    }
};