[Leetcode] BFS/DFS类java题解记录

已于 2022-05-04 15:53:25 修改
阅读量667 收藏
点赞数
分类专栏： LeetcodeJava 文章标签： 深度优先 leetcode java
于 2022-05-04 14:04:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34264472/article/details/124569586
版权

130. 被围绕的区域

class Solution {

    public int rows,cols;

    public void solve(char[][] board) {

        rows = board.length;
        cols = board[0].length;
        for(int i = 0;i<rows;i++){
            for(int j = 0;j<cols;j++){
                if(i == 0 || j == 0 || i == rows - 1 || j == cols - 1){
                    dfs(board,i,j);
                }
            }
        }
        for(int i = 0;i<rows;i++){
            for(int j = 0;j<cols;j++){
                if(board[i][j]=='O'){
                    board[i][j] = 'X';
                }else if(board[i][j]=='Z'){
                    board[i][j] = 'O';
                }
            }
        }
    }

    public void dfs(char[][] board,int i, int j){
        if(i<0 || i>=rows || j<0 || j>=cols || board[i][j]=='X' || board[i][j]=='Z'){
            return;
        }
        board[i][j]='Z';
        dfs(board, i-1, j);
        dfs(board, i+1, j);
        dfs(board, i, j-1);
        dfs(board, i, j+1);
    }
}

BFS写法： 

class Solution {
    //BFS迭代写法
    public void solve1(char[][] board) {
        int rows = board.length;
        if (rows < 1)
            return;
        int cols = board[0].length;
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                boolean isEdge = i == 0 || j == 0 || i == rows - 1 || j == cols - 1;
                if (isEdge && board[i][j] == 'O') {
                    bfs(board, i, j);
                }
            }
        }
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                if (board[i][j] == 'O') {
                    board[i][j] = 'X';
                } else if (board[i][j] == 'Z') {
                    board[i][j] = 'O';
                }
            }
        }
    }

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

200. 岛屿数量

class Solution {

    public int rows,cols;
    public int numIslands(char[][] grid) {
        rows = grid.length;
        cols = grid[0].length;
        int res = 0;
        for(int i = 0;i<rows;i++){
            for(int j=0;j<cols;j++){
                if(grid[i][j]=='1'){
                    res++;
                    dfs(grid,i,j);
                }
            }
        }
        return res;

    }

    public void dfs(char[][] grid,int i,int j){
        if(i<0 || i>=rows || j<0 || j>=cols || 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);
    }
}

79. 单词搜索

class Solution {
    public final int[][] dirs = {{-1, 0}, {0, -1}, {0, 1}, {1, 0}};
    public int rows, cols;

    public boolean exist(char[][] board, String word) {
        rows = board.length;
        cols = board[0].length;
        boolean[][] visited = new boolean[rows][cols];
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                if (dfs(board, i, j, 0, visited, word)) {
                    return true;
                }
            }
        }
        return false;
    }

    private boolean dfs(char[][] board, int i, int j, int k, boolean[][] visited, String word) {
        if (word.charAt(k) != board[i][j]) {
            return false;
        }
        if (word.charAt(k) == board[i][j] && k == word.length() - 1) {
            return true;
        }
        visited[i][j] = true;
        for (int[] dir : dirs) {
            int i1 = i + dir[0];
            int j1 = j + dir[1];
            if (i1 >= 0 && i1 < rows && j1 >= 0 && j1 < cols && !visited[i1][j1]) {
                if (dfs(board, i1, j1, k + 1, visited, word)) {
                    return true;
                }
            }
        }
        visited[i][j] = false;
        return false;
    }
}

547. 省份数量

class Solution {
    public int findCircleNum(int[][] isConnected) {
        int len = isConnected.length;
        boolean[] isVisit = new boolean[len];
        LinkedList<Integer> que = new LinkedList<>();
        int circle = 0;
        for (int i = 0; i < len; i++) {
            if (isVisit[i]) {
                continue;
            }
            que.addLast(i);
            isVisit[i] = true;
            while (!que.isEmpty()) {
                int j = que.removeLast();
                for (int k = 0; k < len; k++) {
                    if (isConnected[j][k] == 1 && !isVisit[k]) {
                        isVisit[k] = true;
                        que.addLast(k);
                    }
                }
            }
            circle++;
        }
        return circle;
    }
}

