图论基础|695. 岛屿的最大面积、1020. 飞地的数量、130. 被围绕的区域

news2024/11/15 6:46:04

695. 岛屿的最大面积

力扣题目链接(opens new window)

给你一个大小为 m x n 的二进制矩阵 grid 。

岛屿 是由一些相邻的 1 (代表土地) 构成的组合，这里的「相邻」要求两个 1 必须在 水平或者竖直的四个方向上 相邻。你可以假设 grid 的四个边缘都被 0（代表水）包围着。

岛屿的面积是岛上值为 1 的单元格的数目。

计算并返回 grid 中最大的岛屿面积。如果没有岛屿，则返回面积为 0 。

  • 输入：grid = [[0,0,1,0,0,0,0,1,0,0,0,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,1,1,0,1,0,0,0,0,0,0,0,0],[0,1,0,0,1,1,0,0,1,0,1,0,0],[0,1,0,0,1,1,0,0,1,1,1,0,0],[0,0,0,0,0,0,0,0,0,0,1,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,0,0,0,0,0,0,1,1,0,0,0,0]]
  • 输出：6
  • 解释：答案不应该是 11 ，因为岛屿只能包含水平或垂直这四个方向上的 1 。

思路：广度优先和深度优先皆可，遍历的时候计数，然后取最大数量即可

class Solution {
public:
    //深度优先版本
    int count=0;
    int result =0;
    int dir[4][2]={0,1,1,0,-1,0,0,-1};
    void dfs(vector<vector<int>>& grid, vector<vector<bool>>& visited, int x, int y){
        for(int i=0;i<4;i++){
            int nextx= x+dir[i][0];
            int nexty=y+dir[i][1];
            if(nextx<0||nextx>=grid.size()||nexty<0||nexty>=grid[0].size())continue;
            if(!visited[nextx][nexty] && grid[nextx][nexty] == 1){
                
                visited[nextx][nexty]=true;
                count++;
                dfs(grid,visited,nextx,nexty);

            }
        }
        
    }
    int maxAreaOfIsland(vector<vector<int>>& grid) {
       int n=grid.size(); int m=grid[0].size();
        vector<vector<bool>>visited=vector<vector<bool>>(n,vector<bool>(m,false));
        for(int i=0;i<n;i++){
            for(int j=0; j<m;j++){
                if(!visited[i][j]&&grid[i][j]==1){
                    count=1;//遇到陆地先计数
                    visited[i][j]=true;
                    dfs(grid,visited,i,j);
                    result=max(result,count);
                }
            }
        }
        return result;
    }
};
//广度优先版本
class Solution {
public:
 
    int count=0;
    int result =0;
    int dir[4][2]={0,1,1,0,-1,0,0,-1};
    void dfs(vector<vector<int>>& grid, vector<vector<bool>>& visited, int x, int y){
        queue<int>que;
        que.push(x);
        que.push(y);
        visited[x][y]=true;
        count++;
        while(!que.empty()){
            int xx=que.front(); que.pop();
            int yy=que.front(); que.pop();
            for(int i=0;i<4;i++){
                int nextx=  xx+dir[i][0];
                int nexty=  yy+dir[i][1];

                if(nextx<0||nextx>=grid.size()||nexty<0||nexty>=grid[0].size())continue;
                if(!visited[nextx][nexty] && grid[nextx][nexty] == 1){
                
                    visited[nextx][nexty]=true;
                    count++;
                    que.push(nextx);
                    que.push(nexty);

                }
            }
        }
        
    }
    int maxAreaOfIsland(vector<vector<int>>& grid) {
       int n=grid.size(); int m=grid[0].size();
        vector<vector<bool>>visited=vector<vector<bool>>(n,vector<bool>(m,false));
        for(int i=0;i<n;i++){
            for(int j=0; j<m;j++){
                if(!visited[i][j]&&grid[i][j]==1){
                    count=0;
                    visited[i][j]=true;
                    dfs(grid,visited,i,j);
                    result=max(result,count);
                }
            }
        }
        return result;
    }
};

1020. 飞地的数量

力扣链接(opens new window)

给你一个大小为 m x n 的二进制矩阵 grid ，其中 0 表示一个海洋单元格、1 表示一个陆地单元格。

一次 移动 是指从一个陆地单元格走到另一个相邻（上、下、左、右）的陆地单元格或跨过 grid 的边界。

