代码随想录算法训练营第五十一天| 98. 所有可达路径、99. 岛屿数量 深搜版、99. 岛屿数量 广搜版

已于 2024-06-27 23:53:37 修改
阅读量690 收藏 15
点赞数 10
文章标签： 算法
于 2024-06-27 23:42:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dreamtang/article/details/140025459
版权

[KamaCoder] 98. 所有可达路径

[KamaCoder] 98. 所有可达路径 文章解释

题目描述

给定一个有 n 个节点的有向无环图，节点编号从 1 到 n。请编写一个函数，找出并返回所有从节点 1 到节点 n 的路径。每条路径应以节点编号的列表形式表示。

输入描述

第一行包含两个整数 N，M，表示图中拥有 N 个节点，M 条边

后续 M 行，每行包含两个整数 s 和 t，表示图中的 s 节点与 t 节点中有一条路径

输出描述

输出所有的可达路径，路径中所有节点之间空格隔开，每条路径独占一行，存在多条路径，路径输出的顺序可任意。如果不存在任何一条路径，则输出 -1。

注意输出的序列中，最后一个节点后面没有空格！ 例如正确的答案是 `1 3 5`,而不是 `1 3 5 `， 5后面没有空格！

输入示例
5 5
1 3
3 5
1 2
2 4
4 5
输出示例
1 3 5
1 2 4 5

用例解释：

有五个节点，其中的从 1 到达 5 的路径有两个，分别是 1 -> 3 -> 5 和 1 -> 2 -> 4 -> 5。

因为拥有多条路径，所以输出结果为：

1 3 5
1 2 4 5

或

1 2 4 5
1 3 5
都算正确。

数据范围：

  • 图中不存在自环
  • 图中不存在平行边
  • 1 <= N <= 100
  • 1 <= M <= 500

[KamaCoder] 98. 所有可达路径

自己看到题目的第一想法

    无, 最近越来越不自己思考了, 有赶进度的因素.

看完代码随想录之后的想法

    递归遍历当前节点所有可达的节点, 直到抵达终点, 或者走到无法继续往前走的节点位置. dfs 表示深度搜索, bfs 表示广度搜索.

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;

// 邻接表 dfs
public class Main {
    private static final List<List<Integer>> result = new ArrayList<>();
    private static List<Integer> path = new ArrayList<>();
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Map<Integer, Set<Integer>> nodes = new HashMap<>();
        int nodeCount = 0;
        int sideCount = 0;
        while (scanner.hasNext()) {
            nodeCount = scanner.nextInt();
            sideCount = scanner.nextInt();
            for (int i = 0; i < sideCount; i++) {
                int node = scanner.nextInt();
                Set<Integer> toNodes = nodes.get(node);
                if (toNodes == null) {
                    toNodes = new HashSet<Integer>();
                    nodes.put(node, toNodes);
                }
                toNodes.add(scanner.nextInt());
            }
        }
        path.add(1);
        dfs(nodes, 1, nodeCount);
        // path.remove(path.size() - 1);
        if (result.size() == 0) {
            System.out.println("-1");
            return;
        }
        for (int i = 0; i < result.size(); i++) {
            path = result.get(i);
            for (int j = 0; j < path.size() - 1; j++) {
                System.out.print(path.get(j) + " ");
            }
            System.out.println(path.get(path.size() - 1));
        }
    }
    
    private static void dfs(Map<Integer, Set<Integer>> nodes, int from, int destination) {
        if (from == destination) {
            result.add(new ArrayList<>(path));
            return;
        }
        Set<Integer> toNodes = nodes.get(from);
        if (toNodes == null) {
            return;
        }
        for (Integer toNode : toNodes) {
            path.add(toNode);
            dfs(nodes, toNode, destination);
            path.remove(path.size() - 1);
        }
    }
}
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;

// 邻接矩阵 dfs
public class Main {
    private static final List<List<Integer>> result = new ArrayList<>();
    private static List<Integer> path = new ArrayList<>();
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int[][] nodes = null;
        int nodeCount = 0;
        int sideCount = 0;
        while (scanner.hasNext()) {
            nodeCount = scanner.nextInt();
            sideCount = scanner.nextInt();
            nodes = new int[nodeCount + 1][nodeCount + 1];
            for (int i = 0; i < sideCount; i++) {
                nodes[scanner.nextInt()][scanner.nextInt()] = 1;
            }
        }
        path.add(1);
        dfs(nodes, 1, nodeCount);
        // path.remove(path.size() - 1);
        if (result.size() == 0) {
            System.out.println("-1");
            return;
        }
        for (int i = 0; i < result.size(); i++) {
            path = result.get(i);
            for (int j = 0; j < path.size() - 1; j++) {
                System.out.print(path.get(j) + " ");
            }
            System.out.println(path.get(path.size() - 1));
        }
    }
    
    private static void dfs(int[][] nodes, int from, int destination) {
        if (from == destination) {
            result.add(new ArrayList<>(path));
            return;
        }
        for (int i = 1; i < nodes[from].length; i++) {
            if (nodes[from][i] != 1) {
                continue;
            }
            path.add(i);
            dfs(nodes, i, destination);
            path.remove(path.size() - 1);
        }
    }
}

