【DFS和BFS】力扣题解

最新推荐文章于 2022-11-30 13:53:52 发布
最新推荐文章于 2022-11-30 13:53:52 发布
阅读量714 收藏 4
点赞数
分类专栏： 笔试编程题 文章标签： 算法 leetcode java dfs bfs
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43180675/article/details/106780291
版权

目录

一、DFS和BFS相关概念

深度优先搜索（DFS）在进行图的搜索时，得到一个新的节点，立即对新节点向下遍历，然后回溯。使用 DFS 对一个图进行遍历时，能够遍历到的节点都是从初始节点可达的，DFS 常用来求解这种 可达性 问题。

广度优先搜索（BFS）在搜索的时候，是一层一层地进行遍历，每层遍历都是以上一层遍历的结果作为起点，遍历一个距离能访问到的所有节点。需要注意的是，遍历过的节点不能再次被遍历。

每一层遍历的节点都与根节点距离相同。设 di 表示第 i 个节点与根节点的距离，推导出一个结论：对于先遍历的节点 i 与后遍历的节点 j，有 di <= dj。

利用这个结论，可以求解最短路径等 最优解 问题：第一次遍历到目的节点，其所经过的路径为最短路径。应该注意的是，使用 BFS 只能求解无权图的最短路径，无权图是指从一个节点到另一个节点的代价都记为 1。

二、DFS相关练习题

1.岛屿的最大面积

给定一个包含了一些 0 和 1 的非空二维数组 grid 。

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

找到给定的二维数组中最大的岛屿面积。(如果没有岛屿，则返回面积为 0 。)

示例 1:

