leetcode刷题笔记：图论 · 从入门到精通---刷通图论（2）bfs

ko no 辉夜 da

已于 2023-11-02 16:20:15 修改

阅读量70

点赞数

分类专栏： java刷题笔记文章标签： leetcode 笔记图论

于 2023-10-25 19:35:21 首次发布

本文链接：https://blog.csdn.net/weixin_43897646/article/details/133795207

版权

java刷题笔记专栏收录该内容

7 篇文章 0 订阅

订阅专栏

该部分的题单如下：
在这里插入图片描述

第一题： 1926. 迷宫中离入口最近的出口

在这里插入图片描述

傻逼题目，千万别做，莫名奇妙的超时，抄一个同门的代码如下：

class Solution {
    public int nearestExit(char[][] maze, int[] entrance) {
        int m = maze.length, n = maze[0].length;
        int[] dx = {-1, 0, 1, 0}, dy = {0, -1, 0, 1};
        int step = 0;
        Queue<int[]> q = new LinkedList();
        q.offer(new int[]{entrance[0], entrance[1]});
        maze[entrance[0]][entrance[1]] = '-';
        while (!q.isEmpty()) {
            int size = q.size();
            for (int i = 0; i < size; ++i) {
                int[] cur = q.poll();
                int x = cur[0], y = cur[1];
                if (step != 0 && (x == 0 || x == m - 1 || y == 0 || y == n - 1)) return step;
                for (int k = 0; k < 4; ++k) {
                    int nx = x + dx[k], ny = y + dy[k];
                    if (nx >= 0 && ny >= 0 && nx < m && ny < n && maze[nx][ny] == '.') {
                        maze[nx][ny] = '-';
                        q.offer(new int[]{nx, ny});
                    }
                }
            }
            ++step;
        }
        return -1;
    }
}

第二题

在这里插入图片描述

只有两座岛就太简单了，先随便遍历到一个岛，然后所有节点呈轮次向外扩张，在遍历到陆地时说明连接到水了。

代码过于繁琐，

class Solution {
    public int shortestBridge(int[][] grid) {
        int n = grid.length;
        int[][] dirs = {{-1, 0}, {1, 0}, {0, 1}, {0, -1}};

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == 1) {
                    Queue<int[]> queue = new ArrayDeque<int[]>();
                    dfs(i, j, grid, queue);
                    int step = 0;
                    while (!queue.isEmpty()) {
                        int sz = queue.size();
                        for (int k = 0; k < sz; k++) {
                            int[] cell = queue.poll();
                            int x = cell[0], y = cell[1];
                            for (int d = 0; d < 4; d++) {
                                int nx = x + dirs[d][0];
                                int ny = y + dirs[d][1];
                                if (nx >= 0 && ny >= 0 && nx < n && ny < n) {
                                    if (grid[nx][ny] == 0) {
                                        queue.offer(new int[]{nx, ny});
                                        grid[nx][ny] = -1;
                                    } else if (grid[nx][ny] == 1) {
                                        return step;
                                    }
                                }
                            }
                        }
                        step++;
                    }
                }
            }
        }
        return 0;
    }

    public void dfs(int x, int y, int[][] grid, Queue<int[]> queue) {
        if (x < 0 || y < 0 || x >= grid.length || y >= grid[0].length || grid[x][y] != 1) {
            return;
        }
        queue.offer(new int[]{x, y});
        grid[x][y] = -1;
        dfs(x - 1, y, grid, queue);
        dfs(x + 1, y, grid, queue);
        dfs(x, y - 1, grid, queue);
        dfs(x, y + 1, grid, queue);
    }
}

第四题： 127. 单词接龙

在这里插入图片描述
又到了奇奇怪怪的困难题了。

每个单词都是一个节点，可以转换表明这两个节点之间存在路径，开始结束单词以及过度单词之间构成了一张图，从开始节点bfs，访问到结束单词说明得到路径。

思路很简单，但是如何判断两个节点之间存在路径呢？
在这里插入图片描述
朴素思路果然超时了捏。
好强的思路，感觉有种并查集的感觉

官解代码：

class Solution {
    Map<String, Integer> wordId = new HashMap<String, Integer>();
    List<List<Integer>> edge = new ArrayList<List<Integer>>();
    int nodeNum = 0;

    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        for (String word : wordList) {
            addEdge(word);
        }
        addEdge(beginWord);
        if (!wordId.containsKey(endWord)) {
            return 0;
        }
        int[] dis = new int[nodeNum];
        Arrays.fill(dis, Integer.MAX_VALUE);
        int beginId = wordId.get(beginWord), endId = wordId.get(endWord);
        dis[beginId] = 0;

        Queue<Integer> que = new LinkedList<Integer>();
        que.offer(beginId);
        while (!que.isEmpty()) {
            int x = que.poll();
            if (x == endId) {
                return dis[endId] / 2 + 1;
            }
            for (int it : edge.get(x)) {
                if (dis[it] == Integer.MAX_VALUE) {
                    dis[it] = dis[x] + 1;
                    que.offer(it);
                }
            }
        }
        return 0;
    }

    public void addEdge(String word) {
        addWord(word);
        int id1 = wordId.get(word);
        char[] array = word.toCharArray();
        int length = array.length;
        for (int i = 0; i < length; ++i) {
            char tmp = array[i];
            array[i] = '*';
            String newWord = new String(array);
            addWord(newWord);
            int id2 = wordId.get(newWord);
            edge.get(id1).add(id2);
            edge.get(id2).add(id1);
            array[i] = tmp;
        }
    }

    public void addWord(String word) {
        if (!wordId.containsKey(word)) {
            wordId.put(word, nodeNum++);
            edge.add(new ArrayList<Integer>());
        }
    }
}

