LintCode 778: Pacific Atlantic Water Flow (BFS好题)

于 2020-01-12 07:25:27 发布
阅读量282 收藏
点赞数
分类专栏： algorithm-design
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/roufoo/article/details/103942896
版权
  1. 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.

Example
Example 1:

Input:
matrix =
[[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]]
Output:
[[0,4],[1,3],[1,4],[2,2],[3,0],[3,1],[4,0]]
Explanation:
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
Example 2:

Input:
matrix =
[[1,2],
[4,3]]
Output:
[[0,1],[1,0],[1,1]]
Notice
1.The order of returned grid coordinates does not matter.
2.Both m and n are less than 150.

解法1：BFS。
用两个queue，把周边的点先加入queue，最后比较一下两个queue中的相同点。
代码如下：

struct Node {
    int x;
    int y;
    Node(int row = 0, int col = 0) : x(row), y(col) {}
};

class Solution {
public:
    /**
     * @param matrix: the given matrix
     * @return: The list of grid coordinates
     */
    vector<vector<int>> pacificAtlantic(vector<vector<int>> &matrix) {
        int m = matrix.size();
        int n = matrix[0].size();
        
        vector<int> dx = {0, 0, 1, -1};
        vector<int> dy = {1, -1, 0, 0};
        
        vector<vector<int>> result;
        queue<Node> pacificQ, atlanticQ;
        vector<vector<bool>> pacificGrid(m, vector<bool>(n, false));
        vector<vector<bool>> atlanticGrid(m, vector<bool>(n, false));

        for (int i = 0; i < m; ++i) {
            pacificQ.push(Node(i, 0)); 
            pacificGrid[i][0] = 1;
            atlanticQ.push(Node(i, n -1)); 
            atlanticGrid[i][n - 1] = 1;
        }

        for (int j = 0; j < n; ++j) {
            pacificQ.push(Node(0, j));
            pacificGrid[0][j] = true;
            atlanticQ.push(Node(m - 1, j));
            atlanticGrid[m - 1][j] = true;
        }

        while(!pacificQ.empty()) {
            Node node = pacificQ.front();
            pacificQ.pop();
            for (int i = 0; i < 4; ++i) {
                int newX = node.x + dx[i];
                int newY = node.y + dy[i];
                if (newX >= 0 && newX < m && newY >= 0 && newY < n   
                && !pacificGrid[newX][newY] && matrix[node.x][node.y] <= matrix[newX][newY]) {
                    Node tmpNode = Node(newX, newY);
                    pacificQ.push(tmpNode);
                    pacificGrid[newX][newY] = true;
                }
            }
        }

        while(!atlanticQ.empty()) {
            Node node = atlanticQ.front();
            atlanticQ.pop();
            for (int i = 0; i < 4; ++i) {
                int newX = node.x + dx[i];
                int newY = node.y + dy[i];
                if (newX >= 0 && newX < m && newY >= 0 && newY < n && !atlanticGrid[newX][newY] && matrix[node.x][node.y] <= matrix[newX][newY]) {
                    Node tmpNode = Node(newX, newY);
                    atlanticQ.push(tmpNode);
                    atlanticGrid[newX][newY] = true;
                }
            }
        }

        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                if (pacificGrid[i][j] && atlanticGrid[i][j]) result.push_back({i,j});
            }
        }    
        return result;
    }
};

解法2：用unordered_set，然后看两个set的重合部分。
注意：unordered_set是基于hash table，所以要重载operator == (不需要重载opertor <)，并且要定义NodeHash结构体，这样hash table才知道调用哪个hash function。

代码如下:

struct Node {
    int x;
    int y;
    Node(int row = 0, int col = 0) : x(row), y(col) {}
    bool operator == (const Node & n) const {
        return x == n.x && y == n.y;
    }
};

struct NodeHash {
    int operator() (const Node & n) const {
        return n.x * 33 + n.y;
    }  
};