[[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 。

示例 2:

[[0,0,0,0,0,0,0,0]]

对于上面这个给定的矩阵, 返回 0。

解题思路：

当登陆某一个岛屿后，以该岛屿的东、西、南、北四个方向探索，同时为了保证不重复访问，将访问过得岛屿标记为2，如果遇到‘0’或者2就退出。

class Solution {

    private int[][] derection = {{-1,0},{1,0},{0,-1},{0,1}};
    private int m, n;
    private int[][] grid;  
      
    public int maxAreaOfIsland(int[][] grid) {
        if(grid == null || grid.length == 0){
            return 0;
        }
        m = grid.length;
        n = grid[0].length;
        int res = 0;
        for(int i = 0; i < m; i++){
            for(int j = 0; j < n;j++){
                if(grid[i][j] == 1){
                    res = Math.max(res,dfs(grid,i,j));
                }
            }
        }
        return res;
    }

    public int dfs(int[][] grid,int r,int c) {
   		//判断边界，以及是否是岛屿或是否被访问过
        if(r < 0 || r >= m || c < 0 || c >= n || grid[r][c] != 1){
            return 0;
        }
        //访问过，设置为2
        grid[r][c] = 2;
        int res = 1;
       	//以当前节点，想四个方向搜索
        for(int d[] : derection){
            res += dfs(grid,r+d[0],c+d[1]);
        }
        return res;
    }


}

2.岛屿的数量

给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。

岛屿总是被水包围，并且每座岛屿只能由水平方向或竖直方向上相邻的陆地连接形成。

此外，你可以假设该网格的四条边均被水包围。

示例 1:

输入:

11110
11010
11000
00000

输出: 1

示例 2:

输入:

11000
11000
00100
00011

输出: 3

解释: 每座岛屿只能由水平和/或竖直方向上相邻的陆地连接而成。

class Solution {

    private int[][] derection = {{-1,0},{1,0},{0,1},{0,-1}};
    private int m, n;
    private char[][] grid;
    
    public int numIslands(char[][] grid) {
        if(grid == null || grid.length == 0){
            return 0;
        }
        m = grid.length;
        n = grid[0].length;
        int res = 0;
        for(int i = 0;i < m; i++){
            for(int j = 0;j < n; j++){
            	//只有是岛屿才进行搜索
                if(grid[i][j] == '1'){
                    dfs(grid,i,j);
                    res++;
                }
            }
        }
        return res;
    }
    private void dfs(char[][] grid,int r, int c){

        if(r < 0 || r >= m || c < 0 || c >= n || grid[r][c] != '1'){
            return;
        }
        grid[r][c] = '2';
        for(int[] d : derection){
            dfs(grid,r+d[0],c+d[1]);
        }
        return;
    }
}

3.朋友圈

班上有 N 名学生。其中有些人是朋友，有些则不是。他们的友谊具有是传递性。如果已知 A 是 B 的朋友，B 是 C 的朋友，那么我们可以认为 A 也是 C 的朋友。所谓的朋友圈，是指所有朋友的集合。

给定一个 N * N 的矩阵 M，表示班级中学生之间的朋友关系。如果M[i][j] = 1，表示已知第 i 个和 j 个学生互为朋友关系，否则为不知道。你必须输出所有学生中的已知的朋友圈总数。

示例 1:

输入:
[[1,1,0],
[1,1,0],
[0,0,1]]

输出: 2

说明：已知学生0和学生1互为朋友，他们在一个朋友圈。
第2个学生自己在一个朋友圈。所以返回2。

示例 2:

输入:
[[1,1,0],
[1,1,1],
[0,1,1]]
输出: 1

说明：已知学生0和学生1互为朋友，学生1和学生2互为朋友，所以学生0和学生2也是朋友，所以他们三个在一个朋友圈，返回1。

 class Solution {
    private int[][] M;
    private int m;

    public int findCircleNum(int[][] M) {
        if(M == null || M.length == 0){
            return 0;
        }
        m = M.length;
        //设置一个辅助数组用来存储节点是否被访问过
        boolean[] isVisited = new boolean[m];
        int res =0;
        //对矩阵一行行的判断
        for(int i = 0; i < m; i++){
        	//如果没有被访问过，从这个定点，一直向下搜索
            if(!isVisited[i]){
                dfs(M,i,isVisited);
                res++;
            }
        }
        return res;
    }
    private void dfs(int[][]M,int i,boolean[] isVisited){
    	//首先设置为已访问
        isVisited[i] = true;
        //循环遍历每一列
        for(int j = 0;j < m; j++){
        	//当两节点有联系，且未被访问，对该节点继续向下搜索。
            if(M[i][j] == 1 && !isVisited[j]){
                dfs(M,j,isVisited);
            }
        }
    }
}

4.被围绕的区域

给定一个二维的矩阵，包含 ‘X’ 和 ‘O’（字母 O）。

找到所有被 ‘X’ 围绕的区域，并将这些区域里所有的 ‘O’ 用 ‘X’ 填充。

示例:

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’。如果两个元素在水平或垂直方向相邻，则称它们是“相连”的。

class Solution {

    private int[][] derection = {{-1,0},{1,0},{0,1},{0,-1}};
    private int m,n;
    private char[][] board; 

    public void solve(char[][] board) {
        if(board == null || board.length == 0){
            return;
        }
        m = board.length;
        n = board[0].length;
		//从第一行和最后一行开始搜索
        for(int i = 0;i < n; i++){
            dfs(board,0,i);
            dfs(board,m-1,i);
        }
        //从第一列和最后一列开始搜索
        for(int i = 0;i < m; i++){
            dfs(board,i,0);
            dfs(board,i,n-1);
        }

        for(int i = 0;i < m; i++){
            for(int j = 0;j < n; j++){
            	//将所有的‘O’设置为‘X’
                if(board[i][j] == 'O'){
                    board[i][j] = 'X';
                }
                //将所有的'#'改为‘O’
                if(board[i][j] == '#'){
                    board[i][j] = 'O';
                }
            }
        }
        return;
    }

    private void dfs(char[][] board,int r,int c){
    
        if(r < 0 || r >= m || c < 0 || c >= n || board[r][c] == 'X' || board[r][c] == '#'){
            return;
        }
        //将与边界相连的'O'设置为‘#’
        board[r][c] = '#';
        //搜索与边界相连接的‘O‘’
        for(int[] d : derection){
            dfs(board,r+d[0],c+d[1]);
        }
    }
       
}

5.太平洋大西洋水流问题

给定一个 m x n 的非负整数矩阵来表示一片大陆上各个单元格的高度。“太平洋”处于大陆的左边界和上边界，而“大西洋”处于大陆的右边界和下边界。

规定水流只能按照上、下、左、右四个方向流动，且只能从高到低或者在同等高度上流动。

请找出那些水流既可以流动到“太平洋”，又能流动到“大西洋”的陆地单元的坐标。

提示：
加粗样式
输出坐标的顺序不重要
m 和 n 都小于150

示例：

给定下面的 5x5 矩阵:
在这里插入图片描述
返回:

[[0, 4], [1, 3], [1, 4], [2, 2], [3, 0], [3, 1], [4, 0]] (上图中带括号的单元).

class Solution {

    private int[][] deriect = {{1,0},{-1,0},{0,1},{0,-1}};
    private int m,n;

    public List<List<Integer>> pacificAtlantic(int[][] matrix) {
        List<List<Integer>> list = new ArrayList<>();
        if(matrix == null || matrix.length == 0){
            return list;
        }
        m = matrix.length;
        n = matrix[0].length;
        boolean[][] checkedP = new boolean[m][n];
        boolean[][] checkedA = new boolean[m][n];
        for(int i = 0;i < m;i++){
            dfs(matrix,i,0,checkedP);
            dfs(matrix,i,n-1,checkedA);
        }
        for(int i = 0;i < n;i++){
            dfs(matrix,0,i,checkedP);
            dfs(matrix,m-1,i,checkedA);
        }
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (checkedP[i][j] && checkedA[i][j]) {
                    list.add(Arrays.asList(i, j));
                }
            }
        } 
        return list;
        
    
    }

    private void dfs(int[][] matrix,int r, int c, boolean[][] checked){
        if(checked[r][c]){
            return;
        }
        checked[r][c] = true;
        for(int[] d : deriect){
            int nextR = r + d[0];
            int nextC = c + d[1];
            if(nextR < 0 || nextR >= m || nextC < 0 || nextC >= n || matrix[r][c] > matrix[nextR][nextC]){
                continue;
            }
            dfs(matrix,nextR,nextC,checked);
        }
        return ;
    }
}

