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

于 2020-01-12 07:25:27 发布
阅读量265 收藏
点赞数
分类专栏： 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]);
        }
    }
};
纸上得来终觉浅 绝知此事要躬行
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深度/广度优先搜索LeetCode 417 Pacific Atlantic Water Flow
萤火虫啊飞呀飞
06-23 228
LeetCode 417 Pacific Atlantic Water Flow Problem Description： 题目给出一个矩阵，矩阵的左侧和上侧为太平洋区域，矩阵的右侧和下侧为大西洋区域，矩阵中每个元素值代表水的高度，水只能向不比它高的地方流动。题目要求矩阵中哪些位置的水既可以流向太平洋也能流向大西洋。 具体的题目信息： https://leetcode.com/prob...
第四周：( LeetCode417 ) Pacific Atlantic Water Flow（c++）
marlonlyh的博客
03-16 377
原题： 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 312
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 184
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...
is-sea::water_wave: 检查地理坐标是否在海中或地球上
05-29
:water_wave: 检查地理坐标是否在海中或地球上。 单击地图以查看实时预览。 概要 给定纬度和经度坐标，此包返回该点是否落入海洋/海洋。 该包在内部使用分辨率为 10m 的地图。 地图的准确性尚未经过测试，但该...
ATLANTIC-R20：CRM企业
02-17
大西洋20 该项目是使用版本10.0.1生成的。 开发服务器 为开发服务器运行ng serve 。... 如果您更改任何源文件，该应用程序将自动重新加载。 代码脚手架 运行ng generate component component-name生成一个新的组件。...
woocommerce-first-atlantic-commerce:WooCommerce的第一个Atlantic Commerce网关扩展
05-01
**标题详解：** "woocommerce-first-atlantic-commerce: WooCommerce的第一个Atlantic Commerce网关扩展" 这个标题表明，这是一个专门针对WooCommerce电子商务平台的插件或扩展，它的主要功能是添加了对Atlantic ...
Using springtime Atlantic SST as a predictor for summertime western North Pacific subtropical high
12-26
利用春季大西洋海表面温度作为西北太平洋副热带高压的一个预报因子，王磊，，研究考察了利用春季大西洋海表面温度(SST)作为夏季西北太平洋副热带高压(WNPSH)的预报因子的可行性。研究结果表明：春季热带北大西洋
atlantic-app
05-14
该项目是通过。 您将在下面找到有关执行常见任务的信息。 该指南的最新版本可。 目录 构建世博会的“独立”应用 从Create React Native App弹出 构建依赖关系（Xcode和Android Studio） 我应该使用ExpoKit吗？...
[Leetcode] 417. Pacific Atlantic Water Flow 解题报告
魔豆（Magicbean）的博客
10-23 445
题目： 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
qq_39638957的博客
09-28 145
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 题解
daqiang95的博客
11-23 419
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 3729
有一个 m × n 的矩形岛屿，与 太平洋 和 大西洋 相邻。“太平洋”处于大陆的左边界和上边界，而 “大西洋” 处于大陆的右边界和下边界。 这个岛被分割成一个由若干方形单元格组成的网格。给定一个 m x n 的整数矩阵heights，heights[r][c]表示坐标 (r, c) 上单元格 高于海平面的高度 。 岛上雨水较多，如果相邻单元格的高度 小于或等于 当前单元格的高度，雨水可以直接向北、南、东、西流向相邻单元格。水可以从海洋附近的任何单元格流入海洋。 返回网格坐标 result
ROS安装配置与语法介绍文档、ROS代码文档、树莓派与ROS结合使用等相关文档
最新发布
07-08
ROS安装配置与语法介绍文档、ROS代码文档、树莓派与ROS结合使用等相关文档
2003-2023年飞机航线信息数据.xlsx
07-08
2003-2023年飞机航线信息数据 1、时间：2003-2023年 2、来源：高铁航线数据库（Chinese High-speed Rail and Airline Database，CRAD） 3、指标：起点城市、起点城市所属地级市、起点城市所属省份、起点机场、终点城市、终点城市所属地级市、终点城市所属省份、终点机场、航空公司、更新日期、航班、出发时间、到达时间、准点率、班次_周一、班次_周二、班次_周三、班次_周四、班次_周五、班次_周六、班次_周日
Xilinx Vitis 2020工程源目录修改
07-08
Xilinx Vitis可以做standalone程序开发,不过其工程中使用的路径为绝对路径。工程更换位置后编译将会显示错误。例如：源目录为D:/work,复制到同事电脑上放到C:/work(同事电脑只有一个C盘)。利用Vitis打开工程编译会有一堆错误，提示文件找不到。本脚本用来解决该问题。
1000__gpt_4_prompts.md
07-08
1000__gpt_4_prompts
{"code":1,"description":null,"resultObject":[{"value":"MA","label":"Middle Atlantic"},{"value":"MT","label":"Mountain"},{"value":"NE","label":"New England"},{"value":"NEC","label":"Northeast Central"},{"value":"NWC","label":"Northwest Central"},{"value":"PF","label":"Pacific"},{"value":"SA","label":"South Atlantic"},{"value":"SEC","label":"Southeast Central"},{"value":"SWC","label":"Southwest Central"}]}                                has context menu {"code":1, "description":null, "resultObject":["executive-summary","smart-activity-results","coder-accuracy","reviewer-results","flags","medpar-comparison"]}  如何在同一个jsonschema中验证以上两个json结果
05-25
可以使用 JSON Schema 中的 `oneOf` 关键字来验证这两个 JSON 结果。具体地，我们可以定义一个 JSON Schema，该 Schema 包含两个 `oneOf` 子项，每个子项分别对应一个 JSON 结果。下面是一个示例： ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值