算法技巧-DFS、BFS

已于 2022-09-04 01:06:08 修改
阅读量79 收藏
点赞数
分类专栏： leetCode 算法 文章标签： 深度优先 算法 宽度优先
于 2022-09-01 22:32:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41282486/article/details/126650619
版权

DFS

286. 墙与门

题解：

class Solution {

    private int[][] directions = new int[][] {
        {-1, 0}, {1, 0}, {0, -1}, {0, 1}
    };

    public void wallsAndGates(int[][] rooms) {
        final int m = rooms.length;
        final int n = rooms[0].length;

        for (int i = 0; i < m; i ++) {
            for (int j = 0; j < n; j ++) {
                if (Integer.MAX_VALUE == rooms[i][j]) {
                    bfs(rooms, i, j);
                }
            }
        }
    }

    private void bfs(int[][] rooms, int x, int y) {

        final int m = rooms.length;
        final int n = rooms[0].length;
        Queue<int[]> queue = new LinkedList<>();
        boolean[][] visited = new boolean[m][n];
        int step = 0;
        queue.offer(new int[]{x, y});

        while (!queue.isEmpty()) {
            int size = queue.size();
            step ++;
            for (int i = 0; i < size; i ++) {
                int[] curNode = queue.poll();
                for (int d = 0; d < directions.length; d ++) {

                    int curX = curNode[0] + directions[d][0];
                    int curY = curNode[1] + directions[d][1];

                    if (curX < 0 || curX >= m || curY < 0 || curY >= n || visited[curX][curY] || (- 1 == rooms[curX][curY])) {
                        continue;
                    }

                    if (0 == rooms[curX][curY]) {
                        rooms[x][y] = step;
                        return ;
                    }

                    visited[curX][curY] = true;
                    queue.offer(new int[]{curX, curY});
                }
                
            }
        }
    }
}
200. 岛屿数量

题解：

class Solution {

    private int[][] directions = new int[][]{
        {-1, 0}, {0, -1}, {1, 0}, {0, 1}
    };

    public int numIslands(char[][] grid) {
        final int m = grid.length;
        final int n = grid[0].length;
        int sum = 0;
        for (int i = 0; i < m; i ++) {
            for (int j = 0; j < n; j ++) {
                if ('1' == grid[i][j]) {
                    sum ++;
                    grid[i][j] = '0';
                    bfs(grid, i, j);
                }
            }
        }

        return sum;
    }

    private void bfs(char[][] grid, int x, int y) {

        final int m = grid.length;
        final int n = grid[0].length;
        boolean[][] visited = new boolean[m][n];
        Queue<int[]> queue = new LinkedList<>();
        queue.offer(new int[]{x, y});
        visited[x][y] = true;

        while (!queue.isEmpty()) {

            int size = queue.size();

            for (int i = 0; i < size; i ++) {
                int[] curNode = queue.poll();
                for (int d = 0; d < directions.length; d ++) {
                    int curX = curNode[0] + directions[d][0];
                    int curY = curNode[1] + directions[d][1];

                    if (curX < 0 || curX >= m || curY < 0 || curY >= n || visited[curX][curY] || '0' == grid[curX][curY]) {
                        continue;
                    }

                    visited[curX][curY] = true;
                    grid[curX][curY] = '0';
                    queue.offer(new int[]{curX, curY});
                }
            }
            
        }
    }
}
279. 完全平方数

题解：

class Solution {
    public int numSquares(int n) {
       Queue<Integer> queue = new LinkedList<>();
       queue.offer(n);

       int step = 0;

       while (!queue.isEmpty()) {
           int size = queue.size();
           step ++; 
           for (int i = 0; i < size; i ++) {
               int curNode = queue.poll();
               
               for (int j = (int)Math.sqrt(curNode); j > 0; j --) {
                   int temp = curNode - j * j;
                   if (temp < 0) {
                       continue;
                   }
                   if (0 == temp) {
                       return step;
                   }
                   queue.offer(temp);
               }
           }
       } 

       return step;
    }
}
133. 克隆图

总结：用hashMap做映射
题解：

/*
// Definition for a Node.
class Node {
    public int val;
    public List<Node> neighbors;
    public Node() {
        val = 0;
        neighbors = new ArrayList<Node>();
    }
    public Node(int _val) {
        val = _val;
        neighbors = new ArrayList<Node>();
    }
    public Node(int _val, ArrayList<Node> _neighbors) {
        val = _val;
        neighbors = _neighbors;
    }
}
*/