三、BFS相关练习题

1. 二进制矩阵中的最短路径

在一个 N × N 的方形网格中，每个单元格有两种状态：空（0）或者阻塞（1）。
一条从左上角到右下角、长度为 k 的畅通路径，由满足下述条件的单元格 C_1, C_2, ..., C_k组成：

class Solution {
    //八个方向联通
    private int[][] derection = {{1,-1},{1,0},{1,1},{-1,-1},{-1,0},{-1,1},{0,1},{0,-1}};    
    private int m,n;
    public int shortestPathBinaryMatrix(int[][] grid) {
        if(grid == null || grid.length == 0){
            return -1;
        }
        m = grid.length;
        n = grid[0].length;
        //如果起始点或者终点是阻塞状态1，代表永远不可达，不存在路径
        if(grid[0][0] == 1 || grid[m-1][n-1] == 1){
            return -1;
        }
        //直接使用grid存储路径长度
        grid[0][0] = 1;

        Queue<int[]> queue = new LinkedList<>();
        //将起始点存入到队列中
        queue.add(new int[]{0,0});
        
        //队列不为空 且终点是可达的，也就是说 目前为止没有任何一条路经可以到达终点
        while(!queue.isEmpty() && grid[m-1][n-1] == 0){
            int[] xy = queue.remove();
            int length = grid[xy[0]][xy[1]];
            for(int[] d : derection){
                int nextR = xy[0] + d[0];
                int nextC = xy[1] + d[1];
                if(inGrid(nextR,nextC) && grid[nextR][nextC] == 0){
                    queue.add(new int[]{nextR,nextC});
                    grid[nextR][nextC] = length + 1;
                }
            }
        }
        return grid[m-1][n-1] == 0 ? -1 : grid[m-1][n-1];
    }

    //判断边界，是否在矩阵范围之内
    private boolean inGrid(int r,int c){
        return r>=0 && r < m && c >=0 && c <  n;
    }
}

2.单词接龙

给定两个单词（beginWord 和 endWord）和一个字典，找到从 beginWord 到 endWord 的最短转换序列的长度。转换需遵循如下规则：

每次转换只能改变一个字母。
转换过程中的中间单词必须是字典中的单词。

