LeetCode —— dfs和bfs

news2024/11/18 13:41:10

797. 所有可能的路径

给你一个有 n 个节点的 有向无环图（DAG），请你找出所有从节点 0 到节点 n-1 的路径并输出（不要求按特定顺序）。 graph[i] 是一个从节点 i 可以访问的所有节点的列表（即从节点 i 到节点 graph[i][j]存在一条有向边）。

示例1：输入：graph = [[1,2],[3],[3],[]]         输出：[[0,1,3],[0,2,3]] 

示例2：输入：graph = [[4,3,1],[3,2,4],[3],[4],[]]      输出：[[0,4],[0,3,4],[0,1,3,4],[0,1,2,3,4],[0,1,4]]

// dfs
class Solution {
    List<List<Integer>> list = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();

    public List<List<Integer>> allPathsSourceTarget(int[][] graph) {
        path.add(0);
        dfs(graph, 0);
        return list;
    }

    public void dfs(int[][] graph, int node){
        if(node == graph.length - 1){
            list.add(new ArrayList<>(path));
            return;
        }

        for(int i = 0; i < graph[node].length; i++){
            path.add(graph[node][i]);
            dfs(graph, graph[node][i]);
            path.removeLast();
        }
    }
}

200. 岛屿数量

给你一个由 '1'（陆地）和 '0'（水）组成的的二维网格，请你计算网格中岛屿的数量。岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。此外，你可以假设该网格的四条边均被水包围。

示例1：

输入：grid = [
  ["1","1","1","1","0"],
  ["1","1","0","1","0"],
  ["1","1","0","0","0"],
  ["0","0","0","0","0"]
]
输出：1

// dfs
class Solution {
    public int numIslands(char[][] grid) {
        int count = 0;
        for(int i = 0; i < grid.length; i++){
            for(int j = 0; j < grid[0].length; j++){
                if(grid[i][j] == '1'){
                    count++;
                    dfs(grid, i, j);
                }
            }
        }
        return count;
    }

    public void dfs(char[][] grid, int i, int j){
        if(i < 0 || i >= grid.length || j < 0 || j >= grid[0].length || grid[i][j] == '0'){
            return;
        }
        grid[i][j] = '0';
        dfs(grid, i - 1, j);
        dfs(grid, i + 1, j);
        dfs(grid, i, j - 1);
        dfs(grid, i, j + 1);
    }
}
// bfs
class Solution {
    public int numIslands(char[][] grid) {
        int count = 0;
        for(int i = 0; i < grid.length; i++){
            for(int j = 0; j < grid[0].length; j++){
                if(grid[i][j] == '1'){
                    count++;
                    bfs(grid, i, j);
                }
            }
        }
        return count;
    }

    public void bfs(char[][] grid, int i, int j){
        Queue<int[]> queue = new LinkedList<>();
        queue.offer(new int[]{i, j});
        while(!queue.isEmpty()){
            int[] cur = queue.poll();
            i = cur[0];
            j = cur[1];
            if(i >= 0 && i < grid.length && j >= 0 && j < grid[0].length && grid[i][j] == '1'){
                grid[i][j] = '0';
                queue.offer(new int[]{i - 1, j});
                queue.offer(new int[]{i + 1, j});
                queue.offer(new int[]{i, j - 1});
                queue.offer(new int[]{i, j + 1});
            }
        }
    }
}

695. 岛屿的最大面积

给你一个大小为 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
// dfs
class Solution {
    int area;
    public int maxAreaOfIsland(int[][] grid) {
        int maxArea = 0;
        for(int i = 0; i < grid.length; i++){
            for(int j = 0; j < grid[0].length; j++){
                if(grid[i][j] == 1){
                    area = 0;
                    dfs(grid, i, j);
                    maxArea = Math.max(maxArea, area);
                }
            }
        }
        return maxArea;
    }