463. 岛屿的周长

class Solution {
    static int[] dx = {0, 0, 1, -1};
    static int[] dy = {1, -1, 0, 0};

    public int islandPerimeter(int[][] grid) {
        if (grid.length == 0) {
            return 0;
        }
        int rows = grid.length;
        int cols = grid[0].length;
        int result = 0;
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                if (grid[i][j] != 1) {
                    continue;
                }
                for (int z = 0; z < 4; z++) {
                    int x1 = i + dx[z];
                    int y1 = j + dy[z];
                    if (x1 < 0 || x1 >= rows || y1 < 0 || y1 >= cols || grid[x1][y1] == 0) {
                        result += 1;
                    }
                }
            }
        }
        return result;
    }
}

329. 矩阵中的最长递增路径

class Solution {
    public int rows, cols;
    public int[][] dirs = new int[][]{{1, 0}, {-1, 0}, {0, 1}, {0, -1}};

    public int longestIncreasingPath(int[][] matrix) {
        rows = matrix.length;
        cols = matrix[0].length;
        int maxlen = 0;
        int[][] path = new int[rows][cols];
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                int len = dfs(matrix, i, j, path);
                maxlen = Math.max(len, maxlen);
            }
        }
        return maxlen;
    }

    private int dfs(int[][] matrix, int i, int j, int[][] path) {
        if (path[i][j] > 0) {
            return path[i][j];
        }
        int maxlen = 1;
        for (int[] dir : dirs) {
            int i1 = i + dir[0];
            int j1 = j + dir[1];
            if (i1 >= 0 && i1 < rows && j1 >= 0 && j1 < cols && matrix[i1][j1] > matrix[i][j]) {
                int len = 1 + dfs(matrix, i1, j1, path);
                maxlen = Math.max(len, maxlen);
            }
        }
        path[i][j] = maxlen;
        return maxlen;
    }
}

207. 课程表

210. 课程表 II


public class CanFinish {

    // 207. 课程表
    public boolean canFinish(int numCourses, int[][] prerequisites) {

        int[] cnt = new int[numCourses];
        for (int[] pair : prerequisites) {
            cnt[pair[0]]++;
        }
        LinkedList<Integer> que = new LinkedList<>();
        for (int i = 0; i < numCourses; i++) {
            if (cnt[i] == 0) {
                que.addLast(i);
            }
        }
        int cntSize = que.size();
        while (!que.isEmpty()) {
            Integer x = que.removeFirst();
            for (int[] pair : prerequisites) {
                if (pair[1] == x) {
                    cnt[pair[0]]--;
                    if (cnt[pair[0]] == 0) {
                        que.addLast(pair[0]);
                        cntSize++;
                    }
                }
            }
        }
        return numCourses == cntSize;
    }

    // 210. 课程表 II
    public int[] findOrder(int numCourses, int[][] prerequisites) {
        int[] cnt = new int[numCourses];
        for (int[] pair : prerequisites) {
            cnt[pair[0]]++;
        }
        LinkedList<Integer> que = new LinkedList<>();
        for (int i = 0; i < numCourses; i++) {
            if (cnt[i] == 0) {
                que.addLast(i);
            }
        }
        int cntSize = que.size();
        int[] result = new int[numCourses];
        int index = 0;
        while (!que.isEmpty()) {
            Integer x = que.removeFirst();
            result[index++] = x;
            for (int[] pair : prerequisites) {
                if (pair[1] == x) {
                    cnt[pair[0]]--;
                    if (cnt[pair[0]] == 0) {
                        que.addLast(pair[0]);
                        cntSize++;
                    }
                }
            }
        }
        if (numCourses != cntSize) {
            return new int[]{};
        }
        return result;
    }

    public static void main(String[] args) {
        int[][] prerequisites = new int[][]{{1, 0}};
        CanFinish solution = new CanFinish();
        System.out.println(solution.canFinish(2, prerequisites));
    }
}

365. 水壶问题