class Solution {
    private HashMap <Node, Node> visited = new HashMap <> ();
    public Node cloneGraph(Node node) {
        if (node == null) {
            return node;
        }

        // 如果该节点已经被访问过了，则直接从哈希表中取出对应的克隆节点返回
        if (visited.containsKey(node)) {
            return visited.get(node);
        }

        // 克隆节点，注意到为了深拷贝我们不会克隆它的邻居的列表
        Node cloneNode = new Node(node.val, new ArrayList());
        // 哈希表存储
        visited.put(node, cloneNode);

        // 遍历该节点的邻居并更新克隆节点的邻居列表
        for (Node neighbor: node.neighbors) {
            cloneNode.neighbors.add(cloneGraph(neighbor));
        }
        return cloneNode;
    }
}
494. 目标和

题解：

class Solution {

    private int sum = 0;

    public int findTargetSumWays(int[] nums, int target) {
        int total = 0;
        dfs(nums, 0, target, total);
        return sum;
    }

    private void dfs(int[] nums, int index, int target, int total) {

        if (index > nums.length) {
            return;
        }

        if (nums.length == index) {
            if (total == target) {
                sum ++;
            }
            return;
        }

        dfs(nums, index + 1, target, total + nums[index]);
        dfs(nums, index + 1, target, total - nums[index]);
    }
}
232. 用栈实现队列

题解：

class MyQueue {

    private Stack<Integer> inStack;
    private Stack<Integer> outStack;
    private int size;

    public MyQueue() {
        inStack = new Stack<>();
        outStack = new Stack<>();
        size = 0;
    }
    
    public void push(int x) {
        inStack.push(x);
        size ++;
    }
    
    public int pop() {
        if (!outStack.isEmpty()) {
            size --;
            return outStack.pop();
        }
        while (!inStack.isEmpty()) {
            outStack.push(inStack.pop());
        }
        size --;
        return outStack.pop();
    }
    
    public int peek() {
        if (!outStack.isEmpty()) {
            return outStack.peek();
        }
        while (!inStack.isEmpty()) {
            outStack.push(inStack.pop());
        }
        return outStack.peek();
    }
    
    public boolean empty() {
        return 0 == size;
    }
}

/**
 * Your MyQueue object will be instantiated and called as such:
 * MyQueue obj = new MyQueue();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.peek();
 * boolean param_4 = obj.empty();
 */
225. 用队列实现栈

题解：

class MyStack {

    private Queue<Integer> data;
    private Queue<Integer> helper;
    private int size;

    public MyStack() {
        data = new LinkedList<>();
        size = 0;
    }
    
    public void push(int x) {
        size ++;
        data.offer(x);
    }
    
    public int pop() {
        helper = new LinkedList<>();
        while (data.size() > 1) {
            helper.offer(data.poll());
        }
        int temp = data.poll();
        size --;
        data = helper;
        helper = null;
        return temp;
    }
    
    public int top() {
        helper = new LinkedList<>();
        while (data.size() > 1) {
            helper.offer(data.poll());
        }
        int temp = data.poll();
        helper.offer(temp);
        data = helper;
        helper = null;
        return temp;
    }
    
    public boolean empty() {
        return 0 == size;
    }

}

/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack obj = new MyStack();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.top();
 * boolean param_4 = obj.empty();
 */
542. 01 矩阵

题解：

// class Solution {

//     private int[][] directions = new int[][]{
//         {-1, 0}, {1, 0}, {0, 1}, {0, -1}
//     };

//     public int[][] updateMatrix(int[][] mat) {
//         final int m = mat.length;
//         final int n = mat[0].length;
//         int[][] ans = new int[m][n];
//         for (int i = 0; i < m; i ++) {
//             for (int j = 0; j < n; j ++) {
//                 if (1 == mat[i][j]) {
//                     int step = bfs(mat, i, j);
//                     ans[i][j] = step;
//                 }
//             }
//         }

//         return ans;
//     }

//     private int bfs(int[][] mat, int sr, int sc) {

//         final int m = mat.length;
//         final int n = mat[0].length;
//         int step = -1;
//         Queue<int[]> queue = new LinkedList<>();
//         boolean[][] visited = new boolean[m][n];
//         queue.offer(new int[]{sr, sc});
//         visited[sr][sc] = true;

//         while (!queue.isEmpty()) {

