LeetCode - 深度广度优先

已于 2022-10-12 22:43:49 修改
阅读量274 收藏
点赞数
分类专栏： 算法 文章标签： leetcode 宽度优先 算法
于 2022-02-28 20:41:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39505091/article/details/122760554
版权

文章目录

六. 搜索算法

1. 深度优先搜索

例题 695 求最大岛屿的面积。

  • 即求最大的连通区域的大小；
  • 主函数遍历矩阵，判断当前元素是否需要递归判断连通岛屿的面积；
  • 辅助函数用于递归计算岛屿面积；
  • 注意遍历过的地方需要将 1 置为 0 ，防止重复计算。
	//辅
	public int searchGrid(int[][] grid, int i, int j) {
        if(i >= grid.length || i < 0 || j >= grid[0].length || j < 0) {
            return 0;
        }
        if (grid[i][j] == 1) {
            //这里置成0，防止下次重新遍历到
            grid[i][j] = 0;
            return 1 + searchGrid(grid, i+1, j) + searchGrid(grid, i, j+1) + searchGrid(grid, i-1, j) + searchGrid(grid, i, j-1);
        }
        return 0;
    }
    //主
    public int maxAreaOfIsland(int[][] grid) {
        int row = grid.length;
        int col = grid[0].length; 
        int area = 0;
        int maxArea = 0;
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                if (grid[i][j] == 1) {
                    area = searchGrid(grid, i, j);
                    maxArea = maxArea < area ? area : maxArea; 
                }
            }
        }
        return maxArea;
    }

例题547。计算省份的数量

  • 即给出一个是否直接相连的二维矩阵，找出其中有多少个岛屿；
  • 深度优先搜索，主函数遍历每一个城市，判断该城市是否被访问过；
  • 辅函数以当前城市为基准，遍历所有城市判断是否有直接相连的城市，找到直接相连的城市，再以该城市为基准进行递归；
  • 需要维护一个当前城市是否被访问过的一维数组，防止重复访问。
/**
    这个递归函数从进入到退出刚好访问一个省会
     */
    public void search(int[][] isConnected, boolean[] isVisited, int i) {
        if (i < 0 || i >= isConnected.length) {
            return;
        }
        //以当前城市为基准，重新遍历所有城市看是否能访问
        for (int j = 0; j < isConnected.length; j++) {
            if (isConnected[i][j] == 1 && !isVisited[j]) {
                isVisited[j] = true;
                search(isConnected, isVisited, j);
            } 
        }
    }
    public int findCircleNum(int[][] isConnected) {
        /**
        深度优先搜索，从一个城市开始，遍历所有与之直接相连的城市，遍历过的做个标记防止重复遍历
         */
        int sum = 0;
        boolean[] isVisited = new boolean[isConnected.length];
        for (int i = 0; i < isConnected.length; i++) {
            if (!isVisited[i]) {
                sum += 1;
                isVisited[i] = true;
                search(isConnected, isVisited, i);
            }
        }
        return sum;
    }

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

  • 按照题目的意思顺流判断是否能到达太平洋和大西洋，需要考虑的条件很复杂；
  • 可以考虑倒流，从四边往内倒流，只要能访问即表示可流到；
  • 这种方式的思路是只要当前值可连通，如果四周的值更大，那肯定更满足要求；
  • 上边和左边一定能流到太平洋，下边和右边一定能流到大西洋。
	public static void search(int[][] heights, int i, int j, boolean[][] canReach) {
        if (i < 0 || j >= heights[0].length || canReach[i][j]) {
            return;
        }
        //可访问到即可达，这也是倒流的好处
        canReach[i][j] = true;
        if (i >= 1 && heights[i][j] <= heights[i-1][j]) {
            search(heights,i-1, j, canReach);
        }
        if (i < heights.length-1 && heights[i][j] <= heights[i+1][j]) {
            search(heights,i+1, j, canReach);
        }
        if (j >= 1 && heights[i][j] <= heights[i][j-1]) {
            search(heights,i, j-1, canReach);
        }
        if (j < heights[0].length-1 && heights[i][j] <= heights[i][j+1]) {
            search(heights,i, j+1, canReach);
        }


    }
    
    public List<List<Integer>> pacificAtlantic(int[][] heights) {
        /**
        按照题目的意思顺流判断是否能到达太平洋和大西洋，需要考虑的条件很复杂；
        可以考虑倒流，从四边往内倒流，只要能访问即表示可流到。
        上边和左边表示能流到太平洋，下边和右边表示能流到大西洋
         */
        List<List<Integer>> retList = new ArrayList<>();
        int m = heights.length;
        int n = heights[0].length;
        boolean[][] canReachP = new boolean[m][n];
        boolean[][] canReachA = new boolean[m][n];
        for (int i = 0; i < m; i++) {
            search(heights, i, 0, canReachP);
            search(heights, i, n-1, canReachA);
        }
        for (int j = 0; j < n; j++) {
            search(heights, 0, j, canReachP);
            search(heights, m-1, j, canReachA);
        }
        for (int i = 0; i < m; i ++) {
            for (int j = 0; j < n; j++) {
                if(canReachP[i][j] && canReachA[i][j]) {
                    retList.add(Arrays.asList(i, j));
                }
            }
        }
         return retList;
    }