class Solution {
public:
    /**
     * @param matrix: the given matrix
     * @return: The list of grid coordinates
     */
    vector<vector<int>> pacificAtlantic(vector<vector<int>> &matrix) {
        int m = matrix.size();
        int n = matrix[0].size();
        
        vector<int> dx = {0, 0, 1, -1};
        vector<int> dy = {1, -1, 0, 0};
        
        vector<vector<int>> result;
        queue<Node> pacificQ, atlanticQ;
        unordered_set<Node, NodeHash> pacificS, atlanticS;
        
        for (int i = 0; i < m; ++i) {
            pacificQ.push(Node(i, 0)); 
            pacificS.insert(Node(i, 0));
            atlanticQ.push(Node(i, n - 1));
            atlanticS.insert(Node(i, n - 1));
        }

        for (int j = 0; j < n; ++j) {
            pacificQ.push(Node(0, j));
            pacificS.insert(Node(0, j));
            atlanticQ.push(Node(m - 1, j));
            atlanticS.insert(Node(m - 1, j));
        }

        while(!pacificQ.empty()) {
            Node node = pacificQ.front();
            pacificQ.pop();
            for (int i = 0; i < 4; ++i) {
                int newX = node.x + dx[i];
                int newY = node.y + dy[i];
                if (newX >= 0 && newX < m && newY >= 0 && newY < n && pacificS.find(Node(newX, newY)) == pacificS.end() && matrix[node.x][node.y] <= matrix[newX][newY]) {
                    pacificQ.push(Node(newX, newY));
                    pacificS.insert(Node(newX, newY));
                }
            }
        }

        while(!atlanticQ.empty()) {
            Node node = atlanticQ.front();
            atlanticQ.pop();
            for (int i = 0; i < 4; ++i) {
                int newX = node.x + dx[i];
                int newY = node.y + dy[i];
                if (newX >= 0 && newX < m && newY >= 0 && newY < n && atlanticS.find(Node(newX, newY)) == atlanticS.end() && matrix[node.x][node.y] <= matrix[newX][newY]) {
                    atlanticQ.push(Node(newX, newY));
                    atlanticS.insert(Node(newX, newY));
                }
            }
        }
        
        for (auto node : pacificS) {
        //for (auto it = pacificS.begin(); it != pacificS.end(); ++it) {
            if (atlanticS.find(node) != atlanticS.end()) {
                result.push_back({node.x, node.y});
            }
        }
        
        return result;
    }
};

解法3：顺便写了一个set的版本。不过set的操作太慢，这个版本会超时。
注意：
1）对于set的元素是结构体的情况，必须重载<，并且必须考虑每个字段的情况，如果只写成以下
bool operator < (const Node & n) const {
return x < n.x;
}
，那么set会把所有y相等的节点当成同一个元素！大错！

代码如下：

struct Node {
    int x;
    int y;
    int z;
    Node(int row = 0, int col = 0, int value = 0) : x(row), y(col), z(value) {}
    bool operator < (const Node & n) const {
        if (x < n.x) return true;
        if (x == n.x && y < n.y) return true;
        if (x == n.x && y == n.y) return z < n.z;
    }
};