//             int size = queue.size();
//             step ++;
//             for (int i = 0; i < size; i ++) {
//                 int[] curNode = queue.poll();
//                 if (0 == mat[curNode[0]][curNode[1]]) {
//                     return step;
//                 }
//                 for (int d = 0; d < directions.length; d ++) {
//                     int x = curNode[0] + directions[d][0];
//                     int y = curNode[1] + directions[d][1];
//                     if (x < 0 || x >= m || y < 0 || y >= n || visited[x][y]) {
//                         continue;
//                     }
//                     visited[x][y] = true;
//                     queue.offer(new int[]{x, y});
//                 }
//             }
//         } 

//         return step;
//     }
// }
// 超时版本


class Solution {

    private int[][] directions = new int[][]{
        {-1, 0}, {1, 0}, {0, 1}, {0, -1}
    };

    public int[][] updateMatrix(int[][] mat) {
        final int m = mat.length;
        final int n = mat[0].length;
        int step = 0;
        Queue<int[]> queue = new LinkedList<>();
        boolean[][] visited = new boolean[m][n];
        int[][] ans = new int[m][n];
        for (int i = 0; i < m; i ++) {
            for (int j = 0; j < n; j ++) {
                if (0 == mat[i][j]) {
                    queue.offer(new int[]{i, j});
                    visited[i][j] = true;
                }
            }
        }

        while (!queue.isEmpty()) {

            int size = queue.size();
            
            for (int i = 0; i < size; i ++) {
                int[] curNode = queue.poll();
                if (1 == mat[curNode[0]][curNode[1]]) {
                    ans[curNode[0]][curNode[1]] = step;
                }
                for (int d = 0; d < directions.length; d ++) {
                    int x = curNode[0] + directions[d][0];
                    int y = curNode[1] + directions[d][1];
                    if (x < 0 || x >= m || y < 0 || y >= n || visited[x][y]) {
                        continue;
                    }
                    visited[x][y] = true;
                    queue.offer(new int[]{x, y});
                }
            }
            step ++;
        } 

        return ans;
    }
}
841. 钥匙和房间

题解：

class Solution {
    public boolean canVisitAllRooms(List<List<Integer>> rooms) {
        final int n = rooms.size();
        boolean[] visited = new boolean[n];
        dfs(rooms, 0, visited);
        boolean ans = true;
        for (boolean v : visited) {
            ans = (ans && v);
        }
        return ans;
    }

    private void dfs(List<List<Integer>> rooms, int index, boolean[] visited) {

        visited[index] = true;

        List<Integer> nodes = rooms.get(index);
        for (Integer i : nodes) {
            if (!visited[i]) {
                dfs(rooms, i, visited);
            }
        }
    }
}
547. 省份数量

题解：

class Solution {
    public int findCircleNum(int[][] isConnected) {

        final int m = isConnected.length;
        boolean[] visited = new boolean[m];
        int sum = 0;
        for (int i = 0; i < m; i ++) {
           if (!visited[i]) {
                visited[i] = true;
                sum ++;
                dfs(isConnected, visited, i);
            }     
        }

        return sum;
    }

    private void dfs(int[][] isConnected, boolean[] visited, int i) {
        final int n = isConnected.length;
        for (int j = 0; j < n; j ++) {
            if (!visited[j] && 1 == isConnected[i][j]) {
                visited[j] = true;
                dfs(isConnected, visited, j);
            }
        }
    }
}
131. 分割回文串

题解：

class Solution {
    public List<List<String>> partition(String s) {
        final int len = s.length();
        List<List<String>> res = new ArrayList<>();
        boolean[][] dp = new boolean[len][len];
        for (int right = 0; right < len; right ++) {
            for (int left = 0; left <= right; left ++) {
                if (s.charAt(left) == s.charAt(right) && (right - left <= 2 || dp[left + 1][right - 1])) {
                    dp[left][right] = true;
                }
            }
        }

        Deque<String> path = new ArrayDeque<>();
        dfs(s, 0, len, dp, path, res);
        return res;
    }

    private void dfs(String s, int start, int len, boolean[][] dp, Deque<String> path, List<List<String>> res) {

        if (start == len) {
            res.add(new ArrayList<>(path));
            return;
        }

        for (int i = start; i < len; i ++) {
            if (!dp[start][i]) {
                continue;
            }
            path.addLast(s.substring(start, i + 1));
            dfs(s, i + 1, len, dp, path, res);
            path.removeLast();
        }
    }
}
1091. 二进制矩阵中的最短路径

题解：

class Solution {

    private int[][] directions = new int[][]{
        {-1, -1}, {-1, 0}, {-1, 1},
        {0, -1}, {0, 1},
        {1, -1}, {1, 0}, {1, 1}
    };