class Solution {
    public boolean canMeasureWater(int jug1Capacity, int jug2Capacity, int targetCapacity) {
        if (targetCapacity > jug1Capacity + jug2Capacity) {
            return false;
        }
        Deque<int[]> stack = new LinkedList<int[]>();
        stack.push(new int[]{0, 0});
        Set<Long> isContain = new HashSet<>();
        while (!stack.isEmpty()) {
            int[] remain = stack.peek();
            stack.pop();
            int remainX = remain[0];
            int remainY = remain[1];
            if (isContain.contains(getHashValue(remainX, remainY))) {
                continue;
            }
            isContain.add(getHashValue(remainX, remainY));
            if (remainX == targetCapacity || remainY == targetCapacity || remainX + remainY == targetCapacity) {
                return true;
            }

            stack.push(new int[]{remainX, jug2Capacity});

            stack.push(new int[]{jug1Capacity, remainY});

            stack.push(new int[]{0, remainY});

            stack.push(new int[]{remainX, 0});

            stack.push(new int[]{remainX + Math.min(jug1Capacity - remainX, remainY), remainY - Math.min(jug1Capacity - remainX, remainY)});

            stack.push(new int[]{remainX - Math.min(remainX, jug2Capacity - remainY), remainY + Math.min(remainX, jug2Capacity - remainY)});
        }

        return false;

    }

    private long getHashValue(int x, int y) {
        return (long)x * 1000000L + y;
    }
}

542. 01 矩阵

class Solution {
    static int[][] dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

    public int[][] updateMatrix(int[][] matrix) {
        int m = matrix.length, n = matrix[0].length;
        int[][] dist = new int[m][n];
        boolean[][] seen = new boolean[m][n];
        Queue<int[]> queue = new LinkedList<int[]>();
        // 将所有的 0 添加进初始队列中
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                if (matrix[i][j] == 0) {
                    queue.offer(new int[]{i, j});
                    seen[i][j] = true;
                }
            }
        }

        // 广度优先搜索
        while (!queue.isEmpty()) {
            int[] cell = queue.poll();
            int i = cell[0], j = cell[1];
            for (int d = 0; d < 4; ++d) {
                int ni = i + dirs[d][0];
                int nj = j + dirs[d][1];
                if (ni >= 0 && ni < m && nj >= 0 && nj < n && !seen[ni][nj]) {
                    dist[ni][nj] = dist[i][j] + 1;
                    queue.offer(new int[]{ni, nj});
                    seen[ni][nj] = true;
                }
            }
        }

        return dist;
    }
}

class Solution {

    public final int[][] dirs = new int[][]{{1, 0}, {-1, 0}, {0, 1}, {0, -1}};

    public int[][] updateMatrix(int[][] mat) {

        LinkedList<int[]> que = new LinkedList<>();

        int rows = mat.length;
        int cols = mat[0].length;

        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                if (mat[i][j] == 0) {
                    que.addLast(new int[]{i, j});
                } else {
                    mat[i][j] = -1;
                }
            }
        }

        while (!que.isEmpty()) {
            int[] point = que.removeFirst();
            for (int[] dir : dirs) {
                int x1 = point[0] + dir[0];
                int y1 = point[1] + dir[1];
                if (x1 >= 0 && x1 < rows && y1 >= 0 && y1 < cols && mat[x1][y1] == -1) {
                    mat[x1][y1] = mat[point[0]][point[1]] + 1;
                    que.addLast(new int[]{x1, y1});
                }
            }
        }
        return mat;

    }
}

