图论力扣hot100热门面试算法题面试基础核心思路背题岛屿数量腐烂的橘子课程表实现 Trie (前缀树)-CSDN博客

本文链接：https://blog.csdn.net/2402_82958989/article/details/146404701

图论

岛屿数量

https://leetcode.cn/problems/number-of-islands/

核心思路

遇到一次"1",就把这个岛上的"1"全改为"0"

示例代码

class Solution {
    public int numIslands(char[][] grid) {
        int cnt = 0;
        for(int i = 0;i < grid.length;i++){
            for(int j = 0;j<grid[0].length;j++){
                if(grid[i][j] == '1'){
                    dfs(grid,i,j);
                    cnt++;
                }
            }
        }
        return cnt;
    }
    void dfs(char grid[][], int i, int j){
        if(i < 0 || j < 0 || i >= grid.length || j >= grid[0].length || grid[i][j] == '0') return;
        grid[i][j] = '0';
        dfs(grid, i + 1, j);
        dfs(grid, i, j + 1);
        dfs(grid, i - 1, j);
        dfs(grid, i, j - 1);
    }
}

腐烂的橘子

https://leetcode.cn/problems/rotting-oranges/

每分钟，腐烂的橘子周围 4 个方向上相邻的新鲜橘子都会腐烂。

核心思路

使用了广度优先搜索（BFS）的思想。它首先统计了网格中的新鲜橘子数量，并将所有初始腐烂橘子的位置加入队列。然后，算法通过模拟每分钟腐烂橘子的扩散过程，不断从队列中取出腐烂橘子，检查其相邻位置是否有新鲜橘子。如果有，就将这些新鲜橘子标记为腐烂，并将它们的位置加入队列。这个过程一直持续到没有新鲜橘子剩余或者队列为空（即没有更多的橘子可以腐烂）。最后，如果还有新鲜橘子剩余，说明不是所有橘子都能腐烂，返回 -1；否则，返回使所有橘子腐烂所需的时间（分钟）。

示例代码

class Solution {
    // 定义四个方向：上、下、左、右
    private static final int[][] DIRECTIONS = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}}; 

    public int orangesRotting(int[][] grid) {
        int n = grid.length; // 网格的行数
        int m = grid[0].length; // 网格的列数
        int fresh = 0; // 用于统计新鲜橘子的数量
        List<int[]> q = new ArrayList<>(); // 使用队列存储初始的腐烂橘子的位置

        // 遍历整个网格，统计新鲜橘子数量，并将腐烂橘子的位置加入队列
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (grid[i][j] == 1) {
                    fresh++; // 如果当前位置是新鲜橘子，则增加新鲜橘子计数
                } else if (grid[i][j] == 2) {
                    q.add(new int[]{i, j}); // 如果当前位置是腐烂橘子，则加入队列
                }
            }
        }

        int ans = 0; // 记录经过的时间（分钟）
        // 当还有新鲜橘子且队列不为空时，继续循环
        while (fresh > 0 && !q.isEmpty()) {
            ans++; // 每遍历一轮，表示经过了一分钟
            List<int[]> tmp = q; // 使用临时变量保存当前队列状态，以便在遍历时不修改队列本身
            q = new ArrayList<>(); // 重新初始化队列，用于存储下一分钟腐烂的橘子位置

            // 遍历当前队列中的所有腐烂橘子位置
            for (int[] pos : tmp) { 
                for (int[] d : DIRECTIONS) { // 遍历四个方向
                    int i = pos[0] + d[0]; // 计算新位置的行索引
                    int j = pos[1] + d[1]; // 计算新位置的列索引
                    // 检查新位置是否在网格内，且该位置是新鲜橘子
                    if (0 <= i && i < n && 0 <= j && j < m && grid[i][j] == 1) { 
                        fresh--; // 减少新鲜橘子计数
                        grid[i][j] = 2; // 将新鲜橘子标记为腐烂
                        q.add(new int[]{i, j}); // 将新腐烂的橘子位置加入队列
                    }
                }
            }
        }

        // 如果还有剩余的新鲜橘子，则返回-1；否则返回经过的时间（分钟）
        return fresh > 0 ? -1 : ans;
    }
}

课程表

https://leetcode.cn/problems/course-schedule/

核心思路

图的表示：
a. 使用邻接表（adjacency）表示课程之间的依赖关系。
b. prerequisites 中的每个关系 [a, b] 表示课程 a 依赖于课程 b，在图中表现为一条从 b 到 a 的有向边。
DFS 检测环：
a. 用 flags 数组记录每个课程的访问状态：
0：未访问。
1：正在访问（表示当前节点在递归栈中）。
-1：已访问（表示当前节点的所有后续节点都已检查完毕，无需再次访问）。
b. 如果在 DFS 的过程中遇到一个节点正在访问（flags[i] == 1），说明存在环。
c. 如果遍历完所有后续节点后没有发现环，将当前节点标记为已访问（flags[i] == -1）。

示例代码

class Solution {
    public boolean canFinish(int numCourses, int[][] prerequisites) {
    // 创建一个邻接表来表示课程之间的依赖关系
    List<List<Integer>> adjacency = new ArrayList<>();
    // 初始化邻接表，每个课程对应一个列表
    for(int i = 0; i < numCourses; i++)
        adjacency.add(new ArrayList<>());
    // 用来标记每个课程的访问状态，0：未访问，1：正在访问（当前栈中），-1：已访问
    int[] flags = new int[numCourses];

    // 根据前置依赖关系构建有向图的邻接表
    for(int[] cp : prerequisites)
        adjacency.get(cp[1]).add(cp[0]); // cp[1] -> cp[0] 表示修 cp[0] 前必须先修 cp[1]

    // 遍历所有课程，检查每个课程是否成环
    for(int i = 0; i < numCourses; i++)
        // 如果从当前课程出发检测到环，则课程安排无法完成
        if(!dfs(adjacency, flags, i)) return false;
    // 如果没有环，则可以完成所有课程
    return true;
}
    private boolean dfs(List<List<Integer>> adjacency, int[] flags, int i) {
    // 如果当前课程状态为 1，表示正在访问（在递归栈中），说明存在环
    if(flags[i] == 1) return false;
    // 如果当前课程状态为 -1，表示已经访问过，无需重复检查，直接返回 true
    if(flags[i] == -1) return true;
    // 标记当前课程为正在访问
    flags[i] = 1;
    // 遍历当前课程的所有后续课程（邻接点）
    for(Integer j : adjacency.get(i))
        // 如果后续课程检测到环，则当前课程也无法完成，返回 false
        if(!dfs(adjacency, flags, j)) return false;
    // 标记当前课程为已访问
    flags[i] = -1;
    // 如果没有环，返回 true
    return true;
}
}

实现 Trie (前缀树)

核心思路

前缀树的常规实现

示例代码

class Node {
    Node[] son = new Node[26];
    boolean end;
}

class Trie {
    private Node root;

    public Trie() {
        root = new Node();
    }

    public void insert(String word) {
        Node cur = root;
        for (char c : word.toCharArray()) {
            c -= 'a';
            if (cur.son[c] == null) {
                cur.son[c] = new Node();
            }
            cur = cur.son[c];
        }
        cur.end = true;
    }

    public boolean search(String word) {
        return find(word) == 2;
    }

    public boolean startsWith(String prefix) {
        return find(prefix) != 0;
    }

    private int find(String word) {
        Node cur = root;
        for (char c : word.toCharArray()) {
            c -= 'a';
            if (cur.son[c] == null) {
                return 0;
            }
            cur = cur.son[c];
        }
        return cur.end ? 2 : 1;
    }
}