力扣刷题 -- BFS 与 DFS

已于 2024-07-26 15:33:55 修改
阅读量1k 收藏 28
点赞数 23
文章标签： leetcode 宽度优先 深度优先 c++
于 2024-07-24 15:19:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/I_am_toutu/article/details/140587045
版权

BFS 与 DFS

BFS 刷题

二叉树的最小深度

111. 二叉树的最小深度

// 队列存储着当前结点以及当前结点的深度
class Solution {
public:
    int minDepth(TreeNode* root) {
        if (root == nullptr) return 0;
        
        queue<pair<TreeNode*, int>> q;
        q.emplace(root, 1);

        while (!q.empty()) {
            TreeNode* node = q.front().first;
            int depth = q.front().second;
            q.pop();

            if (!node->left && !node->right) return depth;

            if (node->left) q.emplace(node->left, depth + 1);
            if (node->right) q.emplace(node->right, depth + 1);
        }
        return 0;
    }
};

// 变量 cc 记录当前层数
class Solution {
public:
    int minDepth(TreeNode* root) {
        if (root == nullptr) return 0;
        
        queue<TreeNode*> q;
        q.push(root);

        int cc = 0;
        while (!q.empty()) {
            int size = q.size();
            cc += 1;
            for (int i=0; i<size; i++) {
                TreeNode* node = q.front(); q.pop();
                
                if (node->right == nullptr && node->left == nullptr) 
                    return cc;
                
                if (node->left) q.push(node->left);
                if (node->right) q.push(node->right);
            }
        }
        return cc;
    }
};
二叉树的层序遍历

102. 二叉树的层序遍历

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        if (root == nullptr) return {};

        vector<vector<int>> res;
        queue<TreeNode*> q;
        q.push(root);

        while (!q.empty()) {
            int num = q.size();
            vector<int> temp;
            for (int i=0; i<num; i++) {
                TreeNode* node = q.front(); q.pop();
                temp.push_back(node->val);
                if (node->left) q.push(node->left);
                if (node->right) q.push(node->right);
            }
            res.push_back(temp);
        }
        return res;
    }
};
单词接龙

127. 单词接龙

在这里插入图片描述
方法一：BFS

  • 初始化队列 que 和一个哈希表 visited 中，visited 是为了不再重复访问单词。
  • 对于刚开始的单词 beginWord = "hit"，我们每次只替换一个位置的字符，然后在 wordList 里查找是否有一样的字符串，若完全没有相同的字符串，相当于 beginWord 不能转换到 endWord；比如将中间的字符 i 替换为 o ：
    • 如果修改后的单词与 endWord 相等，则返回对应的最短转换序列；
    • 如果修改的单词与 endWord 不相等，且在 wordList 数组中找到了对应的单词，以及没有访问过这个单词，则将这个单词放进 que 里，下一循环就重复这个的过程；
    • 如果修改的单词与 endWord 不相等，且在 wordList 数组中不存在对应的单词，则 que 不放入。
  • 整体过程可以视为一个很大的树或者图，如上图所示。从 hit 节点开始，可以分裂出 26*3 个结点（分支），其中 hit 也在里面，但是只有 hot 是在 wordList 中且没有 visited 过，因此只选择这个单词；后续的流程一样，hot 也可以分裂出很多分支，但是能存到队列中就需要看 wordList 和 visited 这两个哈希表。

方式二：双向 BFS

  • 使用两个队列 startQue 和 endQue，分别从 beginWord 和 endWord 开始。
  • 每次循环队列的过程中，选择元素较少的队列开始搜索，以减少搜索空间；较大的队列，不仅作为对立面，也用作较小队列的临时存储。
  • 对队列的元素进行访问流程与第一个方式大部分是相同，但有一个点不同：判断最短转换序列的条件是，当两个队列的元素相交时，表示 beginWord 可以转换为 endWord；具体来说，当在当前队列中找到在另一个队列的集合 visitedEnd 中存在的单词时，直接返回当前步数 + 1。

在这里插入图片描述