    public void dfs(int[][] grid, int i, int j){
        if(i < 0 || i >= grid.length || j < 0 || j >= grid[0].length || grid[i][j] == 0){
            return;
        }
        area++;
        grid[i][j] = 0;
        dfs(grid, i - 1, j);
        dfs(grid, i + 1, j);
        dfs(grid, i, j - 1);
        dfs(grid, i, j + 1);
    }
}
// bfs
class Solution {
    int area;
    public int maxAreaOfIsland(int[][] grid) {
        int maxArea = 0;
        for(int i = 0; i < grid.length; i++){
            for(int j = 0; j < grid[0].length; j++){
                if(grid[i][j] == 1){
                    area = 0;
                    bfs(grid, i, j);
                    maxArea = Math.max(maxArea, area);
                }
            }
        }
        return maxArea;
    }

    public void bfs(int[][] grid, int i, int j){
        Queue<int[]> queue = new LinkedList<>();
        queue.offer(new int[]{i, j});
        while(!queue.isEmpty()){
            int[] cur = queue.poll();
            i = cur[0];
            j = cur[1];
            if(i >= 0 && i < grid.length && j >= 0 && j < grid[0].length && grid[i][j] == 1){
                area++;
                grid[i][j] = 0;
                queue.offer(new int[]{i - 1, j});
                queue.offer(new int[]{i + 1, j});
                queue.offer(new int[]{i, j - 1});
                queue.offer(new int[]{i, j + 1});
            }
        }
    }
}

1020. 飞地的数量

给你一个大小为 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

// dfs
class Solution {
    public int numEnclaves(int[][] grid) {
        for(int i = 0; i < grid.length; i++){   
            if(grid[i][0] == 1){      // 左侧
                dfs(grid, i, 0);
            }
            if(grid[i][grid[0].length - 1] == 1){     // 右侧
                dfs(grid, i, grid[0].length - 1);
            }
        }
        for(int j = 1; j < grid[0].length - 1; j++){    
            if(grid[0][j] == 1){      // 上侧
                dfs(grid, 0, j);
            }
            if(grid[grid.length - 1][j] == 1){      // 下侧
                dfs(grid, grid.length - 1, j);
            }
        }

        int count = 0;
        for(int i = 0; i < grid.length; i++){
            for(int j = 0; j < grid[0].length; j++){
                if(grid[i][j] == 1){
                    count++;
                }
            }
        }
        return count;
    }

    public void dfs(int[][] grid, int i, int j){
        if(i < 0 || i >= grid.length || j < 0 || j >= grid[0].length || grid[i][j] == 0){
            return;
        }
        grid[i][j] = 0;
        dfs(grid, i - 1, j);
        dfs(grid, i + 1, j);
        dfs(grid, i, j - 1);
        dfs(grid, i, j + 1);
    }
}
// bfs
class Solution {
    public int numEnclaves(int[][] grid) {
        for(int i = 0; i < grid.length; i++){
            if(grid[i][0] == 1){      // 左侧
                bfs(grid, i, 0);
            }
            if(grid[i][grid[0].length - 1] == 1){     // 右侧
                bfs(grid, i, grid[0].length - 1);
            }
        }
        for(int j = 1; j < grid[0].length - 1; j++){
            if(grid[0][j] == 1){      // 上侧
                bfs(grid, 0, j);
            }
            if(grid[grid.length - 1][j] == 1){      // 下侧
                bfs(grid, grid.length - 1, j);
            }
        }

        int count = 0;
        for(int i = 0; i < grid.length; i++){
            for(int j = 0; j < grid[0].length; j++){
                if(grid[i][j] == 1){
                    count++;
                }
            }
        }
        return count;
    }

    public void bfs(int[][] grid, int i, int j){
        Queue<int[]> queue = new LinkedList<>();
        queue.offer(new int[]{i, j});
        while(!queue.isEmpty()){
            int[] cur = queue.poll();
            i = cur[0];
            j = cur[1];
            if(i >= 0 && i < grid.length && j >= 0 && j < grid[0].length && grid[i][j] == 1){
                grid[i][j] = 0;
                queue.offer(new int[]{i - 1, j});
                queue.offer(new int[]{i + 1, j});
                queue.offer(new int[]{i, j - 1});
                queue.offer(new int[]{i, j + 1});
            }
        }
    }
}

130. 被围绕的区域

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