自己实现过程中遇到哪些困难

    搜索路径可以用广度优先搜索吗?

[LeetCode] 99. 岛屿数量

[LeetCode] 99. 岛屿数量 文章解释

题目描述

给定一个由 1（陆地）和 0（水）组成的矩阵，你需要计算岛屿的数量。岛屿由水平方向或垂直方向上相邻的陆地连接而成，并且四周都是水域。你可以假设矩阵外均被水包围。

输入描述

第一行包含两个整数 N, M，表示矩阵的行数和列数。

后续 N 行，每行包含 M 个数字，数字为 1 或者 0。

输出描述

输出一个整数，表示岛屿的数量。如果不存在岛屿，则输出 0。

输入示例
4 5
1 1 0 0 0
1 1 0 0 0
0 0 1 0 0
0 0 0 1 1
输出示例
3

根据测试案例中所展示，岛屿数量共有 3 个，所以输出 3。

数据范围：

1 <= N, M <= 50

[LeetCode] 99. 岛屿数量 深搜版

自己看到题目的第一想法

    这个基础题我会~

看完代码随想录之后的想法

import java.util.ArrayList;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;

// 邻接矩阵 dfs
public class Main {
    private static int[][] dir = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    private static boolean[][] visited;
    private static int result = 0;
    private static int rowCount = 0;
    private static int columnCount = 0;
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int[][] nodes = null;
        int result = 0;
        
        while (scanner.hasNext()) {
            rowCount = scanner.nextInt();
            columnCount = scanner.nextInt();
            nodes = new int[rowCount][columnCount]; 
            visited = new boolean[rowCount][columnCount];
            for (int i = 0; i < rowCount; i++) {
                for (int j = 0; j < columnCount; j++) {
                    nodes[i][j] = scanner.nextInt();
                }
            }
        }
        for (int i = 0; i < rowCount; i++) {
            for (int j = 0; j < columnCount; j++) {
                if (visited[i][j] || nodes[i][j] != 1) {
                    continue;
                }
                result++;
                dfs(nodes, visited, i, j);
            }
        }
        System.out.print(result);
    }
    private static void dfs(int[][] nodes, boolean[][] visited, int x, int y) {
        visited[x][y] = true;
        int newX;
        int newY;
        for (int i = 0; i < dir.length; i++) {
            newX = x + dir[i][0];
            newY = y + dir[i][1];
            if (newX < 0 || newX >= nodes.length || newY < 0 || newY >= nodes[newX].length) {
                // 超出范围
                continue;
            }
            if (visited[newX][newY] || nodes[newX][newY] != 1) {
                // 标记过了, 或者非陆地, 不处理
                continue;
            }
            dfs(nodes, visited, newX, newY);
        }
    }
}

自己实现过程中遇到哪些困难

    无.

[LeetCode] 99. 岛屿数量

[LeetCode] 99. 岛屿数量 广搜版 文章解释

[LeetCode] 99. 岛屿数量 广搜版

自己看到题目的第一想法

    这题我会~

看完代码随想录之后的想法

import java.util.ArrayList;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;

public class Main {
    private static int[][] dir = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    private static boolean[][] visited;
    private static int result = 0;
    private static int rowCount = 0;
    private static int columnCount = 0;
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int[][] nodes = null;
        boolean[][] visited = null;
        int result = 0;
        
        while (scanner.hasNext()) {
            rowCount = scanner.nextInt();
            columnCount = scanner.nextInt();
            nodes = new int[rowCount][columnCount];
            visited = new boolean[rowCount][columnCount];
            for (int i = 0; i < rowCount; i++) {
                for (int j = 0; j < columnCount; j++) {
                    nodes[i][j] = scanner.nextInt();
                }
            }
        }
        Deque<int[]> toNodes = new LinkedList<>();
        for (int i = 0; i < rowCount; i++) {
            for (int j = 0; j < columnCount; j++) {
                if (visited[i][j] || nodes[i][j] != 1) {
                    continue;
                }
                result++;
                toNodes.addLast(new int[]{i, j});
                visited[i][j] = true;
                bfs(nodes, visited, toNodes);
            }
        }
        System.out.print(result);
    }
    private static void bfs(int[][] nodes, boolean[][] visited, Deque<int[]> toNodes) {
        while (!toNodes.isEmpty()) {
            int[] node = toNodes.pop();
            int x = node[0];
            int y = node[1];
            
            int newX;
            int newY;
            for (int i = 0; i < dir.length; i++) {
                newX = x + dir[i][0];
                newY = y + dir[i][1];
                if (newX < 0 || newX >= nodes.length || newY < 0 || newY >= nodes[newX].length) {
                    // 超出范围
                    continue;
                }
                if (visited[newX][newY] || nodes[newX][newY] != 1) {
                    // 标记过了, 或者非陆地, 不处理
                    continue;
                }
                toNodes.addLast(new int[]{newX, newY});
                visited[newX][newY] = true;
            }
        }
    }
}

