day54 代码随想录算法训练营图论专题8

1 今日打卡

拓扑排序 117. 软件构建

dijkstra朴素版 47. 参加科学大会（第六期模拟笔试）

2 拓扑排序

2.1 思路

构建图 + 统计入度：

用邻接表（umap）存储每个节点的后继节点（比如 S 的后继是 T）。

用数组（inDegree）统计每个节点的入度（指向该节点的边数，即该节点依赖的文件数）。

初始化队列：将所有入度为 0 的节点（无依赖的文件）加入队列。

处理队列：

取出队列中的节点（处理该文件），加入结果列表。

遍历该节点的所有后继节点（被该文件依赖的文件），将它们的入度减 1（因为依赖的文件已处理）。

如果某个后继节点入度变为 0（所有依赖都已处理），加入队列。

结果判断：

如果结果列表的长度等于节点数（N）：无环，输出顺序。

否则：存在环（相互依赖），输出 - 1。

2.2 实现代码

java 复制代码

import java.util.*;
public class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt(), m = sc.nextInt(); // n=文件数，m=依赖关系数
        // 1. 初始化邻接表（存储图）：每个节点对应一个列表，存后继节点
        List<List<Integer>> umap = new ArrayList<>();
        for(int i = 0; i < n; i++) {
            umap.add(new ArrayList<>());
        }
        // 2. 初始化入度数组：统计每个节点的入度（依赖数）
        int[] inDegree = new int[n];
        for(int i = 0; i < m; i++) {
            int start = sc.nextInt(), end = sc.nextInt(); // S→T：T依赖S
            umap.get(start).add(end); // 邻接表添加边：start的后继是end
            inDegree[end]++; // end的入度+1（多了一个依赖）
        }
        // 3. 初始化队列：入度为0的节点（无依赖的文件）入队
        Queue<Integer> que = new LinkedList<>();
        List<Integer> res = new ArrayList<>(); // 存储拓扑排序结果
        for(int i = 0; i < n; i++) {
            if(inDegree[i] == 0) {
                que.add(i);
            }
        }
        // 4. 处理队列，逐步消除入度为0的节点
        while(!que.isEmpty()) {
            int cur = que.poll(); // 取出当前处理的节点
            res.add(cur); // 加入结果列表
            // 遍历当前节点的所有后继节点
            List<Integer> temp = umap.get(cur);
            for(int node : temp) {
                inDegree[node]--; // 后继节点的入度减1（依赖减少一个）
                if(inDegree[node] == 0) { // 所有依赖都处理完了
                    que.add(node); // 入队等待处理
                }
            }
        }
        // 5. 判断结果：是否所有节点都处理了（无环）
        if(res.size() == n) {
            // 输出顺序（空格分隔）
            for(int i = 0; i < n - 1; i++) {
                System.out.print(res.get(i) + " ");
            }
            System.out.println(res.get(n - 1));
        }else{
            System.out.println(-1); // 有环，输出-1
        }
    }
}

3 dijkstra朴素版

3.1 思路

初始化：

记录起点到所有节点的初始最短距离（起点到自己为 0，到其他节点为 "无穷大"）。

记录节点是否已确定最短路径（避免重复处理）。

贪心选择：每次从未确定最短路径的节点中，选当前距离起点最近的节点（局部最优）。

松弛操作：通过这个选中的节点，更新其邻接节点的最短距离（尝试缩短路径）。

重复：直到所有节点的最短路径都被确定，或找到终点的最短路径。

3.2 实现代码