// dfs
class Solution {
    public void solve(char[][] board) {
        for(int i = 0; i < board.length; i++){
            if(board[i][0] == 'O'){
                dfs(board, i, 0);
            }
            if(board[i][board[0].length - 1] == 'O'){
                dfs(board, i, board[0].length - 1);
            }
        }

        for(int j = 1; j < board[0].length - 1; j++){
            if(board[0][j] == 'O'){
                dfs(board, 0, j);
            }
            if(board[board.length - 1][j] == 'O'){
                dfs(board, board.length - 1, j);
            }
        }

        for(int i = 0; i < board.length; i++){
            for(int j = 0; j < board[0].length; j++){
                if(board[i][j] == 'A'){
                    board[i][j] = 'O';
                }else if(board[i][j] == 'O'){
                    board[i][j] = 'X';
                }
            }
        }
    }

    public void dfs(char[][] board, int i, int j){
        if(i < 0 || i >= board.length || j < 0 || j >= board[0].length || board[i][j] == 'X' 
             || board[i][j] == 'A'){
            return;
        }
        board[i][j] = 'A';
        dfs(board, i - 1, j);
        dfs(board, i + 1, j);
        dfs(board, i, j - 1);
        dfs(board, i, j + 1);
    }
}
// bfs
class Solution {
    public void solve(char[][] board) {
        for(int i = 0; i < board.length; i++){
            if(board[i][0] == 'O'){
                bfs(board, i, 0);
            }
            if(board[i][board[0].length - 1] == 'O'){
                bfs(board, i, board[0].length - 1);
            }
        }

        for(int j = 1; j < board[0].length - 1; j++){
            if(board[0][j] == 'O'){
                bfs(board, 0, j);
            }
            if(board[board.length - 1][j] == 'O'){
                bfs(board, board.length - 1, j);
            }
        }

        for(int i = 0; i < board.length; i++){
            for(int j = 0; j < board[0].length; j++){
                if(board[i][j] == 'A'){
                    board[i][j] = 'O';
                }else if(board[i][j] == 'O'){
                    board[i][j] = 'X';
                }
            }
        }
    }

    public void bfs(char[][] board, int i, int j){
        Queue<int[]> queue = new LinkedList<>();
        queue.offer(new int[]{i, j});
        while(!queue.isEmpty()){
            int[] cur = queue.poll();
            i = cur[0];
            j = cur[1];
            if(i >= 0 && i < board.length && j >= 0 && j < board[0].length && board[i][j] == 'O'){
                board[i][j] = 'A';
                queue.offer(new int[]{i - 1, j});
                queue.offer(new int[]{i + 1, j});
                queue.offer(new int[]{i, j - 1});
                queue.offer(new int[]{i, j + 1});
            }
        }
    }
}

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

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

相关文章

【斗罗二】天梦哥告白冰帝，唐三再返场，雨浩通过冰帝考验，觉醒新武魂

【斗罗二】天梦哥告白冰帝，唐三再返场，雨浩通过冰帝考验，觉醒新武魂

Hello,小伙伴们&#xff0c;我是小郑继续为大家深度解析斗罗大陆2绝世唐门国漫资讯。 斗罗大陆动画第二部绝世唐门第19集已经更新了&#xff0c;全都是霍雨浩与天梦哥在极北之地&#xff0c;吸引冰帝加入造神计划的过程。不仅有天梦哥的爱情宣言告白&#xff0c;唐三也再次限时…
阅读更多...
设计模式_备忘录模式

设计模式_备忘录模式

备忘录模式 介绍 设计模式定义案例问题堆积在哪里解决办法备忘录模式行为型模式&#xff0c; 保存了数据某一个时间点的状态 在需要的时候进行回档单机游戏的角色 数据保存并且回档保存和回档加一个状态管理类 类图 代码 MomentData using UnityEngine;public class MomentD…
阅读更多...
SLAM从入门到精通（从仿真到实践）

SLAM从入门到精通（从仿真到实践）

【 声明&#xff1a;版权所有&#xff0c;欢迎转载&#xff0c;请勿用于商业用途。 联系信箱&#xff1a;feixiaoxing 163.com】 之前花了40多篇文章&#xff0c;弄清了什么是slam&#xff0c;怎么学习slam&#xff0c;什么是ros&#xff0c;怎么利用ros来学好slam等等。不仅如…
阅读更多...
云安全(1)--初识容器逃逸之特权容器逃逸

