LeetCode 热题 100 | 图论（上）

news2025/1/23 3:15:13

目录

1  200. 岛屿数量

2  994. 腐烂的橘子

2.1  智障遍历法

2.2  仿层序遍历法

菜鸟做题，语言是 C++

1  200. 岛屿数量

解题思路：

  1. 遍历二维数组，寻找 “1”（若找到则岛屿数量 +1）
  2. 寻找与当前 “1” 直接或间接连接在一起的 “1”
  3. 将这些 “1” 置为 “0”，再寻找下一个 “1”

思路说明图：

如步骤 1 所示，我们找到 “1”（红框内部），它可以作为一个岛屿的开头。接下来，我们寻找与这个 “1” 直接或间接连接在一起的 “1”，如步骤 2 所示。这一坨 “1”（红框内部）构成一个岛屿。

直接连接 是指上下左右四个方向，斜对角方向的不算。

除此之外，为了避免我们下一次寻找 “1” 时，把这座岛屿内部的 “1” 视为下一个岛屿的开头，我们要将这些 “1” 置为 “0” 。

我们是对整个二维数组进行遍历的，若不在遍历完一座岛屿后将 “1” 置为 “0”，那么这座岛屿除开头之外的 “1” 会被误认为是下一座岛屿的开头。

具体代码：

① Find “1”：在二维数组中寻找 “1”，作为岛屿的开头。

for (int i = 0; i < nr; ++i) {
    for (int j = 0; j < nc; ++j) {
        if (grid[i][j] == '1') {
            ++count;
            helper(grid, i, j);
        }
    }
}

nr 是二维数组的行数，nc 是二维数组的列数。一旦找到 “1” 就 ++count，即认为找到了一座新的岛屿。同时，使用 helper 函数去寻找与当前 “1” 直接或间接连接在一起的 “1” 。

② Find Island：寻找与当前 “1” 直接或间接连接在一起的 “1”，它们构成一座岛屿。

void helper(vector<vector<char>>& grid, int r, int c) {
    int nr = grid.size();
    int nc = grid[0].size();

    grid[r][c] = '0';
    if (r - 1 >= 0 && grid[r - 1][c] == '1') helper(grid, r - 1, c);
    if (r + 1 < nr && grid[r + 1][c] == '1') helper(grid, r + 1, c);
    if (c - 1 >= 0 && grid[r][c - 1] == '1') helper(grid, r, c - 1);
    if (c + 1 < nc && grid[r][c + 1] == '1') helper(grid, r, c + 1);
}

这四个 if 其实就是做上下左右四个方向的边界判断，同时判断当前 “1” 的邻居是不是 “1” 。若找到相邻的 “1”，那么再递归寻找与相邻的 “1” 直接或间接连接在一起的 “1” 。

class Solution {
public:
    void helper(vector<vector<char>>& grid, int r, int c) {
        int nr = grid.size();
        int nc = grid[0].size();

        grid[r][c] = '0';
        if (r - 1 >= 0 && grid[r - 1][c] == '1') helper(grid, r - 1, c);
        if (r + 1 < nr && grid[r + 1][c] == '1') helper(grid, r + 1, c);
        if (c - 1 >= 0 && grid[r][c - 1] == '1') helper(grid, r, c - 1);
        if (c + 1 < nc && grid[r][c + 1] == '1') helper(grid, r, c + 1);
    }

    int numIslands(vector<vector<char>>& grid) {
        int nr = grid.size();
        if (nr == 0) return 0;
        int nc = grid[0].size();

        int count = 0;
        for (int i = 0; i < nr; ++i) {
            for (int j = 0; j < nc; ++j) {
                if (grid[i][j] == '1') {
                    ++count;
                    helper(grid, i, j);
                }
            }
        }
        return count;
    }
};

2  994. 腐烂的橘子

与  200. 岛屿数量  像又不像，区别在于是否有时间观念

2.1  智障遍历法

解题思路：

  1. 每个时刻都遍历二维数组，寻找腐烂的橘子（2）
  2. 对位于腐烂的橘子（2）四周的新鲜橘子（1）进行污染
  3. 直到所有新鲜橘子都被污染，或者无法继续污染

具体代码：

① 寻找腐烂的橘子（2），与 200 题的代码几乎一样。

for (int i = 0; i < nr; ++i) {
    for (int j = 0; j < nc; ++j) {
        if (temp[i][j] == 2)
            helper(grid, i, j);
    }
}