// BFS
class Solution {
public:
    int ladderLength(string beginWord, string endWord, vector<string>& wordList) {
        unordered_set<string> wordlist(wordList.begin(), wordList.end());

        if (wordlist.find(endWord) == wordlist.end())
            return 0;
        
        int count = 1;
        unordered_set<string> visited;

        queue<string> que;
        que.emplace(beginWord);

        visited.insert(beginWord);
        int wordSize = beginWord.size();

        while (!que.empty()) {
            int n = que.size();
            // 层序遍历 
            for (int i=0; i<n; i++) {
                string front = que.front(); que.pop();
                if (front == endWord) return count;

                for (int j=0; j<wordSize; j++) {
                    string str = front; 

                    for (int k=0; k<26; k++) {
                    	// 替换单个字符
                        str[j] = 'a' + k;
                        if (visited.find(str) == visited.end() && wordlist.find(str) != wordlist.end()) {
                            que.emplace(str);
                            visited.insert(str);
                        }
                        
                    }
                }
            }
            count++;
        }

        return 0;
    }
};

// 双向 BFS
class Solution {
public:
    int ladderLength(string beginWord, string endWord, vector<string>& wordList) {
        unordered_set<string> wordlist(wordList.begin(), wordList.end());

        if (wordlist.find(endWord) == wordlist.end())
            return 0;
        
        int count = 1;

        queue<string> beginQue;
        queue<string> endQue;
        beginQue.emplace(beginWord);
        endQue.emplace(endWord);
        
        unordered_set<string> visited;
        unordered_set<string> visitedEnd;
        visited.insert(beginWord);
        visitedEnd.insert(endWord);

        int wordSize = beginWord.size();

        while (!beginQue.empty() && !endQue.empty()) {
            if (beginQue.size() > endQue.size()) {
                swap(beginQue, endQue);
                swap(visited, visitedEnd);
            }

            int n = beginQue.size();
            // 层序遍历 
            for (int i=0; i<n; i++) {
                string front = beginQue.front(); beginQue.pop();

                for (int j=0; j<wordSize; j++) {
                    string str = front;

                    for (int k=0; k<26; k++) {
                        str[j] = 'a' + k;
                        if (visited.find(str) == visited.end() && wordlist.find(str) != wordlist.end()) {
                        	if (visitedEnd.find(str) != visitedEnd.end()) 
                        		// 这个 str 存在 visitedEnd 中，相交了
                            	return count+1; 
                            beginQue.emplace(str);
                            visited.insert(str);
                        } 
                    }
                }
            }
            count++;
        }

        return 0;
    }
};
BFS in Topological Sort

拓扑排序是对一个有向无环图（Directed Acyclic Graph，DAG）进行排序的算法，目的是将图中的顶点排成一个线性序列。且该序列必须满足下面两个条件:
(1) 每个顶点出现且只出现一次。
(2) 若存在一条从顶点A到顶点B的路径，那么在序列中顶点A出现在顶点 B 的前面。
注: 有向无环图 (DAG) 才有拓扑排序，非 DAG 图没有拓扑排序一说。

课程表

207. 课程表
prerequisites[i] = [ai, bi]，表示如果要学习课程 ai 则必须先学习课程 bi ；因此是从 bi 指向 ai。
在这里插入图片描述

(1) 根据 prerequisites 数组利用 哈希表 map 构建整个课程图，以及利用 数组 in 存储每个顶点的入度情况；比如 {1：[3, 4]} 表明为顶点 1 同时指向 3 和 4，in[3] = 2 相当于顶点 3 的入度为 2 ；
(2) 利用队列 que，将入度为 0 的点，放到队列中 【当顶点的入度为 0 ，相当于对应的课程已经学习完了，若仍有些课程的入度不为 0，说明图中存在环，无法被选，完成不了所有课】；
(3) 从队列中得到入度为 0 的顶点，假设将这个顶点去掉，则对应的被指向的顶点的入度应被减一；若是入度被减为 0 ，则将这个被指向的顶点放入队列中。

class Solution {
public:
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        unordered_map<int, vector<int>> map;
        vector<int> in(numCourses, 0);

        for (int i=0; i<prerequisites.size(); i++) {
            map[prerequisites[i][1]].push_back({prerequisites[i][0]});
            in[prerequisites[i][0]]++;
        }

        queue<int> que;
        for (int i=0; i<in.size(); i++) {
            if (in[i] == 0) que.push(i);  
        }
        
        int count = 0;
        while (!que.empty()) {
            int node = que.front(); que.pop();
            count++;

            for (int i=0; i<map[node].size(); i++) {
                if (in[map[node][i]] > 0) {
                    in[map[node][i]]--;
                    if (in[map[node][i]] == 0) que.push(map[node][i]);
                }
            }
        }
		// 入度为 0 的数量是否等于 numCourses 
        return count == numCourses;
    }
};
课程表 II

