weixin_45221477的博客

解题思路广度优先搜索BFS代码/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } * TreeNode(int val, TreeNode left, Tr

解题思路首先找出当前炸弹能引爆的炸弹利用Map存储当前炸弹能引爆的炸弹编号(需要注意判断能否引爆的函数中要使用long类型,不然会产生溢出问题)根据Map集合,选择不同的炸弹作为起爆点,进行DFS或BFS找到最佳起爆点代码//DFS解法class Solution { public int maximumDetonation(int[][] bombs) { int ans = Integer.MIN_VALUE; //记录炸弹编号和其可以引爆的炸弹

解题思路DFS分为以下几个步骤1.构建邻接表和entry入度数组2.将所有entry为0的点入队,作为起点3.开始进行BFS,中心思想为用clone数组记录当前课程的实际所需完成时间课程实际完成时间 = 前置课程完成所需最大时间 + 课程本身学习所需要时间代码class Solution { public int minimumTime(int n, int[][] relations, int[] time) { int[] clone = time.clone();

解题思路BFS构造链表即可代码/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } *//** * Definition for singly-linked list. * public class ListN

解题思路构建有向连通图,然后进行BFS,如果能到达target就返回true 否则返回false代码class Solution { public boolean findWhetherExistsPath(int n, int[][] graph, int start, int target) { Map<Integer, HashSet<Integer>> map = new HashMap<>(); for (int i

解题思路将二叉树转为图,并规定1代表父子关系,2代表左子节点,3代表右子节点总的来说很巧妙,但是需要优化,否则会超时代码/** * @author bakazhou * @description * @date 2021年12月07日 14:06 **/class TreeNode { int val; TreeNode left; TreeNode right; TreeNode() {} TreeNode(int val) {

解题思路BFS即可,题目描述有问题,没用讲清楚边界区域的意思,但总体思想基本为BFS找出所有边界上的点,然后对边界点进行染色即可代码class Solution { public int[][] colorBorder(int[][] grid, int row, int col, int color) { int m = grid.length, n = grid[0].length; boolean[][] visited = new boolean[m][

解题思路两种思路BFS和DFS,因为是二叉搜索树,所以可以想到DFS加入条件判断肯定比BFS快代码//DFSclass Solution { public TreeNode searchBST(TreeNode root, int val) { return dfs(root,val); } public TreeNode dfs(TreeNode root,int val) { if (root.val == val) {

解题思路层次遍历即可代码/*// Definition for a Node.class Node { public int val; public List<Node> children; public Node() {} public Node(int _val) { val = _val; } public Node(int _val, List<Node> _children) {

解题思路BFS解决代码class Solution { public int integerReplacement(int n) { if (n == 1){ return 0; } if(n == 2147483647){ return 32; } LinkedList<Integer> queue = new LinkedList<>();

解题思路BFS解决主要在于helper函数找出所有的可转换单词与127的主要区别就是需要记录路径,因此将Queue的类型替换为List代码class Solution { public List<List<String>> findLadders(String beginWord, String endWord, List<String> wordList) { List<List<String>> ans = n

解题思路BFS解决，主要在于helper函数，找出所有可以变换的单词类型，且时间复杂度不高代码class Solution { public int ladderLength(String beginWord, String endWord, List<String> wordList) { int step = 0; //记录wordList当中的所有单词 HashSet<String> word

解题思路BFS解决代码class Solution { public int minimumOperations(int[] nums, int start, int goal) { Set<Integer> set = new HashSet<>(); LinkedList<Integer> queue = new LinkedList<>(); queue.add(start);

解题思路利用图的入度这一特性，进行bfs如果一门课程入度为0，那么说明这门课程可以学习了，因此每一轮都将所有可以学习的课程学习完，并将对应的后置课程入度-1，如此即可代码class Solution { public int[] findOrder(int numCourses, int[][] prerequisites) { int[][] edge = new int[numCourses][numCourses];//构造邻接矩阵 int[] entr

解题思路利用图的入度这一特性，进行bfs如果一门课程入度为0，那么说明这门课程可以学习了，因此每一轮都将所有可以学习的课程学习完，并将对应的后置课程入度-1，如此即可代码class Solution { public boolean canFinish(int numCourses, int[][] prerequisites) { int[][] edge = new int[numCourses][numCourses];//构造邻接矩阵 int[] en

解题思路因为要返回最少的跳跃次数，并且一定可以到达，所以采用BFS每轮循环找到所能跳跃到的所有点，直到跳到终点位置代码class Solution { public int jump(int[] nums) { LinkedList<Integer> queue = new LinkedList<>(); Set<Integer> set = new HashSet<>(); int step =

解题思路BFS1.构造图，n*n的矩阵,连通则为12.建立队列，将每次能到达的点入队，并将步数+13.如果步数已经到k，且队列中取出点为n-1，则ans+1代码class Solution { public int numWays(int n, int[][] relation, int k) { int[][] road = new int[n][n]; for(int i=0;i<relation.length;i++){

解题思路BFS思路1 2 34 5 0变成字符串后就是1 2 3 4 5 0所以0交换位置就是字符串中交换0的位置代码class Solution { public int slidingPuzzle(int[][] board) { int step = 0; String cur = beString(board); if (cur.equals("123450")){//当前已经满足 return 0;

解题思路利用BFS的思路代码class Solution { public int numBusesToDestination(int[][] routes, int source, int target) { Set<Integer> set = new HashSet<>(); Map<Integer,List<Integer>> map = new HashMap<>();//In

解题思路DFS超时，最终使用BFS代码class Solution { public int numSquares(int n) { int step=0; boolean[] flag = new boolean[n]; LinkedList<Integer> queue = new LinkedList<>(); queue.add(n); while (!queue.isEmpty()

解题思路利用BFS进行遍历因为树中所有值为唯一，因此不会有重复的节点，所以可以直接记录x和y父节点的值，以及他们所在的层数，最终判断层级是否相等，父节点是否不同代码/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int

解题思路bfs找到每一行的最大值并加入到ans中，最后返回代码/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } * TreeNode(int val, T

解题思路bfs层序遍历，取到最后一行的最左边的即可代码/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } * TreeNode(int val, TreeN

解题思路利用bfs进行层序遍历，利用dir来做判断，当前应该是从左至右还是从右至左代码/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } * TreeNod

解题思路利用bfs，找到对应的层数，再将需要添加的层加入其中代码/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } * TreeNode(int val,

解题思路bfs,然后取每次队列中的最后一个节点出来代码/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } * TreeNode(int val, TreeN

解题思路bfs将每层的节点数累加代码/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } * TreeNode(int val, TreeNode left,

解题模板// 计算从起点 start 到终点 target 的最近距离int BFS(Node start, Node target) { Queue<Node> q; // 核心数据结构 Set<Node> visited; // 避免走回头路 q.offer(start); // 将起点加入队列 visited.add(start); int step = 0; // 记录扩散的步数 while (q not empty)

解题思路使用bfs探索，如果找到了叶子节点就直接返回深度~代码/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } * TreeNode(int val, T

解题思路1.bfs基本的框架2.不能走回头路3.判断是否转到了死亡数字4.判断是否转到了正确数字5.需要保证每个位子上的数字向上向下转的情况都产生能完成以上五点这道题基本上就解决了代码class Solution { public int openLock(String[] deadends, String target) { Set<String> words = new HashSet<>(); for (int i=0;i

解题思路两种解法，但是大致思路相同第一种是dfs将每个点的值加入到一个list中，然后对list进行排序，再找出最小差值第二种是bfs将每个点的值加入到一个list中，然后对list进行排序，再找出最小差值代码/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(

二分查找加bfs public int minimumEffortPath(int[][] heights) { int length = heights.length; int weight = heights[0].length; int right = 99999999,left = 0;//代表的是最小体力消耗 int [][]dis = new int[][]{{0,-1},{0,1},{-1,0},{1,0}};//上下左右四个方

二分查找加上bfs,直到所找到的值既为最小也能到达右下角为止public int swimInWater(int[][] grid) { int[][] dir = new int[][]{{0,1},{0,-1},{1,0},{-1,0}}; int weight = grid.length; int length = grid[0].length; int left=Math.max(grid[0][0],grid[weight-1][l

在给定的网格中，每个单元格可以有以下三个值之一：值 0 代表空单元格；值 1 代表新鲜橘子；值 2 代表腐烂的橘子。每分钟，任何与腐烂的橘子（在 4 个正方向上）相邻的新鲜橘子都会腐烂。返回直到单元格中没有新鲜橘子为止所必须经过的最小分钟数。如果不可能，返回 -1。解题思路：其实就是一个传染问题，腐烂橘子会传染新鲜橘子，直到传染完毕或者无法传染为止1.BFSclass Soluti...

迷宫问题定义一个二维数组：int maze[5][5]0, 1, 0, 0, 0,0, 1, 0, 1, 0,0, 0, 0, 0, 0,0, 1, 1, 1, 0,0, 0, 0, 1, 0,它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。Input一个5 × 5的二维数组，表示一个迷宫。数据保证有...

参考：https://blog.youkuaiyun.com/yishuige/article/details/51769997什么时候用DFS，什么时候用BFS?二维数组的题目，N小于20的，适用DFS。而一般 N<= 200，N<=1000这种，一定不可能用DFS去做。而且并不只是整个题目不能用DFS，其中的每一步也不能使用DFS。BFS的基本步骤1.将初始点（一个或多个）加入一个集合...