图论 on Coder_Studio

BISHI101 世界树上找米库

Mon, 09 Mar 2026 22:05:01 +0000

思路

求解代码

public static void main(String[] args) throws IOException {
        // 使用BufferedReader读取输入，使用PrintWriter输出结果
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取测试用例数量T
        int T = Integer.parseInt(br.readLine().trim());

        // 处理每个测试用例
        while (T-- > 0) {
            // 读取树的节点数n
            int n = Integer.parseInt(br.readLine().trim());
            // 创建邻接表表示树
            List<Integer>[] adj = new ArrayList[n + 1];
            // 初始化邻接表
            for (int i = 1; i <= n; i++) {
                adj[i] = new ArrayList<>();
            }
            // 创建度数数组
            int[] deg = new int[n + 1];

            // 读取n-1条边，构建邻接表和度数数组
            for (int i = 0; i < n - 1; i++) {
                String[] edge = br.readLine().trim().split("\\s+");
                int u = Integer.parseInt(edge[0]);
                int v = Integer.parseInt(edge[1]);
                // 无向图，双向添加边
                adj[u].add(v);
                adj[v].add(u);

                // 更新节点的度数
                deg[u]++;
                deg[v]++;
            }
            // 创建距离数组，初始化为-1
            int[] dist = new int[n + 1];
            Arrays.fill(dist, -1);
            // 创建队列用于BFS
            Queue<Integer> queue = new LinkedList<>();

            // 将所有度为1的节点（叶子节点）加入队列，距离设为0
            for (int i = 1; i <= n; i++) {
                if (deg[i] == 1) {
                    dist[i] = 0;
                    queue.add(i);
                }
            }

            // BFS遍历树，计算每个节点到最近叶子节点的距离
            while (!queue.isEmpty()) {
                int u = queue.poll();
                // 遍历当前节点的所有邻接节点
                for (int v : adj[u]) {
                    if (dist[v] == -1) {
                        // 更新距离并加入队列
                        dist[v] = dist[u] + 1;
                        queue.add(v);
                    }
                }
            }

            // 找到最大距离
            int maxDist = -1;
            for (int i = 1; i <= n; i++) {
                // 只考虑非叶子节点
                if (deg[i] > 1) {
                    maxDist = Math.max(maxDist, dist[i]);
                }
            }

            // 收集所有距离为最大距离的非叶子节点（中心点）
            List<Integer> mikuPoints = new ArrayList<>();
            for (int i = 1; i <= n; i++) {
                if (deg[i] > 1 && dist[i] == maxDist) {
                    mikuPoints.add(i);
                }
            }

            // 输出中心点的数量
            out.println(mikuPoints.size());

            // 输出所有中心点
            for (int i = 0; i < mikuPoints.size(); i++) {
                out.print(mikuPoints.get(i) + (i == mikuPoints.size() - 1 ? "" : " "));
            }
            out.println();
        }

        // 刷新输出缓冲区，确保所有输出都被写入
        out.flush();
        // 关闭输出流
        out.close();
        // 关闭输入流
        br.close();
    }

BISHI99 我朋友的朋友不是我的朋友

Sun, 08 Mar 2026 21:13:49 +0000

思路

求解代码