2. 回溯法

例题46. 全排列

  • 回溯法在递归前修改状态，在回溯时将状态还原；
  • 求全排列时，一个数组的全排列等于选定一个数，加剩余数的全排列；
  • 如 [1, 2, 3] 的全排列等于选定 1 + [2, 3] 的全排列，及选定 2 + [1, 3] 的全排列，及选定 3 + [1, 2] 的全排列；而 [2, 3] 的全排列等于选定 2 加 [3] 的全排列，及选定 3 加 [2] 的全排列，以此类推。
	public void swap(List<Integer> nums, int i, int j) {
        int tmp = nums.get(i);
        nums.set(i, nums.get(j));
        nums.set(j, tmp);
    }
    /**
    从start开始的nums的全排列
     */
    public void sort(List<Integer> nums, List<List<Integer>> retList, int start) {
        if (start == nums.size() - 1) {
            retList.add(new ArrayList<Integer>(nums));
        }
        for (int i = start; i < nums.size(); i++) {
            // 对于当前位置 start，可以与后续每一个位置交换，得到一种排列
            swap(nums, i, start);
            // 第一位选定后（i），继续处理后一个位置
            sort(nums, retList, start + 1);
            //恢复原样
            swap(nums, i, start);
        }
    }
    public List<List<Integer>> permute(int[] nums) {
        List<Integer> newNums = new ArrayList<>();
        for (int i = 0; i < nums.length; i++) {
            newNums.add(nums[i]);
        }
        List<List<Integer>> retList = new ArrayList<>();
        sort(newNums, retList, 0);
        return retList;
    }

还可以不采用原数组交换的方式，而是用一个新的列表来存储当前的全排列数组，这样更好理解，但是需要多占用空间

public static void sort(int[] nums, List<Integer> tmpList, boolean[] isVisited, List<List<Integer>> retList) {
        if (tmpList.size() == nums.length) {
            retList.add(new ArrayList<Integer>(tmpList));
            return;
        }
        //注意这里从0开始
        for (int i = 0; i < nums.length; i++) {
            //被使用的不能再用
            if (isVisited[i]) {
                continue;
            }
            isVisited[i] = true;
            tmpList.add(nums[i]);
            sort(nums, tmpList, isVisited, retList);
            //回溯恢复
            isVisited[i] = false;
            tmpList.remove(Integer.valueOf(nums[i]));
        }
    }
    public static List<List<Integer>> permute(int[] nums) {
        boolean[] isVisited = new boolean[nums.length];
        List<List<Integer>> retList = new ArrayList<>();
        //利用一个tmpList存储当前的全排列数组
        List<Integer> tmpList = new ArrayList<>();
        sort(nums, tmpList, isVisited, retList);
        return retList;
    }

如果全排列的数组中含重复数字，则得想办法进行剪枝：

public void sort(int[] nums, List<Integer> tmpList, boolean[] isVisited, List<List<Integer>> retList) {
        if (tmpList.size() == nums.length) {
            retList.add(new ArrayList<Integer>(tmpList));
            return;
        }
        //注意这里从0开始
        for (int i = 0; i < nums.length; i++) {
            //被使用的不能再用
            if (isVisited[i]) {
                continue;
            }
            //含重复数字只需添加这一步剪枝
            //!isVisited[i-1]是因如果前一个相同数字没被使用，那么这个数字就会在后面再次被选中造成重复
            if (i > 0 && nums[i] == nums[i-1] && !isVisited[i-1]) {
                continue;
            }
            isVisited[i] = true;
            tmpList.add(nums[i]);
            sort(nums, tmpList, isVisited, retList);
            //回溯恢复
            isVisited[i] = false;
            //删除最后一个
            tmpList.remove(tmpList.size() - 1);
        }
    }
    public List<List<Integer>> permuteUnique(int[] nums) {
        boolean[] isVisited = new boolean[nums.length];
        List<List<Integer>> retList = new ArrayList<>();
        //利用一个tmpList存储当前的全排列数组
        List<Integer> tmpList = new ArrayList<>();
        //含重复数字需要排序将重复的数字排列在一起
        Arrays.sort(nums);
        sort(nums, tmpList, isVisited, retList);
        return retList;
    }