返回网格中 无法 在任意次数的移动中离开网格边界的陆地单元格的数量。

  • 输入：grid = [[0,0,0,0],[1,0,1,0],[0,1,1,0],[0,0,0,0]]
  • 输出：3
  • 解释：有三个 1 被 0 包围。一个 1 没有被包围，因为它在边界上。

  • 输入：grid = [[0,1,1,0],[0,0,1,0],[0,0,1,0],[0,0,0,0]]
  • 输出：0
  • 解释：所有 1 都在边界上或可以到达边界

思路：本题要求找到不靠边的陆地面积，那么我们只要从周边找到陆地然后 通过 dfs或者bfs 将周边靠陆地且相邻的陆地都变成海洋，然后再去重新遍历地图的时候，统计此时还剩下的陆地就可以了。

遍历周边：分别遍历最左列（grid[i][0]),最右列（grid[i][m-1]),最上行（grid[0][j]),最下行（grid[n-1][j]),同时进行搜索，在搜索过程中将其置0。

class Solution {
public:
    //深度优先搜索
    int dir[4][2]={1,0,0,1,-1,0,0,-1};//四个方向
    int count;
    void dfs(vector<vector<int>>& grid, int x, int y){
        grid[x][y]=0;
        count++;
        for(int i=0; i<4; i++){
            int nextx= x+dir[i][0];
            int nexty=y+dir[i][1];
            if(nextx<0||nextx>=grid.size()||nexty<0||nexty>=grid[0].size())continue;
            if(grid[nextx][nexty]==1){
                // count++;
                // grid[nextx][nexty]=0;
                dfs(grid, nextx, nexty);
            }
        }
        return;
    }
    int numEnclaves(vector<vector<int>>& grid) {
        // int count=0;
        int n=grid.size();//行数
        int m=grid[0].size();//列数
        //遍历周边
        for(int i=0;i<n;i++){
            if(grid[i][0])dfs(grid, i,0);//遍历最左列
            if(grid[i][m-1])dfs(grid,i, m-1);//遍历最右列
        }
        for(int j=0; j<m;j++){
            if(grid[0][j])dfs(grid, 0, j);//遍历最上行
            if(grid[n-1][j])dfs(grid,n-1, j);//遍历最底行
        }
        
        //遍历整个网格，并计数
        count= 0;
        for(int i=0; i<n; i++){
            for(int j=0; j<m;j++){
                if(grid[i][j]){
                    // count++;
                    dfs(grid,i, j);
                }
            }
        }
        return count;
        

    }
};
//广度优先搜索
class Solution {
public:
    int count =0;
    int dir[4][2]={0,1,1,0,0,-1,-1,0};
    void bfs(vector<vector<int>>& grid, int x, int y){
        queue<pair<int,int>>que;
        que.push({x,y});
        count++;
        grid[x][y]=0;
        while(!que.empty()){
            pair<int,int>cur=que.front();que.pop();
            for(int i=0;i<4;i++){
                int nextx=cur.first+dir[i][0];
                int nexty=cur.second+dir[i][1];
                if(nextx<0||nextx>=grid.size()||nexty<0||nexty>=grid[0].size())continue;
                if(grid[nextx][nexty]){
                    que.push({nextx,nexty});
                    count++;
                    grid[nextx][nexty]=0;
                }

            }
            
        }
        return;
    }
    int numEnclaves(vector<vector<int>>& grid) {
        int n=grid.size();//行数
        int m=grid[0].size();//列数
        //遍历周边并置0
        for(int i=0;i<n;i++){
            if(grid[i][0])bfs(grid,i,0);//遍历最左列
            if(grid[i][m-1])bfs(grid,i,m-1);//遍历最右列
        }
        for(int j=0;j<m;j++){
            if(grid[0][j]) bfs(grid,0,j);//遍历第一行
            if(grid[n-1][j]) bfs(grid,n-1,j);//遍历最后一行
        }
        //重新遍历整个网格并计算
        count=0;
        for(int i=0; i<n;i++) {
            for(int j=0;j<m;j++){
                if(grid[i][j]){
                    bfs(grid,i,j);
                }
            }
        }
        return count;
    }
};

130. 被围绕的区域

题目链接(opens new window)

