LeetCode 解题思路 27（课程表、实现 Trie (前缀树)）

解题思路：

1. 构建图结构： 使用邻接表存储每个课程的后续课程，并统计每个课程的入度（即需要先修的课程数量）。
2. 初始化队列： 将所有入度为0的课程（没有先修要求的课程）加入队列。
3. 拓扑排序： 依次处理队列中的课程，将其后续课程入度减1。若某个后续课程入度变为 0，则加入队列。
4. ​判断结果： 若最终处理的课程数量等于总课程数，则无环，可以完成所有课程；否则存在环，无法完成。

Java代码：

vclass Solution {
    public boolean canFinish(int numCourses, int[][] prerequisites) {
        List<List<Integer>> adj = new ArrayList<>();
        int[] indegree = new int[numCourses];
        for (int i = 0; i < numCourses; i++) {
            adj.add(new ArrayList<>());
        }
        for (int[] pair : prerequisites) {
            int course = pair[0], prereq = pair[1];
            adj.get(prereq).add(course);
            indegree[course]++;
        }

        Queue<Integer> queue = new LinkedList<>();
        for (int i = 0; i < numCourses; i++) {
            if (indegree[i] == 0) {
                queue.offer(i);
            }
        }

        int count = 0;
        while (!queue.isEmpty()) {
            int curr = queue.poll();
            count++;
            for (int neighbor : adj.get(curr)) {
                indegree[neighbor]--;
                if (indegree[neighbor] == 0) {
                    queue.offer(neighbor);
                }
            }
        }

        return count == numCourses;
    }
}

复杂度分析：

• 时间复杂度： O(e + v)，e 是prerequisites的长度​（边数），v 是课程数​（节点数）。构建邻接表和入度数组需遍历所有边，时间复杂度为O(e)。BFS遍历每个节点和每条边一次，时间复杂度为O(e + v)。
• 空间复杂度： O(e + v)，邻接表存储所有边，空间复杂度为O(e)。入度数组和队列的空间复杂度为O(e)。
  

解题思路：

1. 插入： 从根节点出发，逐字符遍历。若字符路径不存在则创建新节点，最后标记单词结束。
2. 搜索： 检查路径是否存在且最后一个节点标记为单词结尾。
3. 前缀查询： 仅需检查路径是否存在，不关心是否为单词结尾。

Java代码：

class Trie {
    private class TrieNode {
        TrieNode[] children;
        boolean isEnd;
        public TrieNode() {
            children = new TrieNode[26];
            isEnd = false;
        }
    }

    private final TrieNode root;

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

    public void insert(String word) {
        TrieNode node = root;
        for (char c : word.toCharArray()) {
            int index = c - 'a';
            if (node.children[index] == null) {
                node.children[index] = new TrieNode();
            }
            node = node.children[index];
        }
        node.isEnd = true;
    }

    public boolean search(String word) {
        TrieNode node = root;
        for (char c : word.toCharArray()) {
            int index = c - 'a';
            if (node.children[index] == null) {
                return false;
            }
            node = node.children[index];
        }
        return node.isEnd;
    }

    public boolean startsWith(String prefix) {
        TrieNode node = root;
        for (char c : prefix.toCharArray()) {
            int index = c - 'a';
            if (node.children[index] == null) {
                return false;
            }
            node = node.children[index];
        }
        return true;
    }
}

复杂度分析：

• 时间复杂度： 插入、搜索、前缀查询：O(l)，其中 l 是操作字符串的长度。每个字符需处理一次。
• 空间复杂度： 最坏 O(m * n)，m 是插入的单词数，n 是平均长度。每个节点最多有 26 个子节点。