例题77. 组合
给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。

  • 排列回溯的是交换的位置，而组合回溯的是否把当前的数字加入结果中；
  • 排列递归时传入的 start 是 start+1，而组合传入的是 i+1，因为组合时永远是在后一位寻找数字。
/**
    组合与排列类似，只是在回溯的时候是将添加的元素恢复
     */
    public void myComb(List<Integer> tmpList, List<List<Integer>> retList, int start, int n, int k) {
        if (k == 0) {
            retList.add(new ArrayList(tmpList));
            return;
        }
        //注意这里i <= n-k+1, 因为超过n-k+1的话，tmpList总长度永远小于k
        for (int i = start; i <= n-k+1; i ++) {
            tmpList.add(i);
            //这里的start是i+1，而不是排列中的start+1
            myComb(tmpList, retList, i+1, n, k-1);
            tmpList.remove(tmpList.size()-1);
        }
    }
    public List<List<Integer>> combine(int n, int k) {
        List<List<Integer>> retList = new ArrayList<>();
        myComb(new ArrayList<>(), retList, 1, n, k);
        return retList;
    }

例题40. 含重复数字的组合题。给定一个候选人编号的集合 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。candidates 中的每个数字在每个组合中只能使用 一次 。解集不能包含重复的组合。

  • 组合和全排列一样，如果含有重复数字，第一步要做的就是给数组排序，使得相同元素在一起；
  • 第二步是剪枝，i>0 && candidates[i] == candidates[i-1] && !isUsed[i-1]。
class Solution {
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        Arrays.sort(candidates);
        boolean[] isUsed = new boolean[candidates.length];
        List<List<Integer>> retList = new ArrayList<>();
        List<Integer> list = new ArrayList<>();
        dfs(candidates, target, list, retList, isUsed, 0);
        return retList;
    }

    public void dfs(int[] candidates, int target, List<Integer> list, List<List<Integer>> retList, boolean[] isUsed, int start) {
        if (target == 0) {
            retList.add(new ArrayList<>(list));
            return;
        }
        if (target < 0) {
            return;
        }
        for (int i = start; i < candidates.length; i++) {
            if (isUsed[i]) {
                continue;
            }
        	//和全排列一样的剪枝方法
            if (i>0 && candidates[i] == candidates[i-1] && !isUsed[i-1]) {
                continue;
            }
            list.add(candidates[i]);
            isUsed[i] = true;
            dfs(candidates, target - candidates[i], list, retList, isUsed, i+1);
            isUsed[i] = false;
            list.remove(list.size() - 1);
        }
    }
}

排列组合小结：

  • 排列题：如果不含重复数字，可以通过对原数组进行位置交换得到全排列，注意此时要传入 start，dfs 时是 start+1；也可以另外开辟空间存储单个排列，并建立 isUsed 判断当前元素是否使用过，此时则无需传入 start，for 循环中 i = 0。如果含重复数字，则一定要使用方法二另外开辟空间，并且需要对数组排序和剪枝。
  • 组合题：组合题必须另外开辟空间存储单个组合，并且必须传入 start，for 循环中 i = start，因为组合时不能往回获取元素，dfs 时是 i + 1；如果数组中的元素可重复选取，那 dfs 时是 i。由于一定要传入start，则 isUsed 无需建立。但如果是含重复数字的组合题，则需要建立 isUsed 用于剪枝。

例题79. 单词搜索。在矩阵中搜索指定的单词，存在返回 true，否则返回 false。

  • 单词搜索回溯的是当前字母是否被使用；