给你一个 m x n 的矩阵 board ，由若干字符 'X' 和 'O' ，找到所有被 'X' 围绕的区域，并将这些区域里所有的 'O' 用 'X' 填充。

  • 输入：board = [["X","X","X","X"],["X","O","O","X"],["X","X","O","X"],["X","O","X","X"]]
  • 输出：[["X","X","X","X"],["X","X","X","X"],["X","X","X","X"],["X","O","X","X"]]
  • 解释：被围绕的区间不会存在于边界上，换句话说，任何边界上的 'O' 都不会被填充为 'X'。 任何不在边界上，或不与边界上的 'O' 相连的 'O' 最终都会被填充为 'X'。如果两个元素在水平或垂直方向相邻，则称它们是“相连”的

思路：和上一题类似，只是需要把’飞地‘改为”X"

先广度优先或深度优先遍历周边，把周边的X换为'A'，然后两个for循环遍历整个grid,遇到'A'换成’O',遇到'O'换成‘X'

//广度优先搜索
class Solution {
public:
    int dir[4][2]={0,1,1,0,0,-1,-1,0};
    void dfs(vector<vector<char>>& board, int x, int y){
        board[x][y]='A';
        for(int i=0;i<4;i++){
            int nextx=x+dir[i][0];
            int nexty=y+dir[i][1];
            if(nextx<0||nextx>=board.size()||nexty<0||nexty>=board[0].size())continue;
            if(board[nextx][nexty]=='O'){
                dfs(board,nextx,nexty);
            }
        }
        return;
    }
    void solve(vector<vector<char>>& board) {
        int n=board.size();//行数
        int m=board[0].size();//列数
        //遍历周边，把周边的'O'换成’A‘
        for(int i=0;i<n;i++){
            if(board[i][0]=='O')dfs(board,i,0);//遍历最左列
            if(board[i][m-1]=='O')dfs(board,i,m-1);//遍历最右列
        }

        for(int j=0;j<m;j++){
            if(board[0][j]=='O')dfs(board,0,j);//最上行
            if(board[n-1][j]=='O')dfs(board,n-1,j);//最下行
        }

        //遍历整个网格并替换
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                if(board[i][j]=='O')board[i][j]='X';
                if(board[i][j]=='A') board[i][j]='O';
                
            }
        }
        

    }
};
class Solution {
public:
    int dir[4][2] = {0, 1, 1, 0, 0, -1, -1, 0};
    void bfs(vector<vector<char>>& board, int x, int y) {
        queue<pair<int, int>> que;
        que.push({x, y});
        board[x][y]='A';
        while (!que.empty()) {
            pair<int, int> cur = que.front();
            que.pop();
            for (int i = 0; i < 4; i++) {
                int nextx = cur.first + dir[i][0];
                int nexty = cur.second + dir[i][1];
                if (nextx < 0 || nextx >= board.size() || nexty < 0 ||
                    nexty >= board[0].size())
                    continue;
                if (board[nextx][nexty] == 'O') {
                    board[nextx][nexty] = 'A';
                    // cout<<"board[nextx][nexty]:"<<board[nextx][nexty]<<endl;
                    que.push({nextx, nexty});
                    
                }
            }
        }
    }
    void solve(vector<vector<char>>& board) {
        int n = board.size();
        int m = board[0].size();
        // 遍历周边
        for (int i = 0; i < n; i++) {
            if (board[i][0] == 'O')
                bfs(board, i, 0);
            if (board[i][m - 1] == 'O')
                bfs(board, i, m - 1);
        }
        for (int j = 0; j < m; j++) {
            if (board[0][j] == 'O')
                bfs(board, 0, j);
            if (board[n - 1][j] == 'O')
                bfs(board, n - 1, j);
        }

        // 遍历整个网格并替换
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                // cout<<"before: "<<board[i][j]<<endl;
                if (board[i][j] == 'O')
                    board[i][j] = 'X';
                if (board[i][j] == 'A')
                    board[i][j] = 'O';
                
                
            }
        }
    }
};

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1535214.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

WebGIS航线编辑器(无人机航线规划)

WebGIS航线编辑器(无人机航线规划)

无人机航点、航线规划&#xff0c;实现全自动航点飞行作业及飞行航拍。禁飞区、作业区功能保障飞行安全。 GIS引擎加载 const viewer new Cesium.Viewer("cesiumContainer", { imageryProvider: new Cesium.IonImageryProvider({ assetId: 3872 }), }); const im…
阅读更多...
水泥领域智慧工厂物联网解决方案

水泥领域智慧工厂物联网解决方案