说明:

  • 如果不存在这样的转换序列，返回 0。
  • 所有单词具有相同的长度。
  • 所有单词只由小写字母组成。
  • 字典中不存在重复的单词。
  • 你可以假设 beginWord 和 endWord 是非空的，且二者不相同。

示例 1:

输入:
beginWord = “hit”,
endWord = “cog”,
wordList = [“hot”,“dot”,“dog”,“lot”,“log”,“cog”]

输出: 5

解释: 一个最短转换序列是 “hit” -> “hot” -> “dot” -> “dog” -> “cog”,
返回它的长度 5。

示例 2:

输入:
beginWord = “hit”
endWord = “cog”
wordList = [“hot”,“dot”,“dog”,“lot”,“log”]

输出: 0

解释: endWord “cog” 不在字典中，所以无法进行转换。

class Solution {
    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        
        //首先将wordList存入到HashSet中
        Set<String> wordSet = new HashSet<>(wordList);
        if(wordSet.size() == 0 || !wordSet.contains(endWord)){
            return 0;
        }    
        wordSet.remove(beginWord);

        Queue<String> queue = new LinkedList<>();
        queue.add(beginWord);

        Set<String> visited = new HashSet<>();
        visited.add(beginWord);

        int wordLen = beginWord.length();

        int step = 1;