public boolean search(char[][] board, char[] arr, int k, int n, int i, int j, boolean[][] isUsed) {
		//搜索到所有字母才算成功
        if (k == n) {
            return true;
        }
        if (i >= board.length || j >= board[0].length || i < 0 || j < 0) {
            return false;
        }
        if (arr[k] == board[i][j] && !isUsed[i][j]) {
            isUsed[i][j] = true;
            //选择了一个字母后，再在其周围搜索
            if(search(board, arr, k+1, n, i+1, j, isUsed) 
            || search(board, arr, k+1, n, i-1, j, isUsed) 
            || search(board, arr, k+1, n, i, j+1, isUsed) 
            || search(board, arr, k+1, n, i, j-1, isUsed)) {
                return true;
            } else {
            	//如果后续不满足要求，当前字母回退重新搜索
                isUsed[i][j] = false;
                return false;
            }
        }
        return false;

    }
    public boolean exist(char[][] board, String word) {
        char[] arr = word.toCharArray();
        // 存放字母是否被使用
        boolean[][] isUsed = new boolean[board.length][board[0].length];
        for (int i = 0; i < board.length; i++) {
            for (int j = 0; j < board[0].length; j++) {
                isUsed = new boolean[board.length][board[0].length];
                if (search(board, arr, 0, word.length(), i, j, isUsed)) {
                    return true;
                }
            }
        }
        return false;
         
    }

例题 51. N 皇后。将 n 个皇后放置在 n×n 的棋盘上，并且每一行、列、左斜、右斜最多只有一个皇后。

  • N 皇后问题有隐藏条件，即每一行都只能放置一个皇后，因此我们遍历时只需一行一行进行；
  • 回溯时回溯的是当前行里，该列是否放置皇后；
  • 需要建立方法判断当前是否能放置皇后。
/**
    判断当前是否能放置皇后
     */
    public boolean canPlace( int row, int col, int n, char[][] board) {
        // 检查列是否有皇后冲突
        for (int i = 0; i < row; i++) {
            if (board[i][col] == 'Q') {
                return false;
            }
        }
        // 检查右上方是否有皇后冲突
        for (int i = row - 1, j = col + 1; i >=0 && j < n; i--, j++) {
            if (board[i][j] == 'Q') {
                return false;
            }
        }
        // 检查左上方是否有皇后冲突
        for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--) {
            if (board[i][j] == 'Q') {
                return false;
            }
        }
        return true;
    }

    public void search(int k, int n, List<List<String>> retList, char[][] board, int i) {
        if (k == n) {
            List<String> tmpList = new ArrayList<>();
            for (char[] c : board) {
                String tmp = String.valueOf(c);
                tmpList.add(tmp);
            }
            retList.add(tmpList);
            return;
        }
        if (i < 0 || i >= n) {
            return;
        }
        //针对第i行的每一列
        for (int p = 0; p < n; p++) {
            if (canPlace(i, p, n, board)) {
                //放置
                board[i][p] = 'Q';
                search(k+1, n, retList, board, i+1);
                //撤销放置
                board[i][p] = '.';   
            } 
        }
    }
    public List<List<String>> solveNQueens(int n) {
        //初始化board数组
        char[][] board = new char[n][n];
        for (char[] c : board) {
            Arrays.fill(c, '.');
        }
        List<List<String>> retList = new ArrayList<>();
        //由于每行只能放一个，因此只需要对j进行遍历
        search(0, n, retList, board, 0);
        return retList;
    }

3. 广度优先算法

广度优先不同与深度优先搜索，它是一层层进行遍历的，因此需要用先入先出的队列进行遍历。由于是按层次进行遍历，广度优先搜索时按照“广”的方向进行遍历的，也常常用来处理最短路径等问题。最短路径就是当前层所在的层数。

例题 934. 最短的桥。给定一个二维 0-1 矩阵，其中 1 表示陆地，0 表示海洋，每个位置与上下左右相连。已知矩阵中有且只有两个岛屿，求最少要填海造陆多少个位置才可以将两个岛屿相连。

  • 实际上是求两个岛屿间的最短距离；
  • 先深度优先寻找到其中一个岛屿的所有坐标，再对该岛屿的每个坐标进行广度优先一层一层遍历，每遍历完一层，距离加一，直到找到第二个岛屿;
  • 遍历过的位置要进行记录，防止重复遍历；记得需要明确层与层间的边界，才能正确增加距离。