云安全(1)--初识容器逃逸之特权容器逃逸

文章目录 前言privileged,特权容器逃逸环境配置实际利用实际环境利用计划任务/var/spool/cron/crontabs/ 适用于ubuntu debain/var/spool/cron 适用于centos ld.so.preloadssh 前言 在10.15号的上海中华武数杯的渗透赛里做到了一个k8s的题目&#xff0c;这应该是我第一次在比赛…
阅读更多...
13.3测试用例进阶

13.3测试用例进阶

一.测试对象划分 1.界面测试(参考软件规格说明书和UI视觉稿) a.什么是界面 1)WEB站(浏览器) 2)app 3)小程序 4)公众号 b.测试内容 1)界面内容显示的一致性,完整性,准确性,友好性.比如界面内容对屏幕大小的自适应,换行,内容是否全部清晰展示. 2)验证整个界面布局和排版…
阅读更多...
【数据结构】线性表（七）堆栈：链式栈及其基本操作（初始化、判空、入栈、出栈、存取栈顶元素、清空栈）；顺序栈与链式栈之比较

【数据结构】线性表（七）堆栈：链式栈及其基本操作（初始化、判空、入栈、出栈、存取栈顶元素、清空栈）；顺序栈与链式栈之比较

文章目录 一、堆栈1. 定义2. 基本操作 二、顺序栈三、链式栈0. 链表1. 头文件和常量2. 栈结构体3. 栈的初始化4. 判断栈是否为空5. 入栈6. 出栈7. 存取栈顶元素8. 清空栈9. 主函数10. 代码整合 四、 顺序栈与链式栈的比较 堆栈&#xff08;Stack&#xff09;和队列&#xff08;…
阅读更多...
Linux MMC子系统 - 1.eMMC简介

Linux MMC子系统 - 1.eMMC简介

By: Ailson Jack Date: 2023.10.21 个人博客&#xff1a;http://www.only2fire.com/ 本文在我博客的地址是&#xff1a;http://www.only2fire.com/archives/160.html&#xff0c;排版更好&#xff0c;便于学习&#xff0c;也可以去我博客逛逛&#xff0c;兴许有你想要的内容呢。…
阅读更多...
JAVA基础-数据类型(2)

JAVA基础-数据类型(2)

目录 1、基本数据类型2、引用数据类型3、类型默认值4、数据类型的转换4.1、自动类型转换4.2、强制类型转换4.3、隐含强制类型转换 1、基本数据类型 :::tips Java语言提供了八种基本类型。六种数字类型&#xff08;四个整数型&#xff0c;两个浮点型&#xff09;&#xff0c;一…
阅读更多...
C++多重、多层、分层继承

C++多重、多层、分层继承

在本文中&#xff0c;您将学习C 编程中的不同继承模型&#xff1a;带有示例的多继承&#xff0c;多层和分层继承。 继承是面向对象编程语言的核心功能之一。它允许软件开发人员从现有的类派生一个新的类。派生类继承基类&#xff08;现有类&#xff09;的功能。C 编程中有多种…
阅读更多...
逗号表达式

逗号表达式

#include<stdio.h> int cmp() {return(2,1); } int main() {int z cmp();printf("%d",z);return 0; } 逗号表达式括号里的优先级是自左向右&#xff0c;最后一个值为最终的结果。
阅读更多...
YOLOv5改进实战 | 更换主干网络Backbone（四）之轻量化模型MobileNetV3

YOLOv5改进实战 | 更换主干网络Backbone（四）之轻量化模型MobileNetV3

前言 轻量化网络设计是一种针对移动设备等资源受限环境的深度学习模型设计方法。下面是一些常见的轻量化网络设计方法： 网络剪枝：移除神经网络中冗余的连接和参数，以达到模型压缩和加速的目的。分组卷积：将卷积操作分解为若干个较小的卷积操作，并将它们分别作用于输入的不…
阅读更多...
东信智能：嵌入式内置式身份证阅读器微模块技术参数，和之前的大模块、小模块有什么区别研究