学习代码写法：节点号自己实现，节点号之间的。

在这里插入图片描述
果然双向奔赴才是最好的。

粗略估计减少了一半的搜索量。

第五题：1306. 跳跃游戏 III

在这里插入图片描述

官阶居然没有java版本的

class Solution {
    public boolean canReach(int[] arr, int start) {
        int n = arr.length;
        Queue<Integer> queue = new LinkedList<>();
        boolean[] visited = new boolean[n];
        Arrays.fill(visited, false);
        queue.add(start);
        while (!queue.isEmpty()) {            
            int now_index = queue.poll();
            visited[now_index] = true;
            if (arr[now_index] == 0) return true;

            int line = arr[now_index];
            if (now_index-line >= 0 && !visited[now_index-line]) {
                queue.add(now_index-line);
            }
            if (now_index+line <  n && !visited[now_index+line]) {
                queue.add(now_index+line);
            }
            
        }
        return false;
    }
}

第六题： 542. 01 矩阵

在这里插入图片描述

很无聊的bfs

第七题： 863. 二叉树中所有距离为 K 的结点

在这里插入图片描述

一个简单的想法就是把target数组当作根节点，随后搜索所有的深度为K的字节点，观察原树与把target数组的区别，关键在于需要把从原来root的到target 的路径全部逆折，那么可以想到，从target节点开始，dfs k 次。分为向下dfs，向上dfs。得到丑陋的代码如下。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    List<Integer> res = new ArrayList<>();
    public List<Integer> distanceK(TreeNode root, TreeNode target, int k) {
        dfs(root, target.val, k);
        return res;
    }
    // 返回的是剩余距离
    int dfs (TreeNode root, int target_value, int k) {
        if (root == null) return -1;
        if (root.val == target_value) {
            dfs_depth (root, k);
            return k-1;
        } 
        int ll = dfs(root.left, target_value, k);
        if (ll != -1) {
            // 就是左边
            if (ll == 0) {
                res.add(root.val);
                return -1;
            }
            else {
                dfs_depth (root.right, ll-1);
                return ll-1;
            }
            
        }
        int rr = dfs(root.right, target_value, k);
        if (rr != -1) {
            if (rr == 0) {
                res.add(root.val);
                return -1;
            }
            else {
               dfs_depth (root.left, rr-1);
                return rr-1; 
            }
            
        }
        return -1;
    }
    void dfs_depth (TreeNode root, int depth) {
        if (root == null) {
            return;
        } else {
            if (depth == 0) {
                res.add(root.val);
                return;
            }
            dfs_depth (root.left , depth-1);
            dfs_depth (root.right, depth-1);
        }
    }
}

简单题学方法：邻接表
https://www.cnblogs.com/codingmengmeng/p/5645073.html
三叶的题解


class Solution {
    // 根据数据范围最多有 501 个点，每个点最多有 2 条无向边（两个子节点）
    int N = 510, M = N * 4;
    int[] he = new int[N], e = new int[M], ne = new int[M];
    int idx;
    void add(int a, int b) {
        e[idx] = b;
        ne[idx] = he[a];
        he[a] = idx++;
    }
    boolean[] vis = new boolean[N];
    public List<Integer> distanceK(TreeNode root, TreeNode t, int k) {
        List<Integer> ans = new ArrayList<>();
        Arrays.fill(he, -1);
        dfs(root);
        Deque<Integer> d = new ArrayDeque<>();
        d.addLast(t.val);
        vis[t.val] = true;
        while (!d.isEmpty() && k >= 0) {
            int size = d.size();
            while (size-- > 0) {
                int poll = d.pollFirst();
                if (k == 0) {
                    ans.add(poll);
                    continue;
                }
                for (int i = he[poll]; i != -1 ; i = ne[i]) {
                    int j = e[i];
                    if (!vis[j]) {
                        d.addLast(j);
                        vis[j] = true;
                    }
                }
            }
            k--;
        }
        return ans;
    }
    void dfs(TreeNode root) {
        if (root == null) return;
        if (root.left != null) {
            add(root.val, root.left.val);
            add(root.left.val, root.val);
            dfs(root.left);
        }
        if (root.right != null) {
            add(root.val, root.right.val);
            add(root.right.val, root.val);
            dfs(root.right);
        }
    }
}

邻接表存图非常的巧妙。
he 和ne存了所有顶点。
例如顶点为 1的第一条边对应边的序号是，
he[1]
下一条边是
ne[he[1]]
he 和 ne 内的有效元素和等于 ne 中的有效元素和。

ko no 辉夜 da

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
1
评论
leetcode刷题笔记：图论 · 从入门到精通---刷通图论（2）bfs

一个简单的想法就是把target数组当作根节点，随后搜索所有的深度为K的字节点，观察原树与把target数组的区别，关键在于需要把从原来root的到target 的路径全部逆折，那么可以想到，从target节点开始，dfs k 次。每个单词都是一个节点，可以转换表明这两个节点之间存在路径，开始结束单词以及过度单词之间构成了一张图，从开始节点bfs，访问到结束单词说明得到路径。只有两座岛就太简单了，先随便遍历到一个岛，然后所有节点呈轮次向外扩张，在遍历到陆地时说明连接到水了。
复制链接

扫一扫