210. 课程表 II

class Solution {
public:
    vector<int> findOrder(int numCourses, vector<vector<int>>& prerequisites) {
        unordered_map<int, vector<int>> map;
        vector<int>in(numCourses, 0);

        for (int i=0; i<prerequisites.size(); i++) {
            map[prerequisites[i][1]].push_back(prerequisites[i][0]);
            in[prerequisites[i][0]]++;
        }

        queue<int> que;
        for (int i=0; i<numCourses; i++) {
            if (in[i] == 0) que.push(i);
        }

        vector<int> ans;
        while (!que.empty()) {
            int node = que.front(); que.pop();
            ans.push_back(node);

            for (int i=0; i<map[node].size(); i++) {
                if (in[map[node][i]] > 0) {
                    in[map[node][i]]--;
                    if (in[map[node][i]] == 0) que.push(map[node][i]);
                }
            }
        }
        if (ans.size() < numCourses) return {};
        return ans;
    }
};

DFS 刷题

中序、前序、后序遍历

看这篇文章
力扣刷题 – 树

子集

78. 子集
90. 子集 II

下图是关于 78. 子集 的 dfs 的流程
在这里插入图片描述

下图是关于 90. 子集 II 的 dfs 的流程。
在这里插入图片描述

// 78. 子集
class Solution {
public:
    vector<vector<int>> ans;
    vector<vector<int>> subsets(vector<int>& nums) {
        vector<int> subset;
        dfs(nums, 0, subset);
        return ans;
    }

    void dfs(vector<int>& nums, int idx, vector<int> subset) {
        if (nums.size() <= idx) {
            ans.push_back(subset);
            return;
        }

        dfs(nums, idx+1, subset);     // 不选
        subset.push_back(nums[idx]);  // 选
        dfs(nums, idx+1, subset); 
        subset.pop_back();
    }
};

// 90. 子集 II
class Solution {
public:
    vector<vector<int>> ans;

    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        sort(nums.begin(), nums.end()); 

        vector<int> subset;
        dfs(nums, 0, subset);

        return ans;
    }

    void dfs(vector<int>& nums, int idx, vector<int> subset) {
        if (nums.size() <= idx) {
            ans.push_back(subset);
            return;
        }

        subset.push_back(nums[idx]);  // 选
        dfs(nums, idx+1, subset);
		
		// 对于图中的示例，当索引为 idx 的元素执行前面两步操作后，
		// 再比较 idx 与 idx+1 的元素，若是相等就直接跳过，即为 idx++ 
        while (idx + 1 < nums.size() && nums[idx+1] == nums[idx])
            idx++;

        subset.pop_back();    // 不选
        dfs(nums, idx+1, subset);

    }
};

78. 子集 另一种做法

通过按位与操作以及左移操作符生成给定数组的所有子集。
(1) 利用位移操作符 1 << nums.size() 计算所有可能的子集数量，即为 0 到 7，每个数字的二进制表示一个子集；
(2) 循环每一个子集，循环过程中分别于 j=0、j=1 和 j=2 进行按位与操作；若是结果 1，则表示在当前子集中包含 nums[j]。
在这里插入图片描述

class Solution {
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        vector<vector<int>> ans;
        int size = 1 << nums.size();  
		
        for (int i=0; i<size; i++) {
            vector<int> temp;

            for (int j=0; j<nums.size(); j++) {
            	// 1 << 0 ==> 0001；1 << 1 ==> 0010；1 << 2 ==> 0100 
            	// & 按位与操作: 当相应位都为 1 时，结果才为 1 
                if ((i & (1 << j)) != 0) temp.push_back(nums[j]);
            }
            ans.push_back(temp);
        }

        return ans;
    }
};
全排列

46. 全排列

跟 子集 的关于 dfs 的思路差不多，DFS 用于遍历所有可能的排列组合。
DFS 的每一层代表一个元素的选择。第一层是第一个元素的选择，第二层是第二个元素的选择，以此类推。索引 idx 表示当前层次，也是正在选择第 idx 个位置的元素，通过循环遍历和递归实现深度优先搜索的完整过程。

假设数组 nums = [1, 2, 3] ，第 idx = 0 层的选择有多种，要么是 1，要么是2，要么是 3；假设我们选择元素 2，则第 idx = 1 层的能选择的就有 [1, 3]；若选择了元素 3，则在第 idx = 2 层的元素就只剩下元素 1；这样构成了排列组合的其中一个的结果 [2, 3, 1]。