水泥领域智慧工厂物联网解决方案 在水泥生产行业中&#xff0c;构建智慧工厂物联网解决方案已经成为推动产业升级、实现智能制造的关键路径。该方案深度融合了先进的信息技术与传统的水泥生产工艺&#xff0c;通过全面感知、可靠传输、智能处理等环节&#xff0c;实现了对整个…
阅读更多...
打造高效自动化渗透测试系统：关键步骤与实践

打造高效自动化渗透测试系统：关键步骤与实践

随着当前网络安全威胁的不断扩展与升级&#xff0c;开展渗透测试工作已经成为广大企业组织主动识别安全漏洞与潜在风险的关键过程。然而&#xff0c;传统的人工渗透测试模式对测试人员的专业能力和经验水平有很高的要求&#xff0c;企业需要投入较大的时间和资源才能完成。在此…
阅读更多...
[实践经验]: visual studio code 实用技巧

[实践经验]: visual studio code 实用技巧

目录 editor rulers 这里主要总结一些常用的VScode技巧&#xff0c;不定时更新… editor rulers 设置 -> 搜索 editor.rulers -> edit in settings.json "editor.rulers": [{"column": 80,"color": "#ff00FF"},]效果如图
阅读更多...
基于Java的汽车客运站管理系统的设计与实现论文

基于Java的汽车客运站管理系统的设计与实现论文

摘 要 互联网发展至今&#xff0c;无论是其理论还是技术都已经成熟&#xff0c;而且它广泛参与在社会中的方方面面。它让信息都可以通过网络传播&#xff0c;搭配信息管理工具可以很好地为人们提供服务。针对汽车客运站售票信息管理混乱&#xff0c;出错率高&#xff0c;信息安…
阅读更多...
Tensorflow2.0笔记 - FashionMnist数据集训练

Tensorflow2.0笔记 - FashionMnist数据集训练

本笔记使用FashionMnist数据集&#xff0c;搭建一个5层的神经网络进行训练&#xff0c;并统计测试集的精度。 本笔记中FashionMnist数据集是直接下载到本地加载的方式&#xff0c;不涉及用梯子。 关于FashionMnist的介绍&#xff0c;请自行百度。 #Fashion Mnist数据集本地下载…
阅读更多...
2024开年首展，加速科技展台“热辣滚烫”

2024开年首展，加速科技展台“热辣滚烫”

3月20日&#xff0c;备受瞩目的半导体行业盛会SEMICON China 2024在上海新国际博览中心盛大启幕&#xff0c;展会汇集了来自全球的半导体领域顶尖企业与专业人士。加速科技作为业界领先的半导体测试设备供应商携重磅测试设备及解决方案精彩亮相&#xff0c;展示了最新的半导体测…
阅读更多...
陈巍：Sora大模型技术精要万字详解（上）——原理、关键技术、模型架构详解与应用

陈巍：Sora大模型技术精要万字详解（上）——原理、关键技术、模型架构详解与应用

​目录 收起 1 Sora的技术特点与原理 1.1 技术特点概述 1.2 时间长度与时序一致性 1.3 真实世界物理状态模拟 1.4 Sora原理 1.4.1扩散模型与单帧图像的生成 1.4.2 Transformer模型与连续视频语义的生成 1.4.3 从文本输入到视频生成 2 Sora的关键技术 2.1 传统文生图技…
阅读更多...
GitHub Copilot怎么取消付费？

GitHub Copilot怎么取消付费？

0. 前言 GitHub Copilot非常好用&#xff0c;还没有使用过的同学可以参考教程白嫖一个月&#xff1a;【保姆级】VsCode 安装GitHub Copilot实操教程 GitHub Copilot每月10美元的费用对于一些用户来说可能是一笔不小的开销。如果你已经完成了GitHub Copilot的免费试用&#xf…
阅读更多...
痛失offer的八股

痛失offer的八股

java面试八股 mysql篇&#xff1a; 事物的性质&#xff1a; 事物的性质有acid四特性。 a&#xff1a;automic&#xff0c;原子性&#xff0c;要么全部成功&#xff0c;要么全部失败&#xff0c;mysql的undolog&#xff0c;事物在执行的时候&#xff0c;mysql会进行一个快照读…
阅读更多...
C#多态性

C#多态性

文章目录 C#多态性静态多态性函数重载函数重载 动态多态性运行结果 C#多态性 静态多态性 在编译时&#xff0c;函数和对象的连接机制被称为早期绑定&#xff0c;也被称为静态绑定。C# 提供了两种技术来实现静态多态性。分别为&#xff1a; 函数重载 运算符重载 运算符重载将…
阅读更多...
MINT: Detecting Fraudulent Behaviors from Time-series Relational Data论文阅读笔记