努力的小陶
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode 经典宽搜BFS深搜DFS题目(思路、方法、code)
Ding 的博客
05-14 1758
leetcode 经典宽搜BFS深搜DFS题目(思路、方法、code) BFS和DFS的经典应用就是在树和图中的遍历。 地图的搜索问题通常都可以用BFS和DFS解决，下面题目非常典型，并且很多题目类似，自己如果能够独立完成基本就掌握了BFS和DFS以及地图的遍历问题。 文章目录leetcode 经典宽搜BFS深搜DFS题目(思路、方法、code)[200. 岛屿数量](https://leetcode-cn.com/problems/number-of-islands/)[127. 单词接龙](https:
LeetCode 310. 最小高度树(BFS/DFS/拓扑排序/树形DP)
xylitolz的博客
04-07 827
文章目录题目描述解法一：枚举根节点+DFS求树高（超时）解法二：广度优先搜索解法三：拓扑排序解法四：树形DPReference 题目描述 310. 最小高度树 解法一：枚举根节点+DFS求树高（超时） 枚举以每个节点为根构成的树，然后求出该树的高度，所有树的最小高度即为答案，需要的时间复杂度为 O(n2)O(n^2)O(n2) 算法流程： 从000到n−1n-1n−1枚举根节点 利用dfs求出以i(i∈[0,n−1])i(i\in [0,n-1])i(i∈[0,n−1])为根节点的树高，并保
Java实现 LeetCode 773 滑动谜题（BFS）
南 墙
05-01 8804
773. 滑动谜题 在一个 2 x 3 的板上（board）有 5 块砖瓦，用数字 1~5 来表示, 以及一块空缺用 0 来表示. 一次移动定义为选择 0 与一个相邻的数字（上下左右）进行交换. 最终当板 board 的结果是 [[1,2,3],[4,5,0]] 谜板被解开。 给出一个谜板的初始状态，返回最少可以通过多少次移动解开谜板，如果不能解开谜板，则返回 -1 。 示例： 输入：board ...
Java--Leetcode--地图分析（BFS）
xzzz2020的博客
03-29 206
你现在手里有一份大小为 N x N 的『地图』（网格） grid，上面的每个『区域』（单元格）都用 0 和 1 标记好了。其中 0 代表海洋，1 代表陆地，你知道距离陆地区域最远的海洋区域是是哪一个吗？请返回该海洋区域到离它最近的陆地区域的距离。 我们这里说的距离是『曼哈顿距离』（ Manhattan Distance）：(x0, y0) 和 (x1, y1) 这两个区域之间的距离是 |x0 - ...
LeetCode[Java-BFS模板]
Slashyouth的博客
03-17 378
279.完全平方数   给定正整数 n，找到若干个完全平方数（比如 1, 4, 9, 16, …）使得它们的和等于 n。你需要让组成和的完全平方数的个数最少。   给你一个整数 n ，返回和为 n 的完全平方数的 最少数量 。   完全平方数 是一个整数，其值等于另一个整数的平方；换句话说，其值等于一个整数自乘的积。例如，1、4、9 和 16 都是完全平方数，而 3 和 11 不是。 问题分析   可以将每个整数看成图中的一个节点，如果两个整数之差为一个平方数，那么这两个整数所在的节点就有一条边。   要求
BFS算法-leetcode java题解
qq_23858785的博客
12-19 808
BFS算法-leetcode java题解
leetcode分类-leetcode:Leetcode题目分类总结，附题解及思路
06-30
例如，“二叉树的最近公共祖先”可以利用递归或层次遍历来解决，而“最短路径遍历所有节点”则可能需要用到BFS或DFS。 五、堆与队列 堆是一种高效的优先级队列实现，而队列在许多问题中起到缓冲作用。如“最小覆盖...
js-leetcode题解之种花问题-题解.zip
最新发布
05-09
这个名为“js-leetcode题解之种花问题-题解.zip”的压缩包文件，显然是针对LeetCode中的一道具体题目——“种花问题”提供了JavaScript的解决方案。下面，我们将详细探讨这道题目及其解题策略。 “种花问题”通常是...
leetcode题库-LeetCode-Topic:LeetCode专题刷题模板分类Java版讲解
06-29
leetcode题库 LeetCode 专题 介绍 本仓库用来记录初学者能够理解的各类算法题的模板、思路，并汇总yxc老师推荐的相应习题以及其他的习题，并且有Java版的已经AC的答案...7搜索_DFS_BFS专题 8滑动窗口_双指针_单调队列 9
idea本地调试leetcode-leetcode:我的leetcode题解
07-01
src/main/java 里，src/main/test 是对应的测试用例，这部分代码可以通过 maven (如 mvn clean test) 执行 另一部分题解在 src/main/leetcode/editor/cn 里， 是 IntelliJ-IDEA leetcode 插件生成的文件格式，是另一...
dfs bfs java_DFS和BFS讲解及Leetcode刷题小结（1）（JAVA）
weixin_39669163的博客
02-12 208
DFS(深度优先)与BFS(广度优先)是两种非常重要的算法，要注意的是，这是算法，与其数据结构并无关系，任何数据结构都可以使用这种算法！其中树和图的数据结构使用该算法比较多。这两种算法原理非常好理解，但是他们的应用极其的灵活，而且实现步骤上极其讲究，非常容易编写错误，但又找不到问题的出处，希望这两篇文章可以从原理到实现，从实现到应用完整的讲解DFS与BFS这篇文章为对DFS的整理，文末为Leetc...
【BFS】【递归】【Java】Leetcode 对称二叉树
XVII 的博客
08-14 185
给定一个二叉树，检查它是否是镜像对称的。 例如，二叉树 [1,2,2,3,4,4,3] 是对称的。 1 / \ 2 2 / \ / \ 3 4 4 3 但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的: 1 / \...
Java实现 LeetCode 1161.最大层内元素和（BFS）
Cypresszky的博客
07-25 165
给你一个二叉树的根节点 root。设根节点位于二叉树的第 1 层，而根节点的子节点位于第 2 层，依此类推。 请你找出层内元素之和 最大 的那几层（可能只有一层）的层号，并返回其中 最小 的那个。 示例： 输入：[1,7,0,7,-8,null,null] 输出：2 解释： 第 1 层各元素之和为 1， 第 2 层各元素之和为 7 + 0 = 7， 第 3 层各元素之和为 7 + -8 = -1， 所以我们返回第 2 层的层号，它的层内元素之和最大。 提示： 树中的节点数介于 1 和 10^4 之间 -1
LeetCode DFS&BFS 题库
qq_52138199的博客
01-13 181
lc.226 lc.46 lc.47 lc.51 lc.52
【BFS】【迭代】【Java】Leetcode 二叉树最小深度
XVII 的博客
08-14 345
给定一个二叉树，找出其最小深度。 最小深度是从根节点到最近叶子节点的最短路径上的节点数量。 说明: 叶子节点是指没有子节点的节点 public class MinDeepTree { public static void main(String[] args) { TreeNode treeNode=new TreeNode(1); TreeNod...
leetcode高频题笔记之DFS和BFS
clonechen
03-23 2416
文章目录代码模板BFS模板DFS模板递归玩法非递归玩法二叉树的层次遍历括号生成在每个树行中找最大值岛屿数量岛屿的最大面积被围绕的区域单词接龙 代码模板 BFS模板 def BFS(graph, start, end): visited = set() queue = [] queue.append([start]) while queue: node = queue.po...
leetcode经典题目（11）--BFS和DFS
我只钓小鱼的博客
09-02 630
矩阵中的最短路径；连通面积，连通分支；数字的排列（有重复与无重复）；组合之和（有序和无序，可重复和不可重复）；子集（有重复和无重复）；分割回文串；字符串与矩阵路径
[Leetcode][第130题][JAVA][被围绕的区域][DFS][BFS]
dadongwudi的博客
08-11 259
【问题描述】[中等] 【解答思路】 1. 深度优先搜索 使用深度优先搜索实现标记操作。在下面的代码中，我们把标记过的字母 O 修改为字母 A。 复杂度 class Solution { int[] dx = {1, -1, 0, 0}; int[] dy = {0, 0, 1, -1}; public void solve(char[][] board) { int n = board.length; if (n == 0) {
LeetCode刷题记录--深度优先搜索(bfs,dfs,拓扑排序)
m0_67739923的博客
04-18 678
dfs,拓扑排序，二叉树反序列化，暴搜
Python双指针算法解LeetCode2/3/4Sum问题
"这篇资源主要讨论了如何使用Python的双指针算法来解决LeetCode中的2Sum、3Sum和4Sum问题，提供了不同方法的代码实现，包括暴力解法、排序优化以及哈希表结构的应用。" 在LeetCode中，2Sum、3Sum和4Sum是经典的数组...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值