class Solution {
public:
    vector<vector<int>> ans;

    vector<vector<int>> permute(vector<int>& nums) {
        dfs(nums, 0);
        return ans;
    }

    void dfs(vector<int> nums, int idx) {
        if (nums.size() <= idx) {
            ans.push_back(nums);
            return;
        }

        for (int i=idx; i<nums.size(); i++) {
            swap(nums[idx], nums[i]); // 交换
            dfs(nums, idx+1);
            swap(nums[idx], nums[i]);  
        }
    }
};
全排列 II

47. 全排列 II

下图中，数组为 nums=[1, 2, 2]，那么第一个位置的元素要么是 1，要么是 2，要么是 2；因此存在两次第一个位置都为 2 的情况；
因此，若是第一个安排元素 2，则后续的第一个元素就不能再是 2，就可以避免重复。

只有当第一个 2 被使用了，后续的 2 才能被跳过
相当于在同一层中避免使用相同的元素

在这里插入图片描述

// 方式一：
class Solution {
public:
    vector<vector<int>> ans;
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        dfs(nums, 0);
        return ans;
    }

    void dfs(vector<int> nums, int idx) {
        if (nums.size() <= idx) {
            ans.push_back(nums);
            return;
        }

        set<int> st;
        for (int i=idx; i<nums.size(); i++) {
            if (st.find(nums[i]) != st.end()) 
                continue;  // 存在重复的值
            st.insert(nums[i]);

            swap(nums[idx], nums[i]); 
            dfs(nums, idx+1);
            swap(nums[idx], nums[i]);  
        }
    }
};


// 方式二：
class Solution {
public:
    vector<vector<int>> ans; 

    vector<vector<int>> permuteUnique(vector<int>& nums) {
        sort(nums.begin(), nums.end());

        vector<bool> used(nums.size(), false);
        vector<int> level;
        dfs(nums, level, used);
        return ans;
    }

    void dfs(vector<int>& nums, vector<int> level, vector<bool>& used) {
        if (level.size() == nums.size()) {
            ans.push_back(level);
            return;
        }

        for (int i=0; i < nums.size(); i++) {
            if (used[i]) continue;     // 使用过
            if (i > 0 && nums[i] == nums[i-1] && !used[i-1]) continue;
            
            used[i] = true;
            level.push_back(nums[i]);

            dfs(nums, level, used);

            level.pop_back();
            used[i] = false;
        }
    }
};
组合

77. 组合

class Solution {
public:
    vector<vector<int>> ans;

    vector<vector<int>> combine(int n, int k) {
        vector<int> level;
        dfs(n, k, 1, level);
        return ans;
    }