MINT: Detecting Fraudulent Behaviors from Time-series Relational Data论文阅读笔记

2. 问题定义 时间序列关系数据&#xff08;Time Series Relation Data&#xff09; 这个数据是存放在关系型数据库中&#xff0c;每一条记录都是泰永时间搓的行为。 更具体地&#xff0c;每条记录表示为 x ( v , t , x 1 , x 2 , … , x m − 2 ) x (v,t,x_1,x_2,\dots,x…
阅读更多...
是德科技keysight N9917A微波分析仪

是德科技keysight N9917A微波分析仪

181/2461/8938产品概述&#xff1a; N9917A 是一款使用电池供电的便携式分析仪&#xff1b;基本功能是电缆和天线分析&#xff1b;配置还包括频谱和网络分析仪、可选的内置功率计和矢量电压表。 N9917A FieldFox 手持式微波分析仪 主要特性和功能 18 GHz 最大频率&#xfef…
阅读更多...
docker 容器挂掉，无法exec 进入bash 怎么修改容器里的文件

docker 容器挂掉，无法exec 进入bash 怎么修改容器里的文件

在使用tdengine 数据库时出现了 TDengine.Driver.TDengineError:“code:[0x334],error:Out of dnodes” 查找文档发现需要修改一个配置文件 。 /etc/taos/taos.cfg 中的 supportVnodes 参数 于是修改 保存。然后&#xff0c;运行出错。 03/21 06:56:27.986498 00000064 …
阅读更多...
UE5 C++增强输入

UE5 C++增强输入

一.创建charactor&#xff0c;并且包含增强输入相关的头文件 1.项目名.build.cs。添加模块“EnhancedInput”&#xff0c;方便找到头文件和映射的一些文件。 PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine&q…
阅读更多...
服务器总是宕机问题记录

服务器总是宕机问题记录

博主介绍&#xff1a; 22届计科专业毕业&#xff0c;来自湖南&#xff0c;主要是在CSDN记录一些自己在Java开发过程中遇到的一些问题&#xff0c;欢迎大家一起讨论学习&#xff0c;也欢迎大家的批评指正。 文章目录 背景调整总结 背景 2核2G的服务器&#xff0c;服务器安装了t…
阅读更多...
Spark Rebalance hint的倾斜的处理(OptimizeSkewInRebalancePartitions)

Spark Rebalance hint的倾斜的处理(OptimizeSkewInRebalancePartitions)

背景 本文基于Spark 3.5.0 目前公司在做小文件合并的时候用到了 Spark Rebalance 这个算子&#xff0c;这个算子的主要作用是在AQE阶段的最后写文件的阶段进行小文件的合并&#xff0c;使得最后落盘的文件不会太大也不会太小&#xff0c;从而达到小文件合并的作用&#xff0c;…
阅读更多...
CSS弹性盒模型（学习笔记）

CSS弹性盒模型（学习笔记）

一、厂商前缀 1.1 作用 解决浏览器对C3新特性的兼容&#xff0c;不同的浏览器厂商&#xff0c;定义了自己的厂商前缀 1.2 语法 浏览器 厂商前缀内核(渲染引擎)&#xff1a;解析htmlcssjs谷歌 -webkit-blink苹果-webkit-webkit欧朋-o-blink火狐 -moz-geckoIE-ms- trid…
阅读更多...
sentinel流控规则详解（图形化界面）

sentinel流控规则详解（图形化界面）

1、QPS 每秒的请求数&#xff0c;超过这个请求数&#xff0c;直接流控。 2、BlockException统一异常处理 2.1、创建异常返回类 Result.class public class Result<T> {private Integer code;private String msg;private T data;public Result(Integer code, String ms…
阅读更多...
算法设计与分析-贪心算法的应用动态规划算法的应用——沐雨先生

算法设计与分析-贪心算法的应用动态规划算法的应用——沐雨先生

1&#xff0e; 理解贪心算法的概念&#xff1b; 2&#xff0e;掌握贪心算法的基本思想。 &#xff08;1&#xff09;删数问题 问题描述&#xff1a;给定 n 位正整数 a &#xff0c;去掉其中任意 k ≤ n 个数字后&#xff0c;剩下的数字按原次序排列组成一个新的正整数。对于…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023