/**
    递归寻找第一个岛屿坐标
     */
    public void dfs(int i, int j, int[][] grid, Queue<int[]> retList, boolean[][] isVisited) {
        if (i < 0 || j < 0 || i >= grid.length || j>= grid[0].length) {
            return; 
        }
        if (grid[i][j] == 1) {
            grid[i][j] = 2;
            isVisited[i][j] = true;
            retList.add(new int[]{i, j});
            dfs(i+1, j, grid, retList, isVisited);
            dfs(i, j+1, grid, retList, isVisited);
            dfs(i-1, j, grid, retList, isVisited);
            dfs(i, j-1, grid, retList, isVisited);
        }

    }
    public int shortestBridge(int[][] grid) {
        /**
        先通过深度优先找到其中一个岛屿的所有坐标，并将值改成2，
        再通过广度优先一层一层寻找其与另一个岛屿的距离
         */
        Queue<int[]> landList = new LinkedList<>();
        boolean[][] isVisited = new boolean[grid.length][grid[0].length];
        //寻找第一个岛屿坐标
        boolean flag = true;
        for (int i = 0; i < grid.length && flag; i++) {
            for (int j = 0; j < grid[0].length && flag; j++) {
                if (grid[i][j] == 1) {
                    dfs(i, j, grid, landList, isVisited);
                    flag = false;//用于退出循环
                }
            }
        }
        //开始广度优先搜索
        int dis = 0;
        int[][] direc = new int[][]{{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
        while (!landList.isEmpty()) {
            //记录当前层的长度
            int size = landList.size();
            for (int k = 0; k < size; k ++) {
                int[] land = landList.poll();
                for (int i  = 0; i < 4; i++) {
                    int p = land[0] + direc[i][0];
                    int q = land[1] + direc[i][1];
                    if (p >= 0 && p < grid.length && q >= 0 && q < grid[0].length && !isVisited[p][q]) {
                        isVisited[p][q] = true;
                        //找到另一个岛屿直接返回
                        if (grid[p][q] == 1) {
                            return dis;
                        }
                        landList.add(new int[]{p, q});
                    }
                }
            }
            //搜索完当前层，到下一层长度需加一
            dis ++;
        }
        return Integer.MAX_VALUE;
    }

例题126.单词接龙 。按字典 wordList 完成从单词 beginWord 到单词 endWord 转化，一个表示此过程的 转换序列 是形式上像 beginWord -> s1 -> s2 -> … -> sk 这样的单词序列。

  • 广度优先建图获取可达关系，深度优先+回溯寻找所有可能的解；
  • 把每个字符串当作一个节点，如果某个字符串可以由另一个字符串通过变换一个字符得到，则这两个字符串可连接；通过广度优先为每个字符串确定所在的层级，用一个map存储当前字符串所在的层级，一个map存储当前字符串可达哪些下层字符串（注意同层或上层的字符串不能被加入到可达的下层字符串中）。
  • 将可达关系送入到深度优先算法中，递归+回溯寻找所有可能的解。
/**
     寻找当前字符串的可达字符串
     */
    public static Set<String> getWords(String beginWord, List<String> dict, Map<String, Integer> map) {
        Set<String> retSet = new HashSet<>();
        //当前将字符串的每一位进行替换，看是否在字典中
        for (int i = 0; i < beginWord.length(); i++) {
            char[] word = beginWord.toCharArray();
            for (char c = 'a'; c <= 'z'; c++) {
                word[i] = c;
                String tmp = String.valueOf(word);
                if (dict.contains(tmp)) {
                    //避免平级字符串被加入到可达字符串中
                    if (map.get(tmp) == null || map.get(tmp) > map.get(beginWord)) {
                        retSet.add(tmp);
                        map.put(tmp, map.get(beginWord) + 1);
                    }
                }
            }
        }
        return retSet;
    }
    /**
    dfs回溯寻找所有可能的解
     */
    public static void dfs(Map<String, Set<String>> wordMap, String beginWord, String endWord, List<String> tmpList, List<List<String>> retList) {
        if (endWord.equals(beginWord)) {
            retList.add(new ArrayList(tmpList));
            return;
        }
        Set<String> wordSet = wordMap.get(beginWord);
        for (String word : wordSet) {
            tmpList.add(word);
            dfs(wordMap, word, endWord, tmpList, retList);
            tmpList.remove(word);
        }

    }
    public static List<List<String>> findLadders(String beginWord, String endWord, List<String> wordList) {
        if (!wordList.contains(endWord)) {
            return new ArrayList<>();
        }
        Queue<String> queue = new LinkedList<>();
        queue.add(beginWord);
        //存储当前字符串所在的层级
        Map<String, Integer> map = new HashMap<>();
        //存储从一个字符串可以到后续哪些字符串
        Map<String, Set<String>> wordMap = new HashMap<>();
        int dis = 0;
        while(!queue.isEmpty()) {
            int size = queue.size();
            for (int i = 0 ; i < size; i++) {
                String word = queue.poll();
                //存储当前字符串所在层数
                map.putIfAbsent(word, dis);
                Set<String> words = getWords(word, wordList, map);
                wordMap.put(word, words);
                //当一个字符串有多个父级时，避免该字符串被重复加入队列
                queue.addAll(words.stream().filter(w -> !queue.contains(w)).collect(Collectors.toSet()));
            }
            dis ++;
        }
        List<List<String>> retList = new ArrayList<>();
        List<String> tmpList = new ArrayList<>();
        tmpList.add(beginWord);
        if (map.get(endWord) != null) {
            dfs(wordMap, beginWord, endWord, tmpList, retList);
        }
        return retList;
    }
weixin_39505091
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法刷题——深度优先搜索/广度优先搜索（1）
weixin_54510792的博客
05-21 386
dfs和bfs算是一个比较难的算法了吧（起码对我来说是这样）？近期呢我也是一直在学这个算法。 其实上学期在学数据结构时学过这个内容，但是嘞，由于只是上课听讲，课下并没有用代码去实现，导致现在只会一些理论上的概念，根本无法用代码实现搜索的过程，，，更何况我数据结构方面知识比较差，无法用结构体来存储一张图，更别说实现搜索过程了。 害，不过种一棵树最好的时间是十年前，其次是现在。现在努力学也不迟。 接下来是我这几天做的几道这方面的题 给你一个大小为 m x n 的二进制矩阵 grid 。 岛屿是..
LeetCode算法入门 day7 广度优先搜索/深度优先搜索
qq_52761202的博客
03-21 80
为了完成 上色工作 ，从初始像素开始，记录初始坐标的 上下左右四个方向上 像素值与初始坐标相同的相连像素点，接着再记录这四个方向上符合条件的像素点与他们对应 四个方向上 像素值与初始坐标相同的相连像素点，……岛屿 是由一些相邻的 1 (代表土地) 构成的组合，这里的「相邻」要求两个 1 必须在 水平或者竖直的四个方向上 相邻。有一幅以 m x n 的二维整数数组表示的图画 image ，其中 image[i][j] 表示该图画的像素值大小。计算并返回 grid 中最大的岛屿面积。
深度优先搜索_LeetCode进阶339-深度优先搜索（DFS）
weixin_39686353的博客
12-17 174
概念深度优先搜索算法(英语：Depth-First-Search，DFS)是一种用于遍历或搜索树或图的算法。沿着树的深度遍历树的节点，尽可能深的搜索树的分支。当节点v的所在边都己被探寻过，搜索将回溯到发现节点v的那条边的起始节点。这一过程一直进行到已发现从源节点可达的所有节点为止。如果还存在未被发现的节点，则选择其中一个作为源节点并重复以上过程，整个进程反复进行直到所有节点都被访问为止。属于盲目搜...
leetcode 785 --深度和广度搜索
qq_33228039的博客
07-17 136
1.题目 https://leetcode-cn.com/problems/is-graph-bipartite/ 给定一个无向图graph，当这个图为二分图时返回true。 如果我们能将一个图的节点集合分割成两个独立的子集A和B，并使图中的每一条边的两个节点一个来自A集合，一个来自B集合，我们就将这个图称为二分图。 graph将会以邻接表方式给出，graph[i]表示图中与节点i相连的所有节点。每个节点都是一个在0到graph.length-1之间的整数。这图中没有自环和平行边： graph
leetcode-广度优先遍历/图
MaYingColdPlay的博客
09-14 900
目录 ​​​​​​​279 完全平方数 127 单词接龙 以前的 现在的 ​ 注意： 单词接龙2 以前的 现在的 走迷宫 岛屿数量 深度优先搜索 广度优先搜索 并查集 岛屿数量2 ​ 并查集 5544. 执行操作后字典序最小的字符串 5548.最小体力消耗路径 回溯 bfs 并查集模版 力扣​​​​​​​ 407 接雨水2 并查集 路径压缩和按rank合并 547 省份数量 并查集模版 本题题解 743 网络延迟时间 Dijk...
leetcode答案-LeetCode-solution:LeetCode-解决方案
06-30
这题用到了深度优先遍历和广度优先遍历，正好稍微复习下数据结构 2017/11/8 还是637，发现广度优先遍历还没弄完，昨天搞啥去了…… 写了一下136，异或实在太屌了! 简直要高潮了 2017/11/9 104,二叉树的高度,其DFS和...
蓄水池算法leetcode-leetcode-js-chimy:leetcode-js-chimy
06-30
9.广度优先搜索 10.深度优先搜索 11.Map 12.极大化极小 13.拓扑排序 抽象数学 1. 随机 2. 蓄水池抽样 3. 数学 4. 几何 5. 设计 6. 脑筋急转弯 字符串 数组 链表 队列 栈 排序 树 图 贪心算法 分治算法 回溯算法 动态...
蓄水池算法leetcode-leetcode-cn.go:leetcode-cn.go
06-30
广度优先搜索 74 双指针 70 栈 64 并查集 30 分治算法 28 Sliding Window 24 递归 23 字典树 18 线段树 12 Ordered Map 10 队列 10 几何 9 极小化极大 8 树状数组 6 Line Sweep 6 Random 6 拓扑排序 6 二叉搜索树 5 ...
leetcode分类-leetcode-codelist:leetcode-codelist
06-30
广度优先遍历BFS 超级节点 双指针 977 941 有效山脉 滑动窗口 哈希表 1338 454 四数相加 快速排序 计数排序 1365 有多少小于当前数字的数字 1122 数组相对排序 注：固定数字用桶排序！！！！ 二分法 33 搜索旋转排序...
leetcode答案-leetcode-hot:leetcode-热门
06-30
如果是穷举答案相关的题（如八皇后、二叉树等），基本上来说，需要使用深度优先、广度优先或是回溯等递归的思路。 动态规划要重点准备一下，这样的题很多，如最大和子数组、买卖股票、背包问题、爬楼梯、改字符……...
LeetCode 刷题之 BFS 广度优先搜索【Python实现】
hj1993的博客
02-17 918
【代码】LeetCode 刷题之 BFS 广度优先搜索【Python实现】
(多源广度优先搜索)leetcode-994. 腐烂的橘子
apple_53406386的博客
05-12 95
而多源广度优先搜索相比于单源，无非就是最初初始化队列时，单源只需要加入一个源起点，而多源则需要把所有的多个起点都加入队列中，后面的步骤就差不多了。本题的代码有一个很巧妙的点：在判断一个点是否被访问过时，不需要单独开一个数组来记录访问状态，而是直接在原数组上修改值就可以。首先给出单源广度优先搜索的基本思路，参考。
LeetCode 1129颜色交替的最短路径【广度优先】HERODING的LeetCode之路
HERODING23的博客
02-01 278
一道非常有意思的广度优先遍历问题，一般的优先遍历问题，即可以广度优先遍历，也可以深度优先遍历，甚至动态规划求解，但是这里并不是求单一最优解问题，也不是按照顺序去执行的，所以深度优先和动态规划不太适用。这道题最有意思的地方在于，有向连接是有颜色区分的，也就是说，在构建邻接矩阵时，要考虑颜色的不同，同时红蓝相间连接表明要不断交替遍历红邻接矩阵和蓝邻接矩阵，红先红后两种情况都要考虑，剩下的就是简单的广度优先模板了，只不过要执行两遍罢了。
LeetCode广度优先与深度优先算法
weixin_54379276的博客
07-02 212
经典题目 102.二叉树的层序遍历 给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。 示例： 二叉树：[3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 7 返回其层序遍历结果： [ [3], [9,20], [15,7] ] 如果不需要确定当前遍历到了哪一层，(BFS)广度优先遍历模板如下。 while queue 不空： cur ...
LeetCode-题目详解：深度优先搜索、广度优先遍历
u013250861的博客
05-27 1377
一、高频题 1、高频题 1.1、105-从前序与中序遍历序列构造二叉树 1.2、131-分割回文串 1.3、200-岛屿数量 1.4、124-二叉树中的最大路径和 1.5、394-字符串解码 1.6、199-二叉树的右视图 1.7、17-电话号码的字母组合 1.8、104-二叉树的最大深度 1.9、101-对称二叉树 1.10、679-24 点游戏 1.11、98-验证二叉搜索树 1.12、721-账户合并 1.13、257-二叉树的所有路径 1.14、剑指 Offer 34-二叉树中和为某一值的路径 1.
【LeetCode 】试题总结：广度优先搜索（BFS）
haoweixl的博客
04-07 282
【LeetCode 】试题总结：广度优先搜索（BFS）二叉树的堂兄弟节点试题链接解题思路代码森林中的兔子试题链接：二叉树的层序遍历 II二叉树的锯齿形层序遍历 说明：本文仅做为本人总结算法竞赛试题的笔记，参照许多了题解，如有侵权请联系。 二叉树的堂兄弟节点 在二叉树中，根节点位于深度 0 处，每个深度为 k 的节点的子节点位于深度 k+1 处。 如果二叉树的两个节点深度相同，但 父节点不同 ，则它们是一对堂兄弟节点。 我们给出了具有唯一值的二叉树的根节点 root ，以及树中两个不同节点的值 x 和 y
LeetCode刷题笔记 优先搜索 图结构深度优先搜索
王清欢的博客
01-10 945
图结构深度优先搜索简介 ​ 深度优先搜索（depth-first seach，DFS）在搜索到一个新的节点时，立即对该新节点进行遍历；因此遍历需要用先入后出的栈来实现，也可以通过与栈等价的递归来实现。 ​ 对于树结构而言，由于总是对新节点调用遍历，因此看起来是向着 深 的方向前进，或者说是垂直方向。考虑如下一颗简单的树，由4 个节点构成共三层，其 DFS 过程如下图所示： ​ 图通常有两种表示方法。假设图中一共有 n 个节点、m 条边。 ​ 第一种表示方法是邻接矩阵（adjacency matrix）：我
LeetCode刷题笔记 优先搜索 网格结构深度优先搜索
王清欢的博客
01-07 991
深度优先搜索简介 深度优先搜索（depth-first seach，DFS）在搜索到一个新的节点时，立即对该新节点进行遍历；因此遍历需要用先入后出的栈来实现，也可以通过与栈等价的递归来实现。 二维数组深度优先搜索的一般写法： ​ 一般来说，深度优先搜索类型的题可以分为主函数和辅函数，主函数用于遍历所有的搜索位置，判断是否满足开始搜索的条件，如果可以即在辅函数中进行搜索。 ​ 辅函数负责实现深度优先搜索过程。这一过程可以使用递归调用调用实现；当然，我们也可以使用栈（stack）实现深度优先搜索，与使用队列 （
LeetCode算法刷题——广度优先搜索/深度优先搜索
qq_38958912的博客
10-25 438
LeetCode算法刷题by Python——广度优先搜索/深度优先搜索一、图像渲染广度优先搜索 (BFS)深度优先搜索 (DFS)二、岛屿最大面积BFSDFS四、填充每个节点的下一个右侧节点指针五、01矩阵六、腐烂的橘子 今天和大家一起学习广度优先搜索/深度优先搜索。作为一个小白，我认为积极与实验室师兄讨论是一个好习惯，师兄告诉我除去动态规划以外，广度优先搜索/深度优先搜索算是算法题中复杂度稍高的题目之一，but! 题目的套路相对来说比较固定，只要大家多做几道相关题目、多总结，就肥肠easy啦~ 话不多说
Leetcode高频考题整理
最新发布
08-24
Leetcode 高频考题整理确实是很有帮助的，以下是一些常见的 Leetcode 高频考题整理： 1. 数组和字符串问题： - 两数之和 (Two Sum) - 三数之和 (Three Sum) - 最长回文子串 (Longest Palindromic Substring) - 盛最多水的容器 (Container With Most Water) - 下一个排列 (Next Permutation) 2. 链表问题： - 反转链表 (Reverse Linked List) - 删除链表中的倒数第N个节点 (Remove Nth Node From End of List) - 合并两个有序链表 (Merge Two Sorted Lists) - 链表中环的检测 (Linked List Cycle) - 环形链表的起始点 (Linked List Cycle II) 3. 树和图问题： - 二叉树的遍历 (Binary Tree Traversal) - 二叉树的最大深度 (Maximum Depth of Binary Tree) - 二叉树的最小深度 (Minimum Depth of Binary Tree) - 图的深度优先搜索 (Depth First Search) - 图的广度优先搜索 (Breadth First Search) 4. 动态规划问题： - 爬楼梯 (Climbing Stairs) - 最大子序和 (Maximum Subarray) - 打家劫舍 (House Robber) - 不同路径 (Unique Paths) - 最长递增子序列 (Longest Increasing Subsequence) 5. 排序和搜索问题： - 快速排序 (Quick Sort) - 归并排序 (Merge Sort) - 二分查找 (Binary Search) - 搜索旋转排序数组 (Search in Rotated Sorted Array) - 寻找峰值 (Find Peak Element) 这只是一些常见的 Leetcode 高频考题整理，还有很多其他题目也值得关注。通过刷题和整理高频题目，可以提高对算法和数据结构的理解和应用能力。希望对你有所帮助！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值