    public int shortestPathBinaryMatrix(int[][] grid) {
        final int m = grid.length;
        final int n = grid[0].length;
        Queue<int[]> queue = new LinkedList<>();
        if (1 == grid[0][0] || 1 == grid[m - 1][n - 1]) {
            return -1;
        }
        boolean[][] visited = new boolean[m][n];
        queue.offer(new int[]{0, 0});
        visited[0][0] = true;
        int step = 0;

        while (!queue.isEmpty()) {
            int size = queue.size();
            step ++;
            for (int i = 0; i < size; i ++) {
                int[] curNode = queue.poll();
                int x = curNode[0];
                int y = curNode[1];
                if (x == m - 1 && y == n - 1) {
                    return step;
                }
                for (int d = 0; d < directions.length; d ++) {
                    int curX = x + directions[d][0];
                    int curY = y + directions[d][1];
                    
                    if (curX < 0 || curX >= m || curY < 0 || curY >= n || visited[curX][curY] || 1 == grid[curX][curY]) {
                        continue;
                    }
                    visited[curX][curY] = true;
                    queue.offer(new int[]{curX, curY});
                }
            }
            
        }

        return -1;
    }
}
远腾飞
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法-BFS
pourtheworld的博客
04-17 539
算法-BFSBFSbfs在二维数组1. 2021-4-10 十字路口最优解 BFS bfs在二维数组 1. 2021-4-10 十字路口最优解 题目： 在小美和小团生活的城市中，有n行m列共计n*m个十字路口，第i行j列的十字路口有两个属性aij，b­ij。当行人处在i行j列的路口，对于任意非负整数k: 当时间处在[k x aij+k x b­ij), (k+1) x aij+k x bij)时，行人可以选择走到i±1行j列的路口。 当时间处在[(k+1) x aij+k x bij), (k+1) x
算法-DFS
pourtheworld的博客
04-17 325
算法-DFSDFS暴力回溯1. 2021-4-7 两次回溯2. 2021-4-8 无向图转有向图 DFS 暴力回溯 1. 2021-4-7 两次回溯 题目： 现在有n个物品，每一个物品都有一个价值，现在想将这些物品分给两个人，要求这两个人每一个人分到的物品的价值总和相同（个数可以不同，总价值相同即可），剩下的物品就需要扔掉，现在想知道最少需要扔多少价值的物品才能满足要求分给两个人。 输入描述: 第一行输入一个整数 T，代表有 T 组测试数据。 对于每一组测试数据，一行输入一个整数 n ，代表物品的个数。
ACM算法设计---BFS、DFS
lshsgbb2333的博客
06-02 397
点击打开链接
数据结构与算法-图论-DFS/BFS
2303_76624483的博客
04-24 2446
我们首先定义一个图结构来表示城市中的路口（节点）和道路（边），然后实现 BFS 搜索找到最短路径。
FloodFill算法---DFS
最新发布
2301_80035594的博客
04-25 1798
floodfill算法是一种图像处理算法，用于填充连通区域。它的作用是将指定的像素点及其相邻的相同颜色的像素点都填充为指定的颜色，从而形成一个封闭的区域。 该算法常用于图像编辑软件中的涂色功能，也可以用于图像分割、边缘检测等应用。通过floodfill算法，可以快速、自动地填充图像中的特定区域，提高图像处理的效率和准确性。 floodfill算法的基本思想是通过递归或者栈来实现。 本文章详细介绍了floodfill算法的基本用法及模板，通过经典例题帮助友友快速掌握，希望可以帮到您。
ACM算法设计-BFS-DFS详解_算法_dfs_ACM_zoouts_bfs_
10-01
在计算机科学领域，特别是算法设计中，BFS（广度优先遍历）和DFS（深度优先遍历）是两种常用图或树结构的遍历方法。这两种算法在解决许多问题时发挥着至关重要的作用，例如在寻找最短路径、解决迷宫问题、网络爬虫...
matlab广度优先算法代码-Search-Algorithms-BFS-DFS-A-:搜索算法-BFS-DFS-A-
05-24
matlab广度优先算法代码搜索算法-BFS-DFS-A-star 搜索是AI中解决问题的通用技术。 这个项目将使您开始使用这些不同的算法： 蛮力搜索策略 广度优先搜索：它从根节点开始，先探索相邻节点，然后再向下一级邻居移动。 ...
basicworld#py_structure#chap7.2_图的基本遍历算法--DFS和BFS（python版）1
07-25
注意遍历的结果可能不止一种深度优先DFS深度优先遍历得到的顶点序列为深度优先搜索序列（DFS序列）访问顶点v，并记录为已访问检查v的邻接点，选择尚未访问的点，不
Graph-DFS-BFS.zip_dfs_strategy
09-24
在"Graph DFS BFS.CPP"这个文件中，很可能包含了用C++实现的DFS和BFS算法。C++是一种强大的编程语言，特别适合处理算法和数据结构。文件名中的"DFS"和"BFS"可能分别代表了两个函数，分别实现了这两种图遍历策略。...
Bfs-Dfs.rar_bfs
09-21
**标题：“Bfs-Dfs.rar_bfs”**的解析与详解 在计算机科学领域，图是一种数据结构，用于表示对象之间的关系。为了处理这些关系，我们通常会使用两种主要的图遍历算法：广度优先搜索（Breadth First Search，简称BFS...
[力扣] 动态规划（DP）问题分类汇总
寂寞风中一匹狼的博客
08-11 1701
动态规划是算法面试的一个重点，在力扣上有很多这类题目，题目是刷不完的，将动态规划的全部类型题目刷一遍可以达到事半功倍的效果。 1.线性动态规划 1.1 子序列系列： 题目一：最长上升子序列（300. 最长上升子序列） 题解：注意这里要求的子序列不是连续的，使用动态规划，dp[i]表示的是以下标i的数字作为结尾不连续最长上升子序列的长度，动态转移方程：dp[i] = max{dp[j] + 1, (0 <= j < i,a[j] < a[i]},dp表的初始状态为1，最后统计表中的最大值即为
滑动窗口与双指针
寂寞风中一匹狼的博客
11-29 837
1.最长区间 模板： int maxLength(int[] A) { int N = A.length; // 区间的左指针 int left = -1; int ans = 0; for (int i = 0; i < N; i++) { // assert 在加入A[i]之前，(left, i-1]是一个合法有效的区间 // step 1. 直接将A[i]加到区间中，形成(left, i] // step 2. 将A[i]加入之后，惰性
回溯算法总结
寂寞风中一匹狼的博客
09-06 414
解题的步骤是：先画图，再编码。去思考可以剪枝的条件， 为什么有的时候用 used 数组，有的时候设置搜索起点 begin 变量，理解状态变量设计的想法。 本序列参考资料 1.回溯算法入门级详解 + 练习 2.回溯法总结 3. 回溯算法主要有排列、组合、子集相关问题，Flood Fill，字符串中的回溯问题，游戏问题四大题型。 题型一：排列、组合、子集相关问题 题目一：全排列（46. 全排列） 代码如下： class Solution { public List<List<Integer&
[力扣] 动态规划（DP）问题分类汇总（二）
寂寞风中一匹狼的博客
08-24 289
3.区间DP 3.1 回文序列 回文区间DP模板： for (int i = 0; i < n; i ++) { dp[i][i] = true; res ++; } for (int i = n - 1; i >= 0; i --) { for (int j = i + 1; j < n; j ++) { // 判断s[i] == s[j],dp[i][
算法技巧-栈
寂寞风中一匹狼的博客
08-31 193
栈
算法技巧-队列
寂寞风中一匹狼的博客
09-01 192
队列
图论总结
寂寞风中一匹狼的博客
10-14 184
拓扑排序 拓扑排序的本质是：广度优先遍历 + 贪心算法。 拓扑排序是广度优先遍历和贪心算法应用于有向图的专有名词。 应用场景：任务调度计划、课程安排。 拓扑排序的作用： 1.得到一个拓扑序，拓扑序不唯一； 2.检测有向图是否有环。（补充：无向图中检测是否有环，使用的数据结构是并查集。） 算法流程： 1、在开始排序前，扫描对应的存储空间（使用邻接表），将入度为 0的结点放入队列。 2、只要队列非空，就从队首取出入度为 0 的结点，将这个结点输出到结果集中，并且将这个结点的所有邻接结点（它指向的结点）的入度减
动态规划三
寂寞风中一匹狼的博客
12-11 180
1.树状DP 337. 打家劫舍 III /** * 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,
力扣技巧一
寂寞风中一匹狼的博客
02-05 173
1.变量一定要初始化。 2.前缀和用于计算区间和。一般用于数组，连续子串。
Dijkstra算法与DFS、BFS在图论中的应用
本文将介绍Dijkstra算法以及DFS和BFS在图论中的应用。Dijkstra算法是一种用于寻找图中两点间最短路径的算法，适用于有权重的加权图。而DFS（深度优先搜索）和BFS（广度优先搜索）则是两种基本的图遍历方法，它们在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值