public static void main(String[] args) throws IOException {
        // 使用 BufferedReader 和 PrintWriter 提升大规模数据下的 I/O 效率
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 1. 读取成员数 n 和 好友关系数 m
        String[] strA = br.readLine().trim().split("\\s+");
        int n = Integer.parseInt(strA[0]);
        int m = Integer.parseInt(strA[1]);

        // nameToID: 将字符串姓名映射为整数 ID，方便作为数组下标处理
        HashMap<String, Integer> nameToID = new HashMap<>();
        // idToName: 将整数 ID 映射回姓名，用于最后的结果输出
        String[] idToName = new String[n];
        // adj: 邻接表，存储每个人的好友列表
        List<Integer>[] adj = new ArrayList[n];
        // deg: 存储每个人的“社牛指数”（即节点的度数）
        int[] deg = new int[n];
        int idCount = 0; // 记录当前已分配的 ID 数量

        // 2. 构建图结构
        for (int i = 0; i < m; i++) {
            String[] pair = br.readLine().trim().split("\\s+");

            // 处理每一对好友关系中的两个姓名
            for (String name : pair) {
                // 如果是第一次见到的姓名，分配一个新的 ID 并初始化其邻接表
                if (!nameToID.containsKey(name)) {
                    idToName[idCount] = name;
                    adj[idCount] = new ArrayList<>();
                    nameToID.put(name, idCount++);
                }
            }

            // 获取两个好友对应的 ID
            int u = nameToID.get(pair[0]);
            int v = nameToID.get(pair[1]);

            // 无向图：双方互相添加进对方的好友列表
            adj[u].add(v);
            adj[v].add(u);

            // 双方的度数各加 1
            deg[u]++;
            deg[v]++;
        }

        // 3. 判定“社牛”成员
        List<String> res = new ArrayList<>();
        for (int i = 0; i < idCount; i++) {
            // 孤立点（没有好友的人）不符合社牛定义
            if (deg[i] == 0) {
                continue;
            }

            // sum: 累计该成员所有好友的度数总和
            long sum = 0;
            for (int neighbor : adj[i]) {
                sum += deg[neighbor];
            }

            /**
             * 判定公式推导：
             * 原条件：deg(x) > (sum_of_friends_deg / deg(x))
             * 变形得：deg(x) * deg(x) > sum_of_friends_deg
             *
             * 优点：避免浮点数除法导致的精度丢失。
             * 注意：deg 最大为 10^5，平方后达 10^10，超过了 int 范围，必须强转为 long 计算。
             */
            if ((long) deg[i] * deg[i] > sum) {
                res.add(idToName[i]);
            }
        }

        // 4. 输出处理
        if (res.isEmpty()) {
            // 若不存在任何社牛，输出 None
            out.println("None");
        } else {
            // 题目要求按字典序升序输出
            Collections.sort(res);
            for (int i = 0; i < res.size(); i++) {
                // 格式化输出：姓名之间用单个空格分隔
                out.print(res.get(i) + (i == res.size() - 1 ? "" : " "));
            }
            out.println();
        }

        // 5. 刷新缓冲区并关闭资源
        out.flush();
        out.close();
        br.close();
    }

BISHI98 谍中谍中谍中谍中谍.

Sun, 08 Mar 2026 20:21:01 +0000

思路

求解代码

public static void main(String[] args) throws IOException {
        // 使用 BufferedReader 和 PrintWriter 提升大规模数据下的 I/O 效率
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 1. 读取学生总人数 n
        int n = Integer.parseInt(br.readLine().trim());

        // 2. 读取指认关系字符串并按空格拆分
        String[] strA = br.readLine().trim().split("\\s+");

        // p[i] 存储学生 i 指认的学生编号
        // 使用 n+1 大小以便让下标 1~n 对应学生编号 1~n，符合直觉
        int[] p = new int[n + 1];
        for (int i = 1; i <= n; i++) {
            p[i] = Integer.parseInt(strA[i - 1]);
        }

        // 3. 题目要求：假设老师最初抓到的是第 i 个学生
        // 我们需要对 1 到 n 每一个起点都模拟一遍追踪过程
        for (int i = 1; i <= n; i++) {
            // 获取从起点 i 开始追踪，最后被老师劝退的学生编号
            int res = findStu(i, p, n);

            // 格式化输出：除了最后一个数，后面都加空格
            out.print(res + (i == n ? "" : " "));
        }

        // 4. 刷新缓冲区确保数据完整写出，并按规范关闭流资源
        out.flush();
        out.close();
        br.close();
    }

    /**
     * 追踪退学警告的过程
     *
     * @param start 老师最初抓到的学生编号
     * @param p     指认关系数组（图的邻接关系）
     * @param n     学生总数
     * @return      第一个收到两次警告（即导致退学）的学生编号
     */
    private static int findStu(int start, int[] p, int n) {
        // visited[i] 记录学生 i 是否已经收到过一次警告
        // 每一轮新起点都需要一个全新的标记数组
        boolean[] visited = new boolean[n + 1];

        int cur = start; // 从老师抓到的第一位学生开始

        // 由于学生数量有限且出度为 1，追踪过程必然会进入一个环并死循环
        // 我们通过 while(true) 配合内部 return 退出
        while (true) {
            // 如果当前学生 cur 的 visited 标记已经是 true，
            // 说明这是他第二次被抓到了，触发“劝说退学”逻辑，直接返回他
            if (visited[cur]) {
                return cur;
            }

            // 第一次抓到该学生，打上标记（发出第一次退学警告）
            visited[cur] = true;

            // 根据供述，抓取下一个被指认的人
            cur = p[cur];
        }
    }

BISHI97旺仔哥哥走迷宫

Sat, 07 Mar 2026 20:12:40 +0000

思路