    void dfs(int n, int k, int idx, vector<int> level) {
        if (level.size() == k) {
            ans.push_back(level);
            return;
        }

        for (int i=idx; i <= n - (k - level.size()) + 1; i++) {
            // n - (k - level.size()) + 1 表示剩余元素是否足够生成一个新的组合 
            // k - level.size() 表示当前还需要选择的元素数量
            level.push_back(i);
            dfs(n, k, i+1, level);  // 下一层递归的起始点为 idx = i + 1
            level.pop_back();
        }
    }
};
I_am_toutu
关注
力扣刷题总结之BFS
ComeOnMr博客
04-20 1025
BFS基本思想 虽然题目千变万化，但是考察点永远是那几个。本题给出了一个场景：求 每个 1 到 0 的最短的曼哈顿距离。其中曼哈顿距离就是只能沿着横、竖到达另外一个点走的步数。 在一个图中，能从一个点出发求这种最短距离的方法很容易想到就是 BFS，BFS 的名称是广度优先遍历，即把周围这一圈搜索完成之后，再搜索下一圈，是慢慢扩大搜索范围的。 图左边是BFS，按照层进行搜索；图右边是 DFS，先一路...
代码随想录-力扣刷题-总结笔记02
最新发布
upward
04-04 1254
代码随想录-力扣刷题-总结笔记02
力扣刷题框架——BFS
qq_36919342的博客
07-22 595
BFS——广度优先搜索，核心思想就是把问题抽象成图，从一个点开始向四周扩散，一般用**队列**这种数据结构，每次将一个节点周围的所有节点加入队列。
力扣刷题系列——BFS和DFS
qq_43568704的博客
08-25 2756
BFS与DFS相关算法题 BFS 广度优先搜索（也称宽度优先搜索，缩写BFS，以下采用广度来描述）是连通图的一种遍历算法这一算法也是很多重要的图的算法的原型。Dijkstra单源最短路径算法和Prim最小生成树算法都采用了和宽度优先搜索类似的思想。其别名又叫BFS，属于一种盲目搜寻法，目的是系统地展开并检查图中的所有节点，以找寻结果。换句话说，它并不考虑结果的可能位置，彻底地搜索整张图，直到找到结果为止。基本过程，BFS是从根节点开始，沿着树(图)的宽度遍历树(图)的节点。如果所有节点均被访问，则算法中
力扣题解：542题01矩阵 知识点：多源BFS（确定当前遍历层次与否两类模板）用于求最短距离
个人工作中学到的专业技术与职业发展知识笔记
05-31 522
1、题目描述：题目链接 给定一个由 0 和 1 组成的矩阵，找出每个元素到最近的 0 的距离。 两个相邻元素间的距离为 1 。 示例 1: 输入: 0 0 0 0 1 0 0 0 0 输出: 0 0 0 0 1 0 0 0 0 注意: 给定矩阵的元素个数不超过 10000。 给定矩阵中至少有一个元素是 0。 矩阵中的元素只在四个方向上相邻: 上、下、左、右。 2、思路：搞懂题目考察什么，剩下的任务就是套模板！ a) 首先看到在矩阵上搜索距离，思考关于图的解法。 b) 本题给出了一个场景：求每个1到0的最短距
【力扣】面试08.10：颜色填充 | BFS
Heart_for_Ling的博客
05-09 312
题目描述 颜色填充。编写函数，实现许多图片编辑软件都支持的“颜色填充”功能。给定一个屏幕（以二维数组表示，元素为颜色值）、一个点和一个新的颜色值，将新颜色值填入这个点的周围区域，直到原来的颜色值全都改变。 说明： image 和 image[0] 的长度在范围 [1, 50] 内。 给出的初始点将满足 0 <= sr < image.length 和 0 <= sc < image[0].length。 image[i][j] 和 newColor 表示的颜色值在范围 [0, 655
使用力扣刷题的经验.pdf
04-21
例如，学习双指针、排序、二分查找、动态规划、递归、贪心思想、分治、深度优先搜索（DFS）、广度优先搜索（BFS）等算法，并尝试在力扣平台上解决相关的练习题。 在刷题的过程中，有效的方法能够帮助我们快速进步，...
力扣刷题-腐烂的橘子-解题思路与思考
JaneZ0206的博客
05-25 419
我一开始是想用DFS做，但是用DFS涉及到一个问题：它是从一个结点开始，递归寻找属于图的节点，直到这个结点递归结束。因此，用多源BFS做。我们最开始应该在队列q中加入所有的已经腐烂的橘子，之后再把和他们直接邻接的放在第二行，以此类推……
算法：力扣刷题
02-15
以下是关于Java算法和力扣刷题的一些关键知识点： 1. **排序算法**：包括快速排序、归并排序、冒泡排序、插入排序、选择排序等。这些排序算法各有优缺点，理解和熟练应用它们能帮助我们优化数据处理过程。 2. **...
【力扣】200：岛屿数量 | BFS 广度优先搜索
Heart_for_Ling的博客
04-20 339
题目描述 给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。 岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。 此外，你可以假设该网格的四条边均被水包围。 算法思路 审题，岛屿就是上下左右不与土地相连。 标准的BFS，直接遍历数组，当元素为1时开始上下左右扩散，遇到1就加入扩散列表，并将值修改为0，直到扩散列表为空。 这样整个遍历...
[力扣刷题总结](图,DFS和BFS篇)
weixin_38800498的博客
12-07 1294
文章目录~~~~~~~~~~~~图~~~~~~~~~~~~1034. 边界着色解法1：DFS 图 1034. 边界着色 给你一个大小为 m x n 的整数矩阵 grid ，表示一个网格。另给你三个整数 row、col 和 color 。网格中的每个值表示该位置处的网格块的颜色。 当两个网格块的颜色相同，而且在四个方向中任意一个方向上相邻时，它们属于同一 连通分量 。 连通分量的边界 是指连通分量中的所有与不在分量中的网格块相邻（四个方向上）的所有网格块，或者在网格的边界上（第一行/列或最后一行/列）的所.
力扣第139题：单词拆分（DFS，BFS，动态规划）
少渊的博客
10-24 683
一、题目内容 二、题目分析 对于这道题目我们首先要从头开始判断，一直到字符串结束为止。如下图一般，从0开始，读取c，发现并不在wordDict中，就继续读取a，直到读取到s之后，发现现在的字符串是cats，正好在给定的wordDict中，那么就从a开始，进行递归，递归的出口是当前的字符的个数是否等于给定字符串的长度，如果结果为是，就返回true。 那么我们将会得到这样一串代码 public boolean dfs(String s, Li...
力扣算法题—079单词搜索【DFS】
weixin_34376562的博客
04-17 241
给定一个二维网格和一个单词，找出该单词是否存在于网格中。 单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。 示例: board = [ ['A','B','C','E'], ['S','F','C','S'], ['A','D','E','E'] ] 给定 word = ...
【力扣分模块练习】DFS与BFS
abyss_miracle的博客
12-14 258
695. 岛屿的最大面积 深度优先，返回int 题意：给定一个包含了一些 0 和 1 的非空二维数组 grid 。 一个 岛屿 是由一些相邻的 1 (代表土地) 构成的组合，这里的「相邻」要求两个 1 必须在水平或者竖直方向上相邻。你可以假设 grid 的四个边缘都被 0（代表水）包围着。 找到给定的二维数组中最大的岛屿面积。(如果没有岛屿，则返回面积为 0 。) 如： 输入： [[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
力扣127
Faker_whoop的博客
06-07 251
我丢这题看着听简单的 但是其实内涵玄机 首先你要先想到用到图 同时需要知道每一个word都需要给他一个visit这样的标记 标记是否访问过，同时两个word判断是否能够转化就是判断两个有几个字母不一样 将能够转化的存在一个list里面 大佬的详解 我跟着大佬的思维自己写了一遍 package Leetcode; import java.util.*; /* 简述一下这道题 就是在所给的一个所谓的字典 寻找一个单词有没有和给的单词只有一个字母的差别
力扣207：课程表（Java拓扑排序：bfs+dfs）
m0_49499183的博客
10-23 958
你这个学期必须选修numCourses门课程，记为0到。在选修某些课程之前需要一些先修课程。先修课程按数组给出，其中，表示如果要学习课程ai则先学习课程bi。[0, 1]01请你判断是否可能完成所有课程的学习？如果可以，返回true；否则，返回false。true总共有 2 门课程。学习课程 1 之前，你需要完成课程 0。这是可能的。false总共有 2 门课程。学习课程 1 之前，你需要先完成​课程 0；并且学习课程 0 之前，你还应先完成课程 1。这是不可能的。
【DFS和BFS】力扣题解
weixin_43180675的博客
06-16 959
目录一、DFS和BFS相关概念二、DFS相关练习题1.岛屿的最大面积2.岛屿的数量3.朋友圈4.被围绕的区域5.太平洋大西洋水流问题三、BFS相关练习题1. 二进制矩阵中的最短路径2.单词接龙 一、DFS和BFS相关概念 深度优先搜索（DFS）在进行图的搜索时，得到一个新的节点，立即对新节点向下遍历，然后回溯。使用 DFS 对一个图进行遍历时，能够遍历到的节点都是从初始节点可达的，DFS 常用来求解这种 可达性 问题。 广度优先搜索（BFS）在搜索的时候，是一层一层地进行遍历，每层遍历都是以上一层遍历的结果
算法｜LeetCode（力扣）经典题：广度优先搜索（BFS）
峰峰的博客
03-08 2669
LeetCode经典（数据结构与算法）题刷题指南：广度优先搜索篇
LeetCode841. 钥匙和房间（深度优先的非递归解法）
wjgxajh的博客
11-20 813
有 N 个房间，开始时你位于 0 号房间。每个房间有不同的号码：0，1，2，…，N-1，并且房间里可能有一些钥匙能使你进入下一个房间。 在形式上，对于每个房间 i 都有一个钥匙列表 rooms[i]，每个钥匙 rooms[i][j] 由 [0,1，…，N-1] 中的一个整数表示，其中 N = rooms.length。 钥匙 rooms[i][j] = v 可以打开编号为 v 的房间。 最初，除 ...
前端算法实践：华为OD与力扣刷题 TypeScript版
数据结构与算法是编程的基础，无论是在力扣刷题，还是在日常的软件开发中，都扮演着重要的角色。这里列举了几个常见的数据结构： 1. 链表：一种线性数据结构，其中的元素由一系列节点构成，每个节点包含数据部分和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值