class Solution {
public:
    /**
     * @param matrix: the given matrix
     * @return: The list of grid coordinates
     */
    vector<vector<int>> pacificAtlantic(vector<vector<int>> &matrix) {
        int m = matrix.size();
        int n = matrix[0].size();
        
        vector<int> dx = {0, 0, 1, -1};
        vector<int> dy = {1, -1, 0, 0};
        
        vector<vector<int>> result;
        queue<Node> pacificQ, atlanticQ;
        //unordered_set<Node, NodeHash> pacificS, atlanticS;
        set<Node> pacificS, atlanticS;
        
        for (int i = 0; i < m; ++i) {
            pacificQ.push(Node(i, 0, matrix[i][0])); 
            pacificS.insert(Node(i, 0, matrix[i][0]));
            atlanticQ.push(Node(i, n - 1, matrix[i][n - 1]));
            atlanticS.insert(Node(i, n - 1, matrix[i][n - 1]));
        }

        for (int j = 0; j < n; ++j) {
            pacificQ.push(Node(0, j, matrix[0][j]));
            pacificS.insert(Node(0, j, matrix[0][j]));
            atlanticQ.push(Node(m - 1, j, matrix[m - 1][j]));
            atlanticS.insert(Node(m - 1, j, matrix[m - 1][j]));
        }

        while(!pacificQ.empty()) {
            Node node = pacificQ.front();
            pacificQ.pop();
            for (int i = 0; i < 4; ++i) {
                int newX = node.x + dx[i];
                int newY = node.y + dy[i];
                
                if (newX >= 0 && newX < m && newY >= 0 && newY < n) {
                    Node tmpNode = Node(newX, newY, matrix[newX][newY]);
                    if (pacificS.find(tmpNode) == pacificS.end() && matrix[node.x][node.y] <= matrix[newX][newY]) {
                            pacificQ.push(tmpNode);
                            pacificS.insert(tmpNode);
                    }
                }
            }
        }

        while(!atlanticQ.empty()) {
            Node node = atlanticQ.front();
            atlanticQ.pop();
            for (int i = 0; i < 4; ++i) {
                int newX = node.x + dx[i];
                int newY = node.y + dy[i];
                if (newX >= 0 && newX < m && newY >= 0 && newY < n) {
                    Node tmpNode = Node(newX, newY, matrix[newX][newY]);
                    if (atlanticS.find(tmpNode) == atlanticS.end() && matrix[node.x][node.y] <= matrix[newX][newY]) {
                            atlanticQ.push(tmpNode);
                            atlanticS.insert(tmpNode);
                    }
                }
            }
        }

        for (auto node : pacificS) {
            if (atlanticS.find(node) != atlanticS.end()) {
                result.push_back({node.x, node.y});
            }
        }
        
        return result;
    }
};

解法4：也可以用DFS。以下是网上的代码。