自己实现过程中遇到哪些困难

    无.

dreamtang
关注
图论做题笔记：dfs
2301_76612880的博客
03-30 673
因为上一道题就像是链表的结构，一个点可以连接多个点，我们可以想象成树的结构来做，我们在遍历树寻找节点的时候在深搜的同时必须伴随着回溯使得我们不会落下任意一个路径，二这道题不一样的点在于给了我们一个二维的空间图，在寻找特定点时我们只管往前走不需要考虑有便利不到的情况因为next（x，y）会将四个方向的点都处理一遍。我们引入一个二维的数组visit来记录每个点的访问情况，当传入一个点时，我们直接将其标记为已访问过，然后我们利用opt数组来向四个方向进行搜索，如果搜索的点合法我们继续递归搜索。
代码随想录算法训练营第五十一天｜99.岛屿数量 深搜 、99.岛屿数量 广搜、岛屿的最大面积
m0_73129864的博客
08-09 377
本题思路：用遇到一个没有遍历过的节点陆地，计数器就加一，然后把该节点陆地所能遍历到的陆地都标记上。在遇到标记过的陆地节点和海洋节点的时候直接跳过。这样计数器就是最终岛屿的数量。dfs只处理下一个节点，即在主函数遇到岛屿就计数为1，dfs处理接下来的相邻陆地。100. 岛屿的最大面积。相邻的陆地连接形成。
代码随想录算法训练营第五十一天 | 99.岛屿数量-深搜 ，99.岛屿数量-广搜 ，100.岛屿的最大面积
懒羊羊在努力的博客
09-07 1003
很多同学写dfs其实也是凭感觉来的，有的时候dfs函数中写终止条件才能过，有的时候 dfs函数不写终止添加也能过！本题思路，是用遇到一个没有遍历过的节点陆地，计数器就加一，然后把该节点陆地所能遍历到的陆地都标记上。写法一，dfs只处理下一个节点，即在主函数遇到岛屿就计数为1，dfs处理接下来的相邻陆地。其实终止条件 就写在了 调用dfs的地方，如果遇到不合法的方向，直接不会去调用dfs。写法二，dfs处理当前节点，即在主函数遇到岛屿就计数为0，dfs处理接下来的全部陆地。输出一个整数，表示岛屿的最大面积。
代码随想录算法训练营第五十一天 | 99. 岛屿数量 深搜、99. 岛屿数量 广搜、100. 岛屿的最大面积
weixin_43581681的博客
08-14 256
每遇到一个陆地（1），从当前位置开始深搜，如果访问过则标记为“True”，即表示访问过，每进行一次深搜，岛屿数量+1。
代码随想录算法训练营第五十一天 | 99.岛屿数量 深搜广搜、100.岛屿的最大面积
xizhou_sean的博客
08-30 731
给定一个由 1（陆地）和 0（水）组成的矩阵，岛屿指的是由水平或垂直方向上相邻的陆地单元格组成的区域，且完全被水域单元格包围。本题要求找到不靠边的陆地面积，那么我们只要从周边找到陆地然后 通过 dfs或者bfs 将周边靠陆地且相邻的陆地都变成海洋，然后再去重新遍历地图 统计此时还剩下的陆地就可以了。本题思路，是用遇到一个没有遍历过的节点陆地，计数器就加一，然后把该节点陆地所能遍历到的陆地都标记上。现在你需要计算所有孤岛的总面积，岛屿面积的计算方式为组成岛屿的陆地的总数。输出一个整数，表示岛屿的最大面积。
代码随想录算法训练营第五十六天| 99.岛屿数量 深搜，99.岛屿数量 广搜，100.岛屿的最大面积
qq_61552256的博客
10-14 194
五十六天打卡，今天知道了图中的深搜与广搜方法，能够熟练应用。
代码随想录算法训练营第四十五天|99.岛屿数量 深搜 99.岛屿数量 广搜 100.岛屿的最大面积
S1588994的博客
09-05 189
【代码】代码随想录算法训练营第四十五天|99.岛屿数量 深搜 99.岛屿数量 广搜 100.岛屿的最大面积。
代码随想录算法训练营第五十四天|99.岛屿数量 深搜、广搜、100.岛屿的最大面积
weixin_43903745的博客
07-15 499
状态：不会。
代码随想录算法训练营第五十七天 | 99.岛屿数量 深搜/广搜、100.岛屿的最大面积
Danny_8的博客
07-03 459
遇到一个没有遍历过的节点陆地，计数器就加一，然后把该节点陆地所能遍历到的陆地都标记上。在遇到标记过的陆地节点和海洋节点的时候直接跳过。这样计数器就是最终岛屿的数量。搜索每个岛屿上“1”的数量，然后取一个最大的。
代码随想录算法训练营第一天 - 704. 二分查找
05-08
代码随想录算法训练营第一天 - 704. 二分查找
代码随想录算法训练营第一天- 977.有序数组的平方 ， 209.长度最小的子数组，59.螺旋矩阵II
10-12
代码随想录算法训练营第一天- 977.有序数组的平方 ， 209.长度最小的子数组，59.螺旋矩阵II
代码随想录算法训练营第2天|977. 有序数组的平方、209.长度最小的子数组、59. 螺旋矩阵II
qq_43212651的博客
03-16 132
2023 年 3 月 16 日1h45m★\bigstar★★\bigstar★★\bigstar★★\bigstar★5295第一道题没什么说的，不过最开始我想的是先找到第一个大于等于零的数和最后以后小于零的数，然后由中间向两边迭代，但是这种方法的边界条件很难处理。
代码随想录算法训练营第一天| 704. 二分查找、27. 移除元素
weixin_48111139的博客
12-08 783
学算法，自用，作为记录参考
100种算法【Python版】第36篇——Graham Scan算法
AnFany
11-02 268
100种算法【Python版】第36篇——Graham Scan算法
算法基础-链表
August的专栏
11-05 217
当链表的长度为偶数时，head找到的中点是靠后的，因为fast相对slow移动只快了1步，而head.next找到的中点是靠前的，因为fast相对slow移动快了2步。这2种方式寻找链表的结点主要区别是 当链表的长度为奇偶数时，找到链表中点的位置一个靠后，一个靠前。使用快慢指针寻找链表的中点有2种方式，分别是fast=head;当链表为奇数时 [1->2->3->4->5]当链表长度为奇数时，找到的中点2种方式是一样的。当链表为偶数时 [1->2->3->4]
CSP/信奥赛C++刷题训练：经典深搜例题（1）：洛谷1605 ：迷宫
weixin_66461496的博客
11-02 1039
CSP/信奥赛C++刷题训练：经典深搜例题（1）：洛谷1605 ：迷宫
字符串-06-整数与ip地址之间的转换
qq_45480682的博客
11-04 315
华为od算法——HJ33
【LeetCode】【算法】160.相交链表
最新发布
passer__jw767的博客
11-05 285
Leetcode 160. 相交链表
【算法】（Python）贪心算法
yannan20190313的博客
11-04 1959
【算法】（Python）贪心算法（最大单元数，买卖股票最佳时机，最低加油次数）
代码随想录算法训练营
08-23
代码随想录算法训练营是一个优质的学习和讨论平台，提供了丰富的算法训练内容和讨论交流机会。在训练营中，学员们可以通过观看视频讲解来学习算法知识，并根据讲解内容进行刷题练习。此外，训练营还提供了刷题建议，例如先看视频、了解自己所使用的编程语言、使用日志等方法来提高刷题效果和语言掌握程度。 训练营中的讨论内容非常丰富，涵盖了各种算法知识点和解题方法。例如，在第14天的训练营中，讲解了二叉树的理论基础、递归遍历、迭代遍历和统一遍历的内容。此外，在讨论中还分享了相关的博客文章和配图，帮助学员更好地理解和掌握二叉树的遍历方法。 训练营还提供了每日的讨论知识点，例如在第15天的讨论中，介绍了层序遍历的方法和使用队列来模拟一层一层遍历的效果。在第16天的讨论中，重点讨论了如何进行调试（debug）的方法，认为掌握调试技巧可以帮助学员更好地解决问题和写出正确的算法代码。 总之，代码随想录算法训练营是一个提供优质学习和讨论环境的平台，可以帮助学员系统地学习算法知识，并提供了丰富的讨论内容和刷题建议来提高算法编程能力。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [代码随想录算法训练营每日精华](https://blog.csdn.net/weixin_38556197/article/details/128462133)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值