东信智能：嵌入式内置式身份证阅读器微模块技术参数，和之前的大模块、小模块有什么区别研究

身份证读卡器模块总共分为4种&#xff1a; 1、0503大模块&#xff0c;尺寸大&#xff0c;可读完整信息。 2、0513小模块&#xff0c;尺寸中等&#xff0c;可读完整信息。 3、微模块&#xff0c;尺寸小&#xff0c;只用于比对。 4、SDT88-FR嵌入式模块&#xff0c;尺寸小&am…
阅读更多...
“控制情绪，理性交流”刍议

“控制情绪，理性交流”刍议

今天&#xff0c;本“人民体验官”还是回避推广人民日报官方微博文化产品《走出低谷期的9个习惯》。 截图&#xff1a;来源“人民体验官”推广平台 ​之前&#xff0c;由于笔者读过《人民日报》曾经发表过的关于“学会管理情绪 ”的文章&#xff0c;对文章中这些观点深表认同&…
阅读更多...
DJYOS物联屏：工业HMI里的显控异构计算的超稳定解决方案

DJYOS物联屏：工业HMI里的显控异构计算的超稳定解决方案

1、超稳定性&#xff1a;DJYOS物联屏的超稳定依赖于都江堰泛计算操作系统天然支持多核、多机的异构计算能力&#xff0c;可以一核运行HMI、一核运行控制程序&#xff0c;多核之间可以通过djyos的异构计算去中心化运行&#xff08;确保各自程序不干扰运行&#xff09;&#xff0…
阅读更多...
存储器~Zynq book第九章

存储器~Zynq book第九章

还有小梅哥和正点原子的一些资料。 DRAM SRAM Cache SDRAM SDRAM学习与实现串口传图-CSDN博客 DDR3
阅读更多...
【算法训练-动态规划 零】动态规划解题框架

【算法训练-动态规划 零】动态规划解题框架

动态规划问题的一般形式就是求最值。动态规划其实是运筹学的一种最优化方法&#xff0c;只不过在计算机问题上应用比较多&#xff0c;比如说求最长递增子序列呀&#xff0c;最小编辑距离呀等等。 既然是要求最值&#xff0c;核心问题是什么呢&#xff1f;求解动态规划的核心问…
阅读更多...
C++ 使用httplib库，发送HTTP请求

C++ 使用httplib库，发送HTTP请求

简介 C 使用httplib库&#xff0c;发送HTTP请求 接口信息 ip地址 192.168.16.166 端口 8899 接口地址/abc/tk 请求方式GET 响应内容&#xff1a; { “result”: true, “message”: “”, “tk”: “yueguangsaxialexiangshuitan0ihai”, “datetimeout”: “2023-10-22 21…
阅读更多...
2023年中国预缩机产量、需求量及市场规模分析[图]

2023年中国预缩机产量、需求量及市场规模分析[图]

预缩机是一种用于压缩气体的机械设备&#xff0c;通过减小气体的体积&#xff0c;增加气体的压力。预缩机通常由压缩机、电机、冷却系统和控制系统等组成&#xff0c;广泛应用于空调、制冷、工业生产等领域。 预缩机行业分类 资料来源&#xff1a;共研产业咨询&#xff08;共研…
阅读更多...
LightDM Greeter的启动流程与分析

LightDM Greeter的启动流程与分析

重要的概念 LightDM Greeter是什么&#xff1f;它是一个登录管理器&#xff0c;用于在Ubuntu或其他基于Linux的操作系统中管理用户登录。它提供了一个图形化用户界面&#xff0c;用户可以在其中输入他们的用户名和密码以及选择登录的桌面环境。LightDM Greeter还提供了可定制的…
阅读更多...
设计模式_中介者模式

设计模式_中介者模式

中介者模式 介绍 设计模式定义案例问题堆积在哪里解决办法中介者代替了多个对象之间的互动 使对象1 2 3 之间的互动 变为&#xff1a; 对象1->中介 对象2->中介 对象3->中介好友之间 约饭好友1 通知 好友2 -3 -4 等等加一个群 谁想吃饭就 通知一下 类图 代码 角色 …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023