② 对位于腐烂的橘子（2）四周的新鲜橘子（1）进行污染。

void helper(vector<vector<int>>& grid, int r, int c) {
    if (r - 1 >= 0 && grid[r - 1][c] == 1) grid[r - 1][c] = 2;
    if (r + 1 < nr && grid[r + 1][c] == 1) grid[r + 1][c] = 2;
    if (c - 1 >= 0 && grid[r][c - 1] == 1) grid[r][c - 1] = 2;
    if (c + 1 < nc && grid[r][c + 1] == 1) grid[r][c + 1] = 2;
}

③ 判断是否所有的新鲜橘子（1）都被污染。

bool isRotted(vector<vector<int>>& grid) {
    for (int i = 0; i < nr; ++i) {
        for (int j = 0; j < nc; ++j) {
             if (grid[i][j] == 1) return false;
        }
    }
    return true;
}

④ 判断是否无法继续污染：在进行新一轮污染之前，先把上一轮的污染结果 grid 存入 temp 中，如果这一轮污染后有 temp == grid，则说明已经无法继续污染了。

vector<vector<int>> temp = grid;
for (int i = 0; i < nr; ++i) {
    for (int j = 0; j < nc; ++j) {
        if (temp[i][j] == 2)
            helper(grid, i, j);
    }
}
if (temp == grid) return -1;

这样做还有一个好处，就是可以通过 if (temp[i][j] == 2) 来寻找腐烂的橘子，避免在这一轮中新腐烂的橘子参与到污染中。

class Solution {
public:
    int nr, nc;
    void helper(vector<vector<int>>& grid, int r, int c) {
        if (r - 1 >= 0 && grid[r - 1][c] == 1) grid[r - 1][c] = 2;
        if (r + 1 < nr && grid[r + 1][c] == 1) grid[r + 1][c] = 2;
        if (c - 1 >= 0 && grid[r][c - 1] == 1) grid[r][c - 1] = 2;
        if (c + 1 < nc && grid[r][c + 1] == 1) grid[r][c + 1] = 2;
    }

    bool isRotted(vector<vector<int>>& grid) {
        for (int i = 0; i < nr; ++i) {
            for (int j = 0; j < nc; ++j) {
                if (grid[i][j] == 1) return false;
            }
        }
        return true;
    }

    int orangesRotting(vector<vector<int>>& grid) {
        nr = grid.size();
        nc = grid[0].size();

        int count = 0;
        while (!isRotted(grid)) {
            vector<vector<int>> temp = grid;
            for (int i = 0; i < nr; ++i) {
                for (int j = 0; j < nc; ++j) {
                    if (temp[i][j] == 2)
                        helper(grid, i, j);
                }
            }
            if (temp == grid) return -1;
            ++count;
            if (isRotted(grid)) return count;
        }
        return count;
    }
};

2.2  仿层序遍历法

参考官方题解进行了升级，仿二叉树的层序遍历，不用像 2.1 那样每次都进行全部遍历

核心思想：将属于同一时刻的腐烂橘子视为属于同一层。

上图画出了橘子逐步腐烂的 5 个时刻，每个时刻中打红叉的腐烂橘子属于同一层，打灰叉的腐烂橘子属于上一层。

解题思路：

  • 将属于同一时刻的腐烂橘子送入队列中
  • 出队并遍历属于同一时刻的腐烂橘子
  • 对四周的新鲜橘子进行污染并送入队列中

思路说明图：

对于时刻 1，让腐烂的橘子入队；对于时刻 2，队列中的腐烂橘子出队，让它们对四周的新鲜橘子进行污染，最后将新被污染的橘子入队。以此类推。

在一轮污染中，如果有橘子被污染，则计时器 +1，同时判断新鲜橘子是否被污染完毕；如果没有橘子被污染，则跳出循环，同时判断新鲜橘子是否被污染完毕。若没有橘子被污染且新鲜橘子没有被污染完毕，则表明无法污染所有新鲜橘子。

具体代码：

① 初始化：

  • 计数新鲜橘子的数量，即 freshCount + 1
  • 记录腐烂橘子的位置，即将横纵坐标送入队列中
int freshCount = 0;
queue<pair<int, int>> q;
for (int i = 0; i < nr; ++i) {
    for (int j = 0; j < nc; ++j) {
        if (grid[i][j] == 1) {
            ++freshCount;
        } else if (grid[i][j] == 2) {
            q.push(make_pair(i, j));
        }
    }
}