        while(!queue.isEmpty()){
            //计算某一层次，有多少节点
            int size = queue.size();
            //依次遍历当前节点中的单词
            for(int i = 0;i < size;i++){
                String word = queue.remove();
                char[] charArray = word.toCharArray();
                //修改每一个字符
                for(int j = 0;j < wordLen;j++){
                    //保存原始的字符
                    char originChar = charArray[j];
                    for(char k = 'a';k <= 'z'; k++){
                        //如果修改之后跟原来的字符串相同，就跳过
                         if (k == originChar) {
                            continue;
                        }
                        charArray[j] = k;
                        //将字符数组转换成字符串
                        String nextWord = String.valueOf(charArray);
                        //判断字典中是否存在修改后的字符
                        if(wordSet.contains(nextWord)){
                            //如果修改后的单词与结束单词相同
                            if(nextWord.equals(endWord)){
                                return step+1;
                            }
                            //如果不同，且未被访问过
                            if(!visited.contains(nextWord)){
                                queue.add(nextWord);
                                visited.add(nextWord);
                            }
                        }
                    }
                    //把单词恢复成原始的单词
                    charArray[j] = originChar;
                }
            }
            //这一层次全部遍历完毕，step+1
            step++;
        }
        return 0;
    }
}
Heart of Ocean
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
DFS和BFS.docx
08-21
在C++中，DFS和BFS通常结合队列（for BFS）和栈（for DFS）数据结构实现。在搜索过程中，需要使用标志数组或其他数据结构来记录已经访问过的节点，防止无限循环和重复访问。 总的来说，DFS和BFS是图论和算法中的...
图结构练习——BFSDFS——判断可达性
cui2839255227的博客
08-09 430
题目描述  在古老的魔兽传说中，有两个军团，一个叫天灾，一个叫近卫。在他们所在的地域，有n个隘口，编号为1..n，某些隘口之间是有通道连接的。其中近卫军团在1号隘口，天灾军团在n号隘口。某一天，天灾军团的领袖巫妖王决定派兵攻打近卫军团，天灾军团的部队如此庞大，甚至可以填江过河。但是巫妖王不想付出不必要的代价，他想知道在不修建任何通道的前提下，部队是否可以通过隘口及其相关通道到达近卫军团展开攻
力扣刷题：DFS篇
轻松的小希
05-29 3962
目录112. 路径总和题目介绍题目实现113. 路径总和 II题目介绍题目实现17. 电话号码的字母组合题目介绍题目实现22. 括号生成题目介绍题目实现39. 组合总和题目介绍题目实现46. 全排列题目介绍题目实现47. 全排列 II题目介绍题目实现 112. 路径总和 题目介绍 给你二叉树的根节点 root 和一个表示目标和的整数 targetSum ，判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。 叶子节点 是指没有子节点的节点。 示例 1：
[力扣刷题总结](图,DFS和BFS篇)
weixin_38800498的博客
12-07 892
文章目录~~~~~~~~~~~~图~~~~~~~~~~~~1034. 边界着色解法1：DFS 图 1034. 边界着色 给你一个大小为 m x n 的整数矩阵 grid ，表示一个网格。另给你三个整数 row、col 和 color 。网格中的每个值表示该位置处的网格块的颜色。 当两个网格块的颜色相同，而且在四个方向中任意一个方向上相邻时，它们属于同一 连通分量 。 连通分量的边界 是指连通分量中的所有与不在分量中的网格块相邻（四个方向上）的所有网格块，或者在网格的边界上（第一行/列或最后一行/列）的所.
力扣刷题框架——BFS
qq_36919342的博客
07-22 315
BFS——广度优先搜索，核心思想就是把问题抽象成图，从一个点开始向四周扩散，一般用**队列**这种数据结构，每次将一个节点周围的所有节点加入队列。
力扣刷题总结之BFS
ComeOnMr博客
04-20 839
BFS基本思想 虽然题目千变万化，但是考察点永远是那几个。本题给出了一个场景：求 每个 1 到 0 的最短的曼哈顿距离。其中曼哈顿距离就是只能沿着横、竖到达另外一个点走的步数。 在一个图中，能从一个点出发求这种最短距离的方法很容易想到就是 BFS，BFS 的名称是广度优先遍历，即把周围这一圈搜索完成之后，再搜索下一圈，是慢慢扩大搜索范围的。 图左边是BFS，按照层进行搜索；图右边是 DFS，先一路...
力扣题解大全-600多页版
最新发布
08-29
7. **图论与搜索**：如题目2049，1345，2013等，涉及广度优先搜索(BFS)或深度优先搜索(DFS)。 8. **动态规划**：很多题目如题目436，1823，121，1629等都需要动态规划思维来解决复杂问题。 9. **位操作**：如题目...
DFS和BFS用来干什么
05-01
DFS和BFS DFS（Depth-First-Search）深度优先搜索算法，是搜索算法的一种。是一种在开发爬虫早期使用较多的方法。它的目的是要达到被搜索结构的叶结点 宽度优先搜索算法（又称广度优先搜索）是最简便的图的搜索算法...
图的 DFS 和BFS
07-09
图的深度优先搜索（DFS, Depth First Search）和广度优先搜索（BFS, Breadth First Search）是图论中的两种重要算法，用于遍历或搜索树或图。这两种算法在计算机科学中有着广泛的应用，比如在路径查找、拓扑排序、...
C语言：图的DFS和BFS（内附代码和算法思路）.docx
11-01
在本文档中，我们讨论了如何使用C语言实现无向图的深度优先遍历（DFS）和广度优先遍历（BFS）。首先，我们需要理解数据结构中的图，它由顶点（vertices）和边（edges）组成，无向图意味着边没有方向。图的存储通常有...
力扣刷题系列——BFS和DFS
qq_43568704的博客
08-25 2104
BFS与DFS相关算法题 BFS 广度优先搜索（也称宽度优先搜索，缩写BFS，以下采用广度来描述）是连通图的一种遍历算法这一算法也是很多重要的图的算法的原型。Dijkstra单源最短路径算法和Prim最小生成树算法都采用了和宽度优先搜索类似的思想。其别名又叫BFS，属于一种盲目搜寻法，目的是系统地展开并检查图中的所有节点，以找寻结果。换句话说，它并不考虑结果的可能位置，彻底地搜索整张图，直到找到结果为止。基本过程，BFS是从根节点开始，沿着树(图)的宽度遍历树(图)的节点。如果所有节点均被访问，则算法中
17.关于BFS和DFS力扣算法刷题
zhaozhiwei314的博客
11-30 352
DFS和BFS
leetCode 733. 图像渲染
weixin_42324665的博客
06-23 248
有一幅以 m x n 的二维整数数组表示的图画 image ，其中 image[i][j] 表示该图画的像素值大小。你也被给予三个整数 sr , sc 和 newColor 。你应该从像素 image[sr][sc] 开始对图像进行 上色填充 。为了完成 上色工作 ，从初始像素开始，记录初始坐标的 上下左右四个方向上 像素值与初始坐标相同的相连像素点，接着再记录这四个方向上符合条件的像素点与他们对应 四个方向上 像素值与初始坐标相同的相连像素点，……，重复该过程。将所有有记录的像素点的颜色值改为 newC
力扣第139题：单词拆分（DFS，BFS，动态规划）
sjl20021006的博客
10-24 538
一、题目内容 二、题目分析 对于这道题目我们首先要从头开始判断，一直到字符串结束为止。如下图一般，从0开始，读取c，发现并不在wordDict中，就继续读取a，直到读取到s之后，发现现在的字符串是cats，正好在给定的wordDict中，那么就从a开始，进行递归，递归的出口是当前的字符的个数是否等于给定字符串的长度，如果结果为是，就返回true。 那么我们将会得到这样一串代码 public boolean dfs(String s, Li...
Leetcode 547 解析: Number of Provinces (Python)
TmrTT的博客
02-02 476
文章目录题目描述题目分析方案一 （depth first search(DFS)深度优先搜索）代码实现日期 题目描述 There are n cities. Some of them are connected, while some are not. If city a is connected directly with city b, and city b is connected directly with city c, then city a is connected indirectly wi
LeetCode刷题笔记（Java）---第541-560题
gongsenlin341的博客
12-18 523
文章目录前言笔记导航541. 反转字符串 II542. 01 矩阵543. 二叉树的直径546. 移除盒子547. 朋友圈 前言 需要开通vip的题目暂时跳过 笔记导航 点击链接可跳转到所有刷题笔记的导航链接 541. 反转字符串 II 给定一个字符串 s 和一个整数 k，你需要对从字符串开头算起的每隔 2k 个字符的前 k 个字符进行反转。 如果剩余字符少于 k 个，则将剩余字符全部反转。 如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。 解答 public S
leetcode547. 朋友圈
weixin_43422466的博客
06-09 414
leetcode547. 朋友圈 班上有 N 名学生。其中有些人是朋友，有些则不是。他们的友谊具有是传递性。如果已知 A 是 B 的朋友，B 是 C 的朋友，那么我们可以认为 A 也是 C 的朋友。所谓的朋友圈，是指所有朋友的集合。 给定一个 N * N 的矩阵 M，表示班级中学生之间的朋友关系。如果M[i][j] = 1，表示已知第 i 个和 j 个学生互为朋友关系，否则为不知道。你必须输出所有学生中的已知的朋友圈总数。 示例 1: 输入: [[1,1,0], [1,1,0], [0,0,1]] 输
Leetcode 547：朋友圈（超详细的解法！！！）
coordinate的博客
02-09 4442
班上有 N 名学生。其中有些人是朋友，有些则不是。他们的友谊具有是传递性。如果已知 A 是 B 的朋友，B 是 C 的朋友，那么我们可以认为 A 也是 C 的朋友。所谓的朋友圈，是指所有朋友的集合。 给定一个 N * N 的矩阵 M，表示班级中学生之间的朋友关系。如果M[i][j] = 1，表示已知第 i 个和 j 个学生互为朋友关系，否则为不知道。你必须输出所有学生中的已知的朋友圈总数。 示例 ...
leetcode 547 朋友圈
qq_43460108的博客
09-09 204
班上有 N 名学生。其中有些人是朋友，有些则不是。他们的友谊具有是传递性。如果已知 A 是 B 的朋友，B 是 C 的朋友，那么我们可以认为 A 也是 C 的朋友。所谓的朋友圈，是指所有朋友的集合。 给定一个 N * N 的矩阵 M，表示班级中学生之间的朋友关系。如果M[i][j] = 1，表示已知第 i 个和 j 个学生互为朋友关系，否则为不知道。你必须输出所有学生中的已知的朋友圈总数。 示例 1： 输入： [[1,1,0], [1,1,0], [0,0,1]] 输出：2 解释：已知学生 0 和学生 1
Dijkstra算法与DFS、BFS在图论中的应用
本文将介绍Dijkstra算法以及DFS和BFS在图论中的应用。Dijkstra算法是一种用于寻找图中两点间最短路径的算法，适用于有权重的加权图。而DFS（深度优先搜索）和BFS（广度优先搜索）则是两种基本的图遍历方法，它们在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值