求解代码


    public static void main(String[] args) throws IOException {
        // 使用 BufferedReader 和 PrintWriter 提升大规模数据下的 I/O 效率
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取第一行输入，获取节点数n和边数m
        String[] strA = br.readLine().trim().split("\\s+");
        int n = Integer.parseInt(strA[0]);  // 节点数量
        int m = Integer.parseInt(strA[1]);  // 边的数量
        int[] t = new int[n + 1];  // 存储每个节点的类型，索引从1开始
        // 读取第二行输入，获取每个节点的类型
        String[] strB = br.readLine().trim().split("\\s+");

        // 将节点类型数据存入数组t，索引从1开始
        for (int i = 1; i <= n; i++) {
            t[i] = Integer.parseInt(strB[i - 1]);
        }

        // 创建邻接表表示的图结构
        List<Integer>[] adj = new ArrayList[n + 1];
        for (int i = 1; i <= n; i++) {
            adj[i] = new ArrayList<>();
        }

        // 读取所有边的信息，构建无向图
        for (int i = 0; i < m; i++) {
            String[] edge = br.readLine().trim().split("\\s+");
            int u = Integer.parseInt(edge[0]);  // 边的一个端点
            int v = Integer.parseInt(edge[1]);  // 边的另一个端点
            adj[u].add(v);  // 添加边到邻接表
            adj[v].add(u);  // 无向图，双向添加
        }

        // 检查起点或终点是否为类型1，如果是则直接输出"No"
        if (t[1] == 1 || t[n] == 1) {
            out.println("No");
        } else {
            // 调用BFS算法判断路径是否可行
            if (bfs(n, adj, t)) {
                out.println("Yes");
            } else {
                out.println("No");
            }
        }

        // 刷新缓冲区确保数据完整写出并关闭流
        out.flush();
        out.close();
        br.close();
    }

    /**
     * 使用广度优先搜索(BFS)算法判断从节点1到节点n是否存在有效路径
     *
     * @param n   节点总数
     * @param adj 邻接表，表示图的连接关系
     * @param t   数组，标记节点的状态(0表示可通过，非0表示不可通过)
     * @return 如果存在从节点1到节点n的有效路径则返回true，否则返回false
     */
    private static boolean bfs(int n, List<Integer>[] adj, int[] t) {
        // 创建队列用于BFS遍历
        Queue<Integer> queue = new LinkedList<>();
        // 创建访问标记数组，记录节点是否被访问过
        boolean[] visited = new boolean[n + 1];

        // 从节点1开始搜索
        queue.add(1);
        visited[1] = true;

        // 当队列不为空时，继续搜索
        while (!queue.isEmpty()) {
            // 取出队首节点
            int cur = queue.poll();
            // 如果到达目标节点n，返回true
            if (cur == n) {
                return true;
            }

            // 遍历当前节点的所有邻接节点
            for (int neighbor : adj[cur]) {
                // 如果邻接节点可通过且未被访问过
                if (t[neighbor] == 0 && !visited[neighbor]) {
                    // 标记为已访问并入队
                    visited[neighbor] = true;
                    queue.add(neighbor);
                }
            }
        }
        // 队列已空未到达目标节点，返回false
        return false;
    }

BISHI95 【模板】链式前向星

Fri, 06 Mar 2026 21:04:50 +0000

思路

求解代码

public static void main(String[] args) throws IOException {
        // 使用BufferedReader读取输入，PrintWriter输出结果
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取第一行输入，分割字符串并转换为整数n和m
        String[] strA = br.readLine().trim().split("\\s+");
        int n = Integer.parseInt(strA[0]);  // 节点数
        int m = Integer.parseInt(strA[1]);  // 边数

        // 创建邻接表，大小为n+1（节点从1开始编号）
        List<Integer>[] adj = new ArrayList[n + 1];
        // 初始化每个节点的邻接表
        for (int i = 1; i <= n; i++) {
            adj[i] = new ArrayList<>();
        }

        // 读取m条边，构建无向图的邻接表
        for (int i = 0; i < m; i++) {

            // 读取边的两个端点
            String[] edge = br.readLine().trim().split("\\s+");
            int u = Integer.parseInt(edge[0]);  // 边的一个端点
            int v = Integer.parseInt(edge[1]);  // 边的另一个端点
            // 无向图，两个方向都添加
            adj[u].add(v);
            adj[v].add(u);
        }

        // 遍历每个节点，输出其邻接节点
        for (int i = 1; i <= n; i++) {
            // 如果节点没有邻接节点，输出"None"
            if (adj[i].isEmpty()) {
                out.println("None");
            } else {
                // 对邻接节点进行排序
                Collections.sort(adj[i]);

                // 输出排序后的邻接节点
                for (int j = 0; j < adj[i].size(); j++) {
                    // 如果是最后一个节点，直接输出，否则输出空格
                    out.print(adj[i].get(j) + (j == adj[i].size() - 1 ? "" : " "));
                }
                out.println();
            }
        }


        // 刷新缓冲区并释放资源
        out.flush();
        out.close();
        br.close();
    }