Leetcode101_广度优先搜索_1162地图分析 934最短的桥

最新推荐文章于 2023-02-16 17:48:47 发布

诶你爱我吗

最新推荐文章于 2023-02-16 17:48:47 发布

阅读量401

点赞数

分类专栏： LeetCode 文章标签：宽度优先算法 c++

本文链接：https://blog.csdn.net/weixin_44244154/article/details/125860572

版权

LeetCode 专栏收录该内容

60 篇文章 1 订阅

订阅专栏

这篇博客介绍了如何使用BFS（广度优先搜索）和DFS（深度优先搜索）算法解决两个网格问题。首先，第一题通过BFS寻找每个海洋节点到陆地的最短距离，并返回这些距离中的最大值。其次，第二题利用DFS找到一个陆地，然后从该陆地出发用BFS找到最短的桥，即两个陆地之间的最短路径。这两道题目都涉及到图的遍历和最短路径计算。

摘要由CSDN通过智能技术生成

1162地图分析

在这里插入图片描述

题解

什么鬼示例，题目读半天没读懂
意思是求每个海洋到陆地节点的最小值，然后返回这些最小值里面的最大值
BFS搜索

class Solution {
public:
    vector<int> direction = {-1,0,1,0,-1};
    int maxDistance(vector<vector<int>>& grid) {
        queue<vector<int>> deq;
        int m = grid.size(),n = grid[0].size();
        for(int i = 0; i < m; i++){
            for(int j = 0; j <n; j++){
                if(grid[i][j])
                    deq.push({i,j});
            }
        }
        if(deq.size() == 0 || deq.size() == m * n) return -1;
        int distance = -1;
        while(deq.size() != 0){
            distance++;
            int size = deq.size();
            while(size--){
                auto p = deq.front();
                deq.pop();
                for(int k = 0; k < 4; k++){
                    int x = p[0] + direction[k];
                    int y = p[1] + direction[k + 1];
                    if(!(x >=0 && x < m && y >= 0 && y < n && grid[x][y] == 0)) continue;
                    grid[x][y] = 2;
                    deq.push({x,y}); 
                }
            }
        }
        return distance;
    }
};

934最短的桥

在这里插入图片描述

题解

先用DFS求出一个陆地，然后对这个陆地上的每个节点用BFS，第一个到达的陆地就是最短距离

class Solution {
public:
    queue<vector<int>> que;
    void dfs(int i, int j, vector<vector<int>>& grid){
        int m = grid.size();
        int n = grid[0].size();
        if(!(i >= 0 && i < m && j >= 0 && j < n)) return;
        if(grid[i][j] == 1){
            grid[i][j] = 2;
            que.push({i,j});
            for(int k = 0; k < 4; k++){
                int x = i + direction[k];
                int y = j + direction[k + 1];
                dfs(x,y,grid);
            }
        }
    }
    vector<int> direction = {-1,0,1,0,-1};
    int shortestBridge(vector<vector<int>>& grid) {
        int m = grid.size();
        int n = grid[0].size();
        for(int i = 0; i < m; i++){
            bool flag = 1;
            for(int j = 0; j < n; j++){
                if(grid[i][j]){
                    flag = 0;
                    dfs(i,j,grid);
                    break;
                }
            }
            if(flag == 0) break;
        }
        int ans = 0;
        while(!que.empty()){
            ans++;
            int size = que.size();
            for(int i = 0; i < size; i++){
                auto it = que.front();
                que.pop();
                for(int k = 0; k < 4; k++){
                    int x = it[0] + direction[k];
                    int y = it[1] + direction[k + 1];
                    if(x >= 0 && x < m && y >= 0 && y < n && grid[x][y] != 2){
                        if(grid[x][y] == 1) return ans - 1;
                        else if(grid[x][y] == 0){
                            que.push({x,y});
                            grid[x][y] = 2;
                        }
                    }
                }
            }
        }
    return ans;
    }
};