nr 是 grid 的行数，nc 是 grid 的列数。

② 循环结构和二叉树的层序遍历一模一样：

  • 获取当前层中腐烂橘子的个数
  • 遍历当前层中的腐烂橘子
while (!q.empty()) {
    int currentSize = q.size();
    for (int i = 0; i < currentSize; ++i) {
        pair<int, int> pos = q.front();
        q.pop();

        // 对橘子进行污染
    }
}

③ 针对每个腐烂橘子，对其四周进行污染：

  • 判断上/下/左/右位置是否越界，若越界则跳过该位置
  • 若该位置上的是新鲜橘子，则进行污染并将其入队
  • 同时将污染标志置为 true，新鲜橘子数量 - 1
for (int i = 0; i < 4; ++i) {
    int x = pos.first + dir_x[i];
    int y = pos.second + dir_y[i];
    if (x < 0|| x >= nr || y < 0|| y >= nc || grid[x][y] == 0)
        continue;
    if (grid[x][y] == 1) {
        hasPolluted = true;
        --freshCount;
        grid[x][y] = 2;
        q.push(make_pair(x, y));
    }
    if (freshCount == 0) break;
}

hasPolluted 用于表明当前层中是否至少有一个腐烂橘子造成了污染，如果没有造成污染，那么就要考虑是否无法污染所有新鲜橘子了。

class Solution {
public:
    int dir_x[4] = {0, 1, 0, -1};
    int dir_y[4] = {1, 0, -1, 0};
    int orangesRotting(vector<vector<int>>& grid) {
        int nr = grid.size();
        if (nr == 0) return 0;
        int nc = grid[0].size();

        int freshCount = 0;
        queue<pair<int, int>> q;
        for (int i = 0; i < nr; ++i) {
            for (int j = 0; j < nc; ++j) {
                if (grid[i][j] == 1) {
                    ++freshCount;
                } else if (grid[i][j] == 2) {
                    q.push(make_pair(i, j));
                }
            }
        }

        int timeCount = 0;
        int hasPolluted = false;
        while (!q.empty()) {
            int currentSize = q.size();
            for (int i = 0; i < currentSize; ++i) {
                pair<int, int> pos = q.front();
                q.pop();
                for (int i = 0; i < 4; ++i) {
                    int x = pos.first + dir_x[i];
                    int y = pos.second + dir_y[i];
                    if (x < 0|| x >= nr || y < 0|| y >= nc || grid[x][y] == 0)
                        continue;
                    if (grid[x][y] == 1) {
                        hasPolluted = true;
                        --freshCount;
                        grid[x][y] = 2;
                        q.push(make_pair(x, y));
                    }
                    if (freshCount == 0) break;
                }
            }
            if (hasPolluted) ++timeCount;
            hasPolluted = false;
        }
        return freshCount == 0 ? timeCount : -1;
    }
};

技能点：使用循环结构来测试上/下/左/右四个方位。

int dir_x[4] = {0, 1, 0, -1};
int dir_y[4] = {1, 0, -1, 0};

for (int i = 0; i < 4; ++i) {
    int x = pos.first + dir_x[i];
    int y = pos.second + dir_y[i];
    if (x < 0|| x >= nr || y < 0|| y >= nc)
    // ...
}

并且用逆否命题来作为判断条件，就不需要写很多 && 了！

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

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

相关文章

未来新质生产力Agent的起源与应用

未来新质生产力Agent的起源与应用

Agent是什么&#xff1f; AI Agent的发展经历了从哲学思想启蒙到计算机科学助力、专家系统兴起、机器学习崛起、深度学习突破等多个阶段。如今&#xff0c;AI Agent已经成为人工智能领域的重要组成部分&#xff0c;为人类带来了巨大的便利和发展机遇。早在古希腊时期&#xff0…
阅读更多...
《opencv实用探索·二十二》支持向量机SVM用法

《opencv实用探索·二十二》支持向量机SVM用法

1、概述 在了解支持向量机SVM用法之前先了解一些概念&#xff1a; &#xff08;1&#xff09;线性可分和线性不可分 如果在一个二维空间有一堆样本&#xff0c;如下图所示&#xff0c;如果能找到一条线把这两类样本分开至线的两侧&#xff0c;那么这个样本集就是线性可分&#…
阅读更多...
关于年化收益率的思考

关于年化收益率的思考

近期&#xff0c;对于投资的年化收益率有一些思考&#xff0c;想着将这些思考整理一下&#xff0c;顺便也就记录在这里。 1. 计算方式 年化收益率常见的计算有三种&#xff1a;算数平均&#xff0c;几何平均&#xff0c;IRR。 1.1 算术平均 算数平均用于度量产品的回报率&a…
阅读更多...
【Java EE初阶二十六】简单的表白墙（二）

【Java EE初阶二十六】简单的表白墙（二）

2. 后端服务器部分 2.1 服务器分析 2.2 代码编写 2.2.2 前端发起一个ajax请求 2.2.3 服务器读取上述请求,并计算出响应 服务器需要使用 jackson 读取到前端这里的数据,并且进行解析&#xff1a; 代码运行图&#xff1a; 2.2.4 回到前端代码&#xff0c;处理服务器返回的响应…
阅读更多...
vue项目从后端下载文件显示进度条或者loading

vue项目从后端下载文件显示进度条或者loading

//API接口 export const exportDownload (params?: Object, peCallback?: Function) > {return new Promise((resolve, reject) > {axios({method: get,url: ,headers: {access_token: ${getToken()},},responseType: blob,params,onDownloadProgress: (pe) > {peC…
阅读更多...
Flutter（三）：Stack、Positioned、屏幕相关尺寸、Navigator路由跳转

Flutter（三）：Stack、Positioned、屏幕相关尺寸、Navigator路由跳转

页面尺寸 通知栏高度&#xff1a;MediaQuery.of(context).padding.top顶部导航高度&#xff1a;kToolbarHeight底部导航高度&#xff1a;kBottomNavigationBarHeight屏幕宽&#xff1a;MediaQuery.of(context).size.width屏幕高&#xff1a;MediaQuery.of(context).size.height…
阅读更多...
SpringMVC 学习（十）之异常处理

SpringMVC 学习（十）之异常处理

目录 1 异常处理介绍 2 通过 SimpleMappingExceptionResolver 实现 3 通过接口 HandlerExceptionResolver 实现 4 通过 ExceptionHandler 注解实现&#xff08;推荐&#xff09; 1 异常处理介绍 在 SpringMVC中&#xff0c;异常处理器&#xff08;Exceptio…
阅读更多...
项目解决方案：海外门店视频汇聚方案（全球性的连锁店、国外连锁店视频接入和汇聚方案）

项目解决方案：海外门店视频汇聚方案（全球性的连锁店、国外连锁店视频接入和汇聚方案）

目 录 一、概述 二、建设目标及需求 2.1 建设目标 2.2 需求描述 2.3 需求分析 三、建设方案设计 3.1 系统方案拓扑图 3.2 方案描述 3.3 服务器配置推荐 四、产品功能 4.1 资源管理平台 &#xff08;1&#xff09;用户权限管理 &#xff08;2&#xff09…
阅读更多...
AD9226 65M采样 模数转换

AD9226 65M采样 模数转换

目录 AD9220_ReadTEST AD9220_ReadModule AD9226_TEST_tb 自己再写个 260M的时钟&#xff0c;四分频来提供65M的时钟。 用 vivado 写的 AD9226_ReadTEST module AD9226_ReadTEST( input clk, input rstn,output clk_driver, //模块时钟管脚 input [12:0]IO_data, //模块数…
阅读更多...
LACP——链路聚合控制协议

LACP——链路聚合控制协议

LACP——链路聚合控制协议 什么是LACP&#xff1f; LACP&#xff08;Link Aggregation Control Protocol&#xff0c;链路聚合控制协议&#xff09;是一种基于IEEE802.3ad标准的实现链路动态聚合与解聚合的协议&#xff0c;它是链路聚合中常用的一种协议。 链路聚合组中启用了…
阅读更多...
Linux运维-Web服务器的配置与管理(Apache+tomcat)（没成功，最后有失败经验）

Linux运维-Web服务器的配置与管理(Apache+tomcat)（没成功，最后有失败经验）

Web服务器的配置与管理(Apachetomcat) 项目场景 公司业务经过长期发展&#xff0c;有了很大突破&#xff0c;已经实现盈利&#xff0c;现公司要求加强技术架构应用功能和安全性以及开始向企业应用、移动APP等领域延伸&#xff0c;此时原来开发web服务的php语言已经不适应新的…
阅读更多...
云服务器ECS价格表出炉_2024年最新价格表——阿里云

云服务器ECS价格表出炉_2024年最新价格表——阿里云

2024年最新阿里云服务器租用费用优惠价格表&#xff0c;轻量2核2G3M带宽轻量服务器一年61元&#xff0c;折合5元1个月&#xff0c;新老用户同享99元一年服务器&#xff0c;2核4G5M服务器ECS优惠价199元一年&#xff0c;2核4G4M轻量服务器165元一年&#xff0c;2核4G服务器30元3…
阅读更多...
高防IP简介

高防IP简介

高防IP可以防御的有包括但不限于以下类型&#xff1a; SYN Flood、UDP Flood、ICMP Flood、IGMP Flood、ACK Flood、Ping Sweep 等攻击。高防IP专注于解决云外业务遭受大流量DDoS攻击的防护服务。支持网站和非网站类业务的DDoS、CC防护&#xff0c;用户通过配置转发规则&#x…
阅读更多...
Nginx反向代理ip透传与负载均衡

Nginx反向代理ip透传与负载均衡

前言 上篇介绍了nginx服务器单向代理和动静分离等相关内容&#xff0c;可参考Nginx重写功能和反向代理-CSDN博客&#xff0c;这里就ip透传和负载均衡对nginx反向代理做进一步了解。 目录 一、客户端ip透传 1. 概述 2. 一级代理 2.1 图示 2.2 操作过程 3. 二级代理 3.…
阅读更多...
type may not be empty [type-empty]

type may not be empty [type-empty]

原因是使用了规范commit信息的工具&#xff0c;你的提交信息不符合规范&#xff0c;所以被拒绝了 commit规范工具 commitlinthusky 解决方式一&#xff1a; 修改提交信息&#xff0c; 使其符合规范 git commit -m "feat: 新功能"使用Git Gui的使用以下格式写提交…
阅读更多...
wu-framework-parent 项目明细

wu-framework-parent 项目明细

wu-framework-parent 介绍 springboot 版本3.2.1 wu-framework-parent 是一款由Java语言开发的框架&#xff0c;目标不写代码但是却能完成功能。 框架涵盖无赖ORM( wu-database-lazy-starter)、仿生组件 、easy框架系列【Easy-Excel、easy-listener、easy-upsert】 授权框架(…
阅读更多...
华为ipv6 over ipv4 GRE隧道配置

华为ipv6 over ipv4 GRE隧道配置

思路&#xff1a; PC1访问PC2时&#xff0c;会先构造源ipv6为2001:1::2&#xff0c;目的IPV6为2001:2::2的ipv6报文&#xff0c;然后查看PC1的路由表&#xff0c;发送到R1&#xff0c;r1接收后&#xff0c;以目的IPV6地址2001:2::2查询IPV6路由表&#xff0c;出接口为tun0/0/0…
阅读更多...
C++ 补充之常用遍历算法

C++ 补充之常用遍历算法

C遍历算法和原理 C标准库提供了丰富的遍历算法&#xff0c;涵盖了各种不同的功能。以下是一些常见的C遍历算法以及它们的概念和原理的简要讲解&#xff1a; for_each&#xff1a;对容器中的每个元素应用指定的函数。 概念&#xff1a;对于给定的容器和一个可调用对象&#xff…
阅读更多...
jenkins+kubernetes+git+dockerhub构建devops云平台

jenkins+kubernetes+git+dockerhub构建devops云平台

Devops简介 k8s助力Devops在企业落地实践 传统方式部署项目为什么发布慢&#xff0c;效率低&#xff1f; 上线一个功能&#xff0c;有多少时间被浪费了&#xff1f; 如何解决发布慢&#xff0c;效率低的问题呢&#xff1f; 什么是Devops&#xff1f; 敏捷开发 提高开发效率&…
阅读更多...
Linux中数据库sqlite3的基本命令的使用

Linux中数据库sqlite3的基本命令的使用

数据库概念介绍 数据库安装 首先将本地的三个sqlite3安装包移动到共享文件夹然后在移动到自己创建的文件夹中如下&#xff1a; 然后对安装包进行解压如下&#xff1a;sudo dpkg -i *.deb检查是否安装成功sqlite数据库命令 系统命令 &#xff0c; 都以’.开头 .exit .quit .…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023