class Solution {
public:
    /**
     * @param matrix: the given matrix
     * @return: The list of grid coordinates
     */
    vector<vector<int>> pacificAtlantic(vector<vector<int>> &matrix) {
        // write your code here
        vector<vector<int>> res;
        int n = matrix.size();
        if(n == 0){
            return res;
        }
        int m = matrix[0].size();
        vector<vector<bool>> Pacific(n,vector<bool>(m,false));
        vector<vector<bool>> Atlantic(n,vector<bool>(m,false));
        for(int i = 0;i < n;i++){
            dfs(matrix, Pacific, INT_MIN, i, 0);
            dfs(matrix, Atlantic, INT_MIN, i, m - 1);
        }
        for(int i = 0;i < m;i++){
            dfs(matrix, Pacific, INT_MIN, 0, i);
            dfs(matrix, Atlantic, INT_MIN, n - 1, i);
        }
        for(int i = 0;i < n;i++){
            for(int j = 0;j < m;j++){
                if(Pacific[i][j] && Atlantic[i][j]){
                    vector<int> temp;
                    temp.push_back(i);
                    temp.push_back(j);
                    res.push_back(temp);
                }
            }
        }
        return res;
    }
    int dx[4] = {0,-1,0,1};
    int dy[4] = {1,0,-1,0};
    void dfs(vector<vector<int>> &matrix, vector<vector<bool>> &visited, int height, int x, int y){
        int n = matrix.size();
        int m = matrix[0].size();
        if(x < 0 || x >=n || y < 0 || y >= m || matrix[x][y] < height || visited[x][y]){
            return;
        }
        visited[x][y] = true;
        for(int i = 0;i < 4;i++){
            dfs(matrix, visited, matrix[x][y], x + dx[i], y + dy[i]);
        }
    }
};
深度/广度优先搜索LeetCode 417 Pacific Atlantic Water Flow
萤火虫啊飞呀飞
06-23 269
LeetCode 417 Pacific Atlantic Water Flow Problem Description： 题目给出一个矩阵，矩阵的左侧和上侧为太平洋区域，矩阵的右侧和下侧为大西洋区域，矩阵中每个元素值代表水的高度，水只能向不比它高的地方流动。题目要求矩阵中哪些位置的水既可以流向太平洋也能流向大西洋。 具体的题目信息： https://leetcode.com/prob...
Leetcode 417. Pacific Atlantic Water Flow(python+cpp)
qq_37821701的博客
04-24 408
Leetcode 417. Pacific Atlantic Water Flow题目解析 题目 解析 这道题肯定第一时间想到的是dfs。但是这边如果遍历数组的每个位置进行dfs的话，复杂度太高了，这样做理论上时间复杂度会是O((MN)(M*N))。所以可以采用一种逆向的思路。从靠近大洋的四条边开始反向搜索，反向搜索的过程中把能够到的位置进行标记。如果某个位置两个大洋同时都能到，那么这个位置满...
第四周：( LeetCode417 ) Pacific Atlantic Water Flow（c++）
marlonlyh的博客
03-16 397
原题： 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.
417. Pacific Atlantic Water Flow
wilzxu的博客
05-22 334
417. Pacific Atlantic Water Flow方法0: wrong方法2: dfs方法2: dfs 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...
[LeetCode 417] Pacific Atlantic Water Flow
ExcitedZhang的博客
04-21 201
Given anm x nmatrix 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" touch...
LeetCode 417. Pacific Atlantic Water Flow
Keep Learning
04-28 226
问题描述 地址 问题分析 该题一看便知是枚举所有可能性的题目，但一开始的思路是从每一个点进行dfs，这样的想法是实在是太死脑筋了。应该换个方向！！！ 该题思路有点类似 LeetCode 130. Surrounded Regions , 从每条边界开始进行 DFS, 对连通区域进行染色，但该题的“连通区域”定义为下一个进行dfs的位置大于等于上一位置的数才可以。因为这样水才能从该位...
is-sea::water_wave: 检查地理坐标是否在海中或地球上
05-29
:water_wave: 检查地理坐标是否在海中或地球上。 单击地图以查看实时预览。 概要 给定纬度和经度坐标，此包返回该点是否落入海洋/海洋。 该包在内部使用分辨率为 10m 的地图。 地图的准确性尚未经过测试，但该...
Using springtime Atlantic SST as a predictor for summertime western North Pacific subtropical high
12-26
利用春季大西洋海表面温度作为西北太平洋副热带高压的一个预报因子，王磊，，研究考察了利用春季大西洋海表面温度(SST)作为夏季西北太平洋副热带高压(WNPSH)的预报因子的可行性。研究结果表明：春季热带北大西洋
[Leetcode] 417. Pacific Atlantic Water Flow 解题报告
魔豆（Magicbean）的博客
10-23 470
题目： 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 o
LeetCode 417. Pacific Atlantic Water Flow 题解
daqiang95的博客
11-23 430
417. Pacific Atlantic Water Flow   Add to List Question Editorial Solution  My Submissions Total Accepted: 5223Total Submissions: 16297Difficulty: MediumContributors: Admin
【LeetCode】417. Pacific Atlantic Water Flow 太平洋大西洋水流问题
负雪明烛
10-01 3792
有一个 m × n 的矩形岛屿，与 太平洋 和 大西洋 相邻。“太平洋”处于大陆的左边界和上边界，而 “大西洋” 处于大陆的右边界和下边界。 这个岛被分割成一个由若干方形单元格组成的网格。给定一个 m x n 的整数矩阵heights，heights[r][c]表示坐标 (r, c) 上单元格 高于海平面的高度 。 岛上雨水较多，如果相邻单元格的高度 小于或等于 当前单元格的高度，雨水可以直接向北、南、东、西流向相邻单元格。水可以从海洋附近的任何单元格流入海洋。 返回网格坐标 result
VB程序实例-图像的打印.zip
11-03
VB程序实例-图像的打印.zip
VB程序实例-字形窗口.zip
最新发布
11-03
VB程序实例-字形窗口.zip
VB程序实例36_动态控制_增减控件.zip
11-03
VB程序实例，可供参考学习使用，希望对你有所帮助
技术资料分享CC2530非常好的技术资料.zip
11-03
技术资料分享CC2530非常好的技术资料.zip
带宽调度算法-基于业务递归分配
11-03
带宽调度算法-基于业务递归分配
用java写的数独小游戏课程设计.zip
11-03
西电计组课设用java写的数独小游戏课程设计.zip
冠词练习题解析：深海机器人与成功案例
本文是一份关于冠词练习题的解析文档，共包含五道题目，旨在帮助学习者巩固和理解英语中冠词的使用规则。以下是对各题目的详细解析： 1. 第一题考察的是不定冠词（a/an）和定冠词（the）的区别。题干提到的“an ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值