算法 on Coder_Studio

哈希、对称_非对称加密、数字签名，一次性讲清

Thu, 02 Apr 2026 18:43:59 +0000

Java线程与操作系统线程的生命周期

Wed, 01 Apr 2026 14:12:15 +0000

一篇搞懂前后端所有的“器”

Wed, 25 Mar 2026 20:58:53 +0000

用一个电商场景中常见的用户下单流程，把前后端的所有“器”串起来：

前后端对比

层级	前端“器”	作用	后端“器”	作用
第一道关卡	路由守卫	页面访问权限控制	过滤器	跨域、编码、协议级过滤
第二道关卡	请求/响应拦截器	统一加Token、统一报错	拦截器	登录校验、权限验证
业务层	-	-	Controller	执行核心业务逻辑
业务增强层	-	-	AOP切面	日志、监控、事务增强，不侵入主业务代码
执行层	-	-	执行器	异步任务、线程池调度

其实啊，所有的“器”，本质上都是“关注点分离”的体现，即主业务代码只关心“下单”本身，而登录、跨域、日志、异步这些“脏活累活”，交给各种“器”去做。

【面试真题拆解】5秒内限10次HTTP接口访问，结合数据结构和算法说说你的思路

Fri, 20 Mar 2026 15:00:00 +0000

面试官问：

做Web项目的时候，会暴露出一些HTTP接口，我现在想对它进行限流，限制5秒内只能访问10次，结合数据结构和算法，看如何实现，说说你的思路

当时只说了个滑动窗口就没说其他的，然后就没有然后了。。。

首先，为什么要限流？

主要有以下三个原因：

防止恶意刷接口，比如爬虫爬数据、黑客DDoS攻击。
保护服务器不被压垮，比如一个接口挂了，拖垮整个服务。
保证核心业务的可用性，比如大促场景下，支付接口优先，对普通接口进行限流。

技术选型

方案	数据结构+算法	核心思想	优缺点	适用场景
固定窗口计数器	数组/Map + 时间戳	把时间分成固定的窗口，每个窗口内计数	简单易实现；有临界问题（比如4.9秒刷10次，5.1秒又刷10次，实际0.2秒内刷了20次）	对精度要求不高的场景
滑动窗口计数器	本地：LinkedList（双向链表）分布式：Redis ZSet（有序集合） + 时间戳	窗口是“滑动”的，只保留当前窗口内的请求	解决了固定窗口的临界问题；本地版 LinkedList 删头加尾 O (1)，分布式版 ZSet 按时间范围操作高效；本地版不适合分布式集群	固定时间窗口内精确计数的场景
漏桶算法	队列 + 定时器	像漏桶一样，请求先存到队列里，然后匀速处理	可以削峰填谷；突发流量处理不了（秒杀时很多请求直接被拒）	对流量稳定性要求高的场景（比如消息队列）
令牌桶算法	队列 + 定时器	像令牌桶一样，匀速生成令牌，请求拿到令牌才能通过	可以削峰填谷，也可以处理突发流量	对流量稳定性和突发流量都有要求的场景（比如API网关）

滑动窗口计数器

滑动窗口的核心，是窗口不再是静止分段的，而是随当前时间连续移动、互相重叠的：

比如固定窗口，窗口是死的，0-5秒、5-10秒，边界固定不变。

而滑动窗口，窗口的右边界永远是当前请求的时间，左边界永远是当前时间 - 窗口大小，窗口会跟着每一次请求一直往前滑。

数据结构选型

本地：LinkedList（双向链表）

选择双向链表是因为我们需要频繁删除链表头部的过期时间戳，并且还需要频繁在链表尾部新增新的请求时间戳，而双向链表的删头、加尾操作时间复杂度都是O(1)，效率极高。

分布式：Redis ZSet（有序集合）

Web项目基本都是集群部署，本地计数器无法多实例同步，考虑用Redis实现。

选择Redis中的ZSet数据结构，ZSet的score字段可以存请求的时间戳，天然支持按时间范围排序。

实现逻辑

每次请求进来，执行 3 步：

删掉所有早于当前时间 - 窗口大小的请求
统计当前窗口内的请求数，超过 10 次直接拒绝
把当前请求的时间戳加入数据结构，放行请求

小贴士

令牌桶的令牌生成速度要合理

不能太快（等于没限流），也不能太慢（很多请求被拒），要根据业务场景调整。

Redis ZSet的过期时间要设置对

要设置成窗口大小+一点缓冲（比如1秒），防止数据提前过期，导致计数不准确。

【手撕真题】合并区间

Mon, 16 Mar 2026 17:02:46 +0000

题目意思很好理解：

给定一个区间集合，每个区间由 [start, end] 组成，要求合并所有重叠的区间，返回一个不重叠的区间数组，且这个数组要恰好覆盖输入中的所有区间。

思路

首先，先按每个区间的起始值从小到大排序，这样重叠的区间就会挨在一起，方便后续合并；

然后初始化一个结果列表，把排序后的第一个区间放进去，作为初始的待合并区间；

接着遍历剩下的所有区间，每次取出结果列表的最后一个区间和当前区间比较：

如果当前区间的起始值小于等于最后一个区间的结束值，说明两个区间重叠，就把最后一个区间的结束值更新为两者的最大值，完成合并；

如果不重叠，就直接把当前区间加入结果列表；

最后把结果列表转换成二维数组返回即可。

代码实现

    public int[][] merge(int[][] intervals) {
        // 区间个数为0或1，直接返回
        if (intervals.length <= 1) {
            return intervals;
        }

        // 1. 按区间的start值从小到大排序
        // a[0]-b[0]表示按start升序
        Arrays.sort(intervals, (a, b) -> a[0] - b[0]);

        // 2. 初始化结果列表，存储合并后的区间
        List<int[]> res = new ArrayList<>();
        // 先将排序后的第一个区间加入结果列表，作为初始合并区间
        res.add(intervals[0]);

        // 3. 遍历剩下的所有区间，逐个合并
        for (int i = 1; i < intervals.length; i++) {
            // 取出结果列表中最后一个区间
            int[] last = res.get(res.size() - 1);
            // 取出当前遍历的区间
            int[] curr = intervals[i];

            // 判断是否重叠：当前区间的start <= 最后一个区间的end
            if (curr[0] <= last[1]) {
                // 重叠：合并区间，更新最后一个区间的end为两者最大值
                last[1] = Math.max(last[1], curr[1]);
            } else {
                // 不重叠：直接将当前区间加入结果列表
                res.add(curr);
            }
        }

        // 4. 将List<int[]>转换为int[][]
        return res.toArray(new int[res.size()][]);
    }

手撕真题-计算二叉树中两个节点之间的距离

Wed, 11 Mar 2026 22:26:31 +0000

思路

求解代码

 public class TreeDistance {

        /**
         * 计算两个节点在二叉树中的距离
         *
         * @param root 二叉树的根节点
         * @param p    第一个节点
         * @param q    第二个节点
         * @return 两个节点之间的距离
         */
        public int distanceBetweenNodes(TreeNode root, TreeNode p, TreeNode q) {
            // 首先找到两个节点的最近公共祖先(LCA)
            TreeNode lca = findLCA(root, p, q);
            // 计算节点p到LCA的深度
            int depthP = findDepth(lca, p);
            // 计算节点q到LCA的深度
            int depthQ = findDepth(lca, q);
            // 两个节点之间的距离等于它们到LCA的深度之和
            return depthP + depthQ;
        }

        /**
         * 查找二叉树中两个节点的最近公共祖先(LCA)
         *
         * @param root 二叉树的根节点
         * @param p    第一个目标节点
         * @param q    第二个目标节点
         * @return 最近公共祖先节点，如果其中一个节点是根节点，则返回该节点；如果两个节点分别在左右子树中，则返回它们的根节点
         */
        private TreeNode findLCA(TreeNode root, TreeNode p, TreeNode q) {
            // 如果根节点为空，或者根节点是p或q中的一个，直接返回根节点
            if (root == null || root == p || root == q) {
                return root;
            }
            // 递归查找左子树中的LCA
            TreeNode left = findLCA(root.left, p, q);
            // 递归查找右子树中的LCA
            TreeNode right = findLCA(root.right, p, q);
            // 如果左右子树都找到了非空节点，说明p和q分别在左右子树中，当前节点就是LCA
            if (left != null && right != null) {
                return root;
            }
            // 如果左子树找到非空节点，则返回左子树的结果，否则返回右子树的结果
            return left != null ? left : right;
        }


        /**
         * 查找目标节点在给定祖先节点下的深度
         *
         * @param ancestor 起始祖先节点
         * @param target   目标节点
         * @return 目标节点相对于祖先节点的深度，如果未找到则返回-1
         */
        private int findDepth(TreeNode ancestor, TreeNode target) {
            // 如果祖先节点为空，说明无法找到目标节点，返回-1
            if (ancestor == null) {
                return -1;
            }
            // 如果当前节点就是目标节点，深度为0
            if (ancestor == target) {
                return 0;
            }
            // 递归查找左子树
            int left = findDepth(ancestor.left, target);
            // 如果在左子树中找到目标节点，返回左子树深度+1
            if (left != -1) {
                return left + 1;
            }
            // 递归查找右子树
            int right = findDepth(ancestor.right, target);
            // 如果在右子树中找到目标节点，返回右子树深度+1，否则返回-1
            return right != -1 ? right + 1 : -1;
        }
    }

BISHI103 【模板】有依赖的背包问题

Tue, 10 Mar 2026 20:41:45 +0000

思路

求解代码

// 存储并查集中节点 i 的父节点
    private static int[] parent;
    // 存储第 i 朵云（或合并后以 i 为根的商品组）的总价钱
    private static int[] cost;
    // 存储第 i 朵云（或合并后以 i 为根的商品组）的总价值
    private static int[] value;

    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 个搭配关系, w 现有的钱
        String[] strA = br.readLine().trim().split("\\s+");
        int n = Integer.parseInt(strA[0]);
        int m = Integer.parseInt(strA[1]);
        int w = Integer.parseInt(strA[2]);

        parent = new int[n + 1];
        cost = new int[n + 1];
        value = new int[n + 1];

        // 2. 初始化每朵云的属性，并初始化并查集（每个节点初始父节点为自己）
        for (int i = 1; i <= n; i++) {
            String[] strB = br.readLine().trim().split("\\s+");
            cost[i] = Integer.parseInt(strB[0]);
            value[i] = Integer.parseInt(strB[1]);
            parent[i] = i;
        }

        // 3. 处理搭配购买关系：使用并查集将必须一起买的云“联通”起来
        for (int i = 0; i < m; i++) {
            String[] strC = br.readLine().trim().split("\\s+");
            int u = Integer.parseInt(strC[0]);
            int v = Integer.parseInt(strC[1]);
            union(u, v);
        }

        // 4.将同一集合内所有云的价钱和价值全部累加到该集合的“根节点”上
        for (int i = 1; i <= n; i++) {
            int root = find(i);
            // 如果当前节点不是根节点，则将其属性转移给根节点
            if (root != i) {
                cost[root] += cost[i];
                value[root] += value[i];
                // 清空当前非根节点的属性，防止在后续背包计算中被重复统计
                cost[i] = 0;
                value[i] = 0;
            }
        }

        // 5. 执行 0/1 背包算法
        // dp[j] 表示在花费 j 元钱的情况下能获得的最大价值
        int[] dp = new int[w + 1];
        for (int i = 1; i <= n; i++) {
            // 只处理根节点（代表一个完整的“捆绑商品组”）
            if (parent[i] == i) {
                // 0/1 背包内层循环必须“逆序遍历”，防止同一商品被多次购买
                for (int j = w; j >= cost[i]; j--) {
                    // 状态转移方程：不买当前组 vs 买当前组（消耗钱，加价值）
                    dp[j] = Math.max(dp[j], dp[j - cost[i]] + value[i]);
                }
            }
        }

        // 6. 输出预算 w 内能获得的最大总价值
        out.println(dp[w]);

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

    /**
     * 查找根节点（带路径压缩优化）
     */
    private static int find(int i) {
        if (parent[i] == i) {
            return i;
        }
        // 将查找路径上的所有节点直接挂在根节点下，加速后续查找
        return parent[i] = find(parent[i]);
    }

    /**
     * 合并两个集合
     */
    private static void union(int i, int j) {
        int rootI = find(i);
        int rootJ = find(j);
        if (rootI != rootJ) {
            // 将 I 树合并到 J 树下
            parent[rootI] = rootJ;
        }
    }

BISHI102 【模板】并查集

Tue, 10 Mar 2026 20:04:55 +0000

思路

求解代码

// 存储节点 i 的父节点编号；当 parent[i] == i 时，i 为该集合的根节点
    private static int[] parent;
    // 仅在 i 为根节点时有效，记录以 i 为根的集合中包含的元素总数
    private static int[] size;

    public static void main(String[] args) throws IOException {
        // 使用高性能输入输出流
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 解析输入首行的 n (元素总数) 和 q (操作总数)
        String[] strA = br.readLine().trim().split("\\s+");
        int n = Integer.parseInt(strA[0]);
        int q = Integer.parseInt(strA[1]);

        parent = new int[n + 1];
        size = new int[n + 1];
        for (int i = 1; i <= n; i++) {
            // 初始状态下，每个元素自成一个集合，父节点指向自己
            parent[i] = i;
            // 每个初始集合的大小均为 1
            size[i] = 1;
        }

        while (q-- > 0) {
            String[] strB = br.readLine().trim().split("\\s+");
            int op = Integer.parseInt(strB[0]); // 操作类型编号

            switch (op) {
                case 1: {
                    // 合并操作：将 i 和 j 所在的两个集合合并为一个
                    int i = Integer.parseInt(strB[1]);
                    int j = Integer.parseInt(strB[2]);
                    union(i, j);
                    break;
                }
                case 2: {
                    // 判断 i 和 j 是否属于同一个集合
                    int i = Integer.parseInt(strB[1]);
                    int j = Integer.parseInt(strB[2]);
                    // 若两者的根节点相同，则在同一集合，输出 YES
                    out.println(find(i) == find(j) ? "YES" : "NO");
                    break;
                }
                case 3: {
                    // 获取 i 所在集合的元素总数
                    int i = Integer.parseInt(strB[1]);
                    // 必须先通过 find(i) 找到根节点，因为只有根节点的 size 是准确的
                    out.println(size[find(i)]);
                    break;
                }
            }
        }

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

    /**
     * 查找元素 i 所在集合的根节点
     * 在递归查找过程中，将路径上所有节点的父节点直接指向根节点
     */
    private static int find(int i) {
        // 如果自己就是根节点，直接返回
        if (parent[i] == i) {
            return i;
        }
        // 将查找到的根节点赋值给当前节点的 parent 数组
        return parent[i] = find(parent[i]);
    }

    /**
     * 将包含 i 和 j 的两个集合合并
     *
     * @param i 第一个元素
     * @param j 第二个元素
     */
    private static void union(int i, int j) {
        // 分别获取两个元素当前的根节点
        int rootI = find(i);
        int rootJ = find(j);

        // 如果根节点不同，说明处于不同集合，执行合并
        if (rootI != rootJ) {
            // 将 I 集合的根节点挂载到 J 集合的根节点之下
            parent[rootI] = rootJ;
            // 将被合并集合的规模累加到新的根节点 (rootJ) 上
            size[rootJ] += size[rootI];
        }
    }

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();
    }

BISHI100 【模板】二分图结构Ⅰ-A ‖ 染色判定：DFS

Mon, 09 Mar 2026 20:51:45 +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]);  // 边数

        // 创建邻接表表示的无向图
        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);  // 无向图，双向添加
        }

        // color数组用于记录每个顶点的颜色，0表示未染色，1和2表示两种不同的颜色
        int[] color = new int[n + 1];
        boolean flag = true;  // 标记是否为二分图

        // 使用队列实现BFS
        Queue<Integer> queue = new LinkedList<>();

        // 从顶点1开始染色，并将其加入队列
        queue.add(1);
        color[1] = 1;

        // BFS遍历图
        while (!queue.isEmpty()) {

            int cur = queue.poll();  // 取出队首顶点

            // 遍历当前顶点的所有邻接顶点
            for (int neighbor : adj[cur]) {

                // 如果邻接顶点未被染色
                if (color[neighbor] == 0) {

                    // 将邻接顶点染成与当前顶点不同的颜色
                    color[neighbor] = 3 - color[cur];
                    queue.add(neighbor);  // 将邻接顶点加入队列
                } else if (color[neighbor] == color[cur]) {
                    // 如果邻接顶点与当前顶点颜色相同，则不是二分图
                    flag = false;
                    break;
                }
            }
        }

        // 输出结果：如果是二分图输出"YES"，否则输出"NO"
        out.println(flag ? "YES" : "NO");
        // 刷新输出缓冲区，确保所有输出都被写入
        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;
    }

BISHI96 先序遍历、中序遍历和后序遍历

Sat, 07 Mar 2026 19:38:45 +0000

思路

求解代码

// 使用数组模拟指针，lc[i] 存储节点 i 的左孩子，rc[i] 存储右孩子
    private static int[] lc, rc;

    // 使用 StringBuilder 缓存结果
    private static StringBuilder preOrder = new StringBuilder();
    private static StringBuilder inOrder = new StringBuilder();
    private static StringBuilder postOrder = new StringBuilder();

    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));

        int n = Integer.parseInt(br.readLine().trim());

        // 边界情况：空树
        if (n == 0) {
            return;
        }

        // 初始化结构：n+1 长度是为了匹配从 1 开始的节点编号
        lc = new int[n + 1];
        rc = new int[n + 1];
        boolean[] hasParent = new boolean[n + 1]; // 用于寻找根节点（根节点没有父节点）

        // 使用邻接表暂时存储“父 -> 子”的原始指向关系，随后再按规则分配左右
        List<Integer>[] adj = new ArrayList[n + 1];
        for (int i = 1; i <= n; i++) {
            adj[i] = new ArrayList<>();
        }

        // 读取 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);
            hasParent[v] = true; // 只要被指向，就说明该节点不是根节点
        }

        /**
         * 根据题目定义的规则，将 adj 里的子节点分配到 lc 或 rc
         */
        for (int i = 1; i <= n; i++) {
            // 父节点拥有两个孩子
            if (adj[i].size() == 2) {
                int c1 = adj[i].get(0);
                int c2 = adj[i].get(1);
                // 编号小者为左，大者为右
                lc[i] = Math.min(c1, c2);
                rc[i] = Math.max(c1, c2);
            }
            // 父节点仅有一个孩子
            else if (adj[i].size() == 1) {
                int child = adj[i].get(0);
                // 子节点编号 > 父节点编号 ➜ 视为左孩子；反之 ➜ 视为右孩子
                if (child > i) {
                    lc[i] = child;
                } else {
                    rc[i] = child;
                }
            }
        }

        // 寻找整棵树的唯一根节点
        int root = 1;
        for (int i = 1; i <= n; i++) {
            if (!hasParent[i]) {
                root = i;
                break;
            }
        }

        // 从根节点开始DFS
        traverse(root);

        // 格式化输出
        out.println(preOrder.toString().trim());
        out.println(inOrder.toString().trim());
        out.println(postOrder.toString().trim());

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

    /**
     * 深度优先遍历 (DFS) 方法
     *
     * @param cur 当前正在访问的节点索引
     */
    private static void traverse(int cur) {
        // 基准情形：如果当前节点为 0，说明触碰到了空叶子节点，停止向下延伸
        if (cur == 0) {
            return;
        }

        /**
         * 1. 先序遍历 (Pre-order)：[中] -> 左 -> 右
         * 刚进入当前节点时立即记录。
         */
        preOrder.append(cur).append(" ");

        // 向左延伸
        traverse(lc[cur]);

        /**
         * 2. 中序遍历 (In-order)：左 -> [中] -> 右
         * 当左子树全部处理完毕回溯到当前点时记录。
         */
        inOrder.append(cur).append(" ");

        // 向右延伸
        traverse(rc[cur]);

        /**
         * 3. 后序遍历 (Post-order)：左 -> 右 -> [中]
         * 当左右子树全部处理完毕，即将彻底离开当前点时记录。
         */
        postOrder.append(cur).append(" ");
    }

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();
    }

BISHI94 【模板】马拉车算法

Fri, 06 Mar 2026 20:32:16 +0000

思路

求解代码

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

        // 读取输入字符串并去除首尾空格
        String s = br.readLine().trim();

        // 处理空字符串或null值的情况
        if (s == null || s.length() == 0) {
            out.println(0);  // 输出0
            out.flush();     // 确保所有输出都被刷新
            return;          // 提前返回
        }

        // 调用manacher算法处理字符串并输出结果
        out.println(manacher(s));
        out.flush();  // 刷新输出缓冲区
        out.close();  // 关闭输出流
        br.close();   // 关闭输入流
    }

    /**
     * Manacher算法实现，用于查找字符串中的最长回文子串的长度
     * 该算法通过预处理字符串和利用回文对称性来高效地找到最长回文子串
     *
     * @param s 输入的字符串
     * @return 返回最长回文子串的长度
     */
    private static int manacher(String s) {
        // 构造新的字符串，以^开头，$结尾，并在每个字符间插入#，这样可以统一处理奇数和偶数长度的回文
        StringBuilder sb = new StringBuilder("^");

        // 在原字符串的每个字符前后添加特殊字符#
        for (char c : s.toCharArray()) {
            sb.append("#").append(c);
        }

        // 添加结尾标记
        sb.append("#$");

        // 将构造好的字符串转换为字符数组
        char[] t = sb.toString().toCharArray();

        // 获取新字符串的长度
        int n = t.length;
        // 创建数组p，p[i]表示以t[i]为中心的最长回文半径
        int[] p = new int[n];
        // c表示当前回文中心，r表示当前回文右边界
        int c = 0, r = 0;
        // 记录最长回文半径
        int maxLen = 0;

        // 遍历字符串，跳过首尾的特殊字符
        for (int i = 1; i < n - 1; i++) {
            // 利用回文对称性，如果i在当前回文范围内，则获取其对称位置的回文半径
            p[i] = r > i ? Math.min(r - i, p[2 * c - i]) : 0;

            // 尝试扩展以i为中心的回文
            while (t[i + p[i] + 1] == t[i - p[i] - 1]) {
                p[i]++;
            }

            // 如果当前回文右边界超过了r，更新中心和右边界
            if (i + p[i] > r) {
                c = i;
                r = i + p[i];
            }

            // 更新最大回文半径
            maxLen = Math.max(maxLen, p[i]);
        }

        // 返回最长回文半径，也就是最长回文子串的长度
        return maxLen;
    }

BISHI93 【模板】Trie 字典树

Thu, 05 Mar 2026 22:07:17 +0000

思路

求解代码

/**
     * trie[p][i]: 字典树的节点存储。
     * 第一维 p 代表节点的编号（行号）；
     * 第二维 i 代表字符的映射索引（0-51）。
     * 值存储的是该字符指向的下一个节点的编号。
     */
    private static int[][] trie = new int[1000005][52];

    /**
     * count[p]: 前缀统计的核心。
     * 记录有多少个模式串在插入过程中经过了编号为 p 的节点。
     * 因为我们要统计“以某串为前缀的个数”，所以每经过一个点都要加1。
     */
    private static int[] count = new int[1000005];

    /**
     * nodes: 记录当前字典树已经创建的节点总数。
     * 编号 0 始终代表根节点（不存储具体字符）。
     */
    private static int nodes = 0;

    public static void main(String[] args) throws IOException {
        // 使用高效的输入输出流处理百万级数据，防止超时
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取第一行：模式串数量 n 和查询次数 q
        String[] strA = br.readLine().trim().split("\\s+");
        int n = Integer.parseInt(strA[0]);
        int q = Integer.parseInt(strA[1]);

        // 1. 构建字典树阶段
        for (int i = 0; i < n; i++) {
            insert(br.readLine().trim());
        }

        // 2. 查询阶段
        for (int i = 0; i < q; i++) {
            // 直接输出以该文本串为前缀的模式串数量
            out.println(query(br.readLine().trim()));
        }

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

    /**
     * 将字符映射到 0-51 的索引空间。
     * 区分大小写：'A'-'Z' 映射到 0-25，'a'-'z' 映射到 26-51。
     */
    private static int getIndex(char c) {
        return c >= 'A' && c <= 'Z' ? c - 'A' : c - 'a' + 26;
    }

    /**
     * 模式串插入方法
     * 核心逻辑：沿着路径在每个经过的节点打标记计数。
     */
    private static void insert(String s) {
        int p = 0; // 从根节点 (编号 0) 开始
        for (char c : s.toCharArray()) {
            int i = getIndex(c);
            // 如果当前字符在当前节点下没有对应的子节点，则新建一个
            if (trie[p][i] == 0) {
                trie[p][i] = ++nodes;
            }
            // 移动到子节点
            p = trie[p][i];
            /**
             * 关键：只要经过这个节点，count 就自增。
             * 这样 count[p] 就代表了有多少个单词是以“从根到当前点”这一串字符为前缀的。
             */
            count[p]++;
        }
    }

    /**
     * 文本串查询方法
     * 核心逻辑：在字典树中顺着文本串寻找路径，若能走完路径，返回最后的 count。
     */
    private static int query(String t) {
        int p = 0; // 从根节点开始
        for (char c : t.toCharArray()) {
            int i = getIndex(c);
            /**
             * 如果在路径中发现某个字符没有对应的分支，
             * 说明没有任何一个模式串包含这个前缀，直接返回 0。
             */
            if (trie[p][i] == 0) {
                return 0;
            }
            p = trie[p][i]; // 顺着路径向下走
        }
        /**
         * 成功走完文本串 t 的所有字符，
         * 此时节点 p 的 count 值就是在插入阶段经过该点的字符串总数。
         */
        return count[p];
    }

BISHI92 【模板】前缀函数（kmp）

Thu, 05 Mar 2026 20:58:37 +0000

思路

求解代码

public static void main(String[] args) throws IOException {
        // 创建缓冲读取器，用于从标准输入读取数据
        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) {
            // 读取一行输入并分割成字符串数组
            String[] s = br.readLine().trim().split("\\s+");
            // 获取字符串的长度n
            int n = Integer.parseInt(s[0]);

            // 计算前缀函数数组
            int[] pi = computePre(s[1], n);

            // 输出前缀函数数组，元素间用空格分隔
            for (int i = 0; i < n; i++) {
                out.print(pi[i] + (i == n - 1 ? "" : " "));
            }
            // 换行
            out.println();
        }

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

    /**
     * 计算字符串的前缀函数（Prefix Function）
     * 前缀函数pi[i]表示字符串s[0..i]的最长相等前后缀的长度（不包括s[0..i]本身）
     *
     * @param s 输入的字符串
     * @param n 字符串的长度
     * @return 返回前缀函数数组pi，其中pi[i]表示s[0..i]的最长相等前后缀长度
     */
    private static int[] computePre(String s, int n) {
        int[] pi = new int[n];  // 初始化前缀函数数组，长度为n

        // 从第二个字符开始遍历字符串
        for (int i = 1; i < n; i++) {
            int j = pi[i - 1];  // 初始化j为前一个字符的前缀函数值

            // 当j大于0且当前字符不匹配时，通过前缀函数回退
            while (j > 0 && s.charAt(i) != s.charAt(j)) {
                j = pi[j - 1];  // 回退到前一个可能匹配的位置
            }

            // 如果当前字符匹配，则增加匹配长度
            if (s.charAt(i) == s.charAt(j)) {
                j++;
            }

            // 将当前字符的前缀函数值存入数组
            pi[i] = j;
        }
        return pi;  // 返回计算得到的前缀函数数组
    }

【DFS+剪枝】BISHI91 拼接木棍

Wed, 04 Mar 2026 22:20:09 +0000

思路

求解代码

// n: 小木棒总数, sum: 所有木棒总长度, targetL: 目标原始长度, numbers: 目标原始木棒根数
    private static int n, sum, targetL, numbers;
    private static Integer[] a; // 存储砍断后的小木棒长度

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        n = Integer.parseInt(br.readLine().trim());
        String[] s = br.readLine().trim().split("\\s+");
        a = new Integer[n];
        boolean[] used = new boolean[n]; // 标记每根小木棒是否已被乔治使用
        sum = 0;
        int maxL = 0;

        for (int i = 0; i < n; i++) {
            a[i] = Integer.parseInt(s[i]);
            sum += a[i];
            maxL = Math.max(maxL, a[i]); // 原始长度至少要等于最长的那根小木棒
        }

        // 【剪枝优化 1】：降序排序。
        // 优先尝试长木棒。因为长木棒对位置要求更苛刻，如果它拼不通，能更早触发回溯。
        Arrays.sort(a, (x1, x2) -> (x2 - x1));

        // 枚举原始木棒可能的长度 targetL
        // 范围：从最长的那根开始，直到所有木棒的总和
        for (targetL = maxL; targetL <= sum; targetL++) {

            // 【条件约束】：原始长度必须能被总长度整除，否则乔治不可能拼成同样长的木棒
            if (sum % targetL != 0) {
                continue;
            }

            numbers = sum / targetL; // 计算在当前 targetL 下应该拼出多少根

            // 尝试拼凑，初始：已完成0根，当前长度0，从第0个小木棒开始找
            if (dfs(0, 0, 0, used)) {
                out.println(targetL); // 找到第一个可行的最小长度，即为答案
                break;
            }
        }
        out.flush();
        out.close();
        br.close();
    }

    /**
     * DFS 拼凑过程
     *
     * @param completed 已完整拼好的原始木棒根数
     * @param currentL  当前正在拼的那根原始木棒已经达到的长度
     * @param idx       为了避免重复组合，从数组的哪一个下标开始挑选下一根小木棒
     * @param used      使用情况记录
     */
    private static boolean dfs(int completed, int currentL, int idx, boolean[] used) {
        // 【递归出口】：如果乔治拼好了所有原始木棒，大功告成
        if (completed == numbers) {
            return true;
        }

        // 如果当前这根拼满了，开启下一根木棒的拼凑
        if (currentL == targetL) {
            return dfs(completed + 1, 0, 0, used);
        }

        for (int i = idx; i < n; i++) {
            // 如果这根用过了，或者放进去就超过了目标长度，跳过
            if (used[i] || currentL + a[i] > targetL) {
                continue;
            }

            // 【做选择】：尝试放这根木棒
            used[i] = true;
            if (dfs(completed, currentL + a[i], i + 1, used)) {
                return true;
            }

            // 【撤销选择】：刚才的尝试失败了，拿出来
            used[i] = false;

            // --- 核心剪枝策略 (极其关键) ---

            // 【剪枝优化 2】：首棒失败判定
            // 如果此时 currentL 为 0，说明我们正在尝试拼一根新木棒的第一部分。
            // 如果第一部分用这根最长的木棒都拼不出来，那后面更拼不出来了。

            // 【剪枝优化 3】：末棒失败判定
            // 如果加上这根木棒刚好填满了 targetL，但在后续递归中失败了，
            // 说明用这根刚好填满的方案不行，那么换用几根更碎的小木棒来填这个坑也肯定不行。
            if (currentL == 0 || currentL + a[i] == targetL) {
                return false;
            }

            // 【剪枝优化 4】：去重剪枝
            // 如果当前长度的木棒不行，那后面相同长度的木棒也肯定不行，直接跳过。
            while (i + 1 < n && a[i + 1].equals(a[i])) {
                i++;
            }
        }
        return false;
    }

BISHI90 【模板】记忆化搜索

Wed, 04 Mar 2026 20:51:44 +0000

思路

求解代码

 private static final int MOD = 1000000007;
    private static long[][][] memory = new long[101][101][101];

    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));


        int T = Integer.parseInt(br.readLine().trim());

        while (T-- > 0) {
            String[] s = br.readLine().trim().split("\\s+");
            int a = Integer.parseInt(s[0]);
            int b = Integer.parseInt(s[1]);
            int c = Integer.parseInt(s[2]);
            out.println(solve(a, b, c));
        }


        // 刷新输出流，确保所有输出都被写入
        out.flush();
        // 关闭输出流，释放资源
        out.close();
        // 关闭输入流，释放资源
        br.close();
    }

    /**
     * 这是一个递归求解函数，使用记忆化技术来优化性能
     *
     * @param a 第一个参数
     * @param b 第二个参数
     * @param c 第三个参数
     * @return 返回计算结果，类型为long
     */
    private static long solve(int a, int b, int c) {
        // 如果任一参数小于等于0，返回1
        if (a <= 0 || b <= 0 || c <= 0) {
            return 1;
        }

        // 如果结果已经计算过并存储在memory中，直接返回存储的结果
        if (memory[a][b][c] != 0) {
            return memory[a][b][c];
        }

        long res; // 用于存储计算结果

        // 当a<b且b<c时，使用特定的递归公式计算
        if (a < b && b < c) {
            res = (solve(a, b, c - 1) + solve(a, b - 1, c - 1)) % MOD;
            res = (res - solve(a, b - 1, c) + MOD) % MOD;
        } else {
            res = (solve(a - 1, b, c) + solve(a - 1, b - 1, c)) % MOD;
            res = (res + solve(a - 1, b, c - 1)) % MOD;
            res = (res - solve(a - 1, b - 1, c - 1) + MOD) % MOD;
        }
        return memory[a][b][c] = res;
    }

【二分】BISHI89 山峰数组计数

Tue, 03 Mar 2026 21:17:15 +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，表示数组的长度
        int n = Integer.parseInt(br.readLine().trim());
        // 创建长度为n的数组P，用于存储输入的数值
        long[] P = new long[n];
        // 创建长度为n+1的前缀和数组preSum，preSum[0]=0
        long[] preSum = new long[n+1];

        // 读取一行输入，按空格分割成字符串数组
        String[] s= br.readLine().trim().split("\\s+");
        // 计算前缀和
        for(int i=0;i<n;i++){
            // 将字符串转换为长整型并存入数组P
            P[i]= Long.parseLong(s[i]);
            // 计算前缀和，preSum[i+1]表示前i个元素的和
            preSum[i+1]=preSum[i]+P[i];
        }

        // 初始化总和变量total
        long total = 0;

        // 遍历数组，从第2个元素开始到倒数第2个元素
        for (int j=2;j<n;j++){
            // 计算limit1，即(preSum[j]-1)/2
            long limit1 = (preSum[j]-1)/2;
            // 计算limit2，即2*preSum[j]-preSum[n]-1
            long limit2 = 2*preSum[j]-preSum[n]-1;
            // 取limit1和limit2中的较小值作为阈值
            long threshold = Math.min(limit1,limit2);

            // 如果阈值大于等于第一个元素的前缀和
            if (threshold >= preSum[1]){
                // 调用upper函数计算符合条件的元素个数
                int count = upper(preSum,1,j-1,threshold);
                // 将count累加到total中
                total += count;
            }
        }



        // 输出最终结果
        out.println(total);

        // 刷新输出流，确保所有输出都被写入
        out.flush();
        // 关闭输出流，释放资源
        out.close();
        // 关闭输入流，释放资源
        br.close();
    }

/**
 * 在有序数组中查找最后一个小于等于目标值的元素的位置，并返回满足条件的元素个数
 * @param preSum 有序数组，表示前缀和数组
 * @param left 查找范围的左边界
 * @param right 查找范围的右边界
 * @param target 目标值
 * @return 返回在[left, right]范围内小于等于target的元素个数
 */
    private static int upper(long[] preSum,int left,int right,long target){
        int low = left,high = right;    // 初始化查找范围的左右边界
        int ans = 0;                    // 初始化答案变量

        // 执行二分查找
        while(low<=high){
            int mid = low +((high-low)>>1);   // 计算中间值，使用位运算优化替代除法

                                        // 这种写法可以避免(low+high)可能导致的整数溢出问题
            // 检查中间值是否满足条件
            if(preSum[mid]<=target){    // 如果中间值小于等于目标值
                ans = mid;              // 更新答案为当前位置
                low = mid+1;            // 在右半部分继续查找
            }else{                      // 如果中间值大于目标值
                high = mid-1;           // 在左半部分继续查找
            }
        }
    // 返回结果：如果找到满足条件的元素，返回其个数；否则返回0
        return ans>0?(ans-left+1):0;
    }

【二分】BISHI88 小苯的魔法染色

Tue, 03 Mar 2026 20:41:07 +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));

        // 读取第一行输入，分割为字符串数组
        String[] strA = br.readLine().trim().split("\\s+");

        int n = Integer.parseInt(strA[0]);    // 获取字符串长度
        int m = Integer.parseInt(strA[1]);    // 获取操作次数

        char[] c = new char[n];               // 创建字符数组，虽然在此代码中未使用

        String s= br.readLine().trim();      // 待处理的字符串

        int low = 0,high = n;                // 二分查找的边界
        int ans = n;                          // 初始化答案为字符串长度

        // 执行二分查找
        while(low<=high){
            int mid = low +((high-low)>>1);   // 计算中间值，使用位运算优化替代除法

            // 检查中间值是否满足条件
            if(check(mid,n,m,s)){
                ans = mid;                     // 如果满足条件，更新答案
                high = mid-1;                // 尝试寻找更小的解
            }else{
                low = mid+1;                 // 如果不满足，尝试更大的值
            }
        }

        // 输出最终结果
        out.println(ans);

        // 刷新输出流，确保所有输出都被写入
        out.flush();
        // 关闭输出流，释放资源
        out.close();
        // 关闭输入流，释放资源
        br.close();
    }
    
    private static boolean check(int k,int n,int m,String s){
        // 如果k为0，检查字符串中是否不包含'W'
        if(k==0){
            return !s.contains("W");
        }

        int count = 0; // 记录操作次数
        // 遍历字符串
        for (int i=0;i<n;i++){
            // 如果当前字符是'W'，增加操作计数
            if(s.charAt(i)=='W'){
                count++;
                // 如果操作次数超过m，返回false
                if(count>m){
                    return false;
                }
                // 跳过接下来的k-1个字符
                i+=(k-1);
            }
        }

        // 检查总操作次数是否不超过m
        return count<=m;
    }

【二分】BISHI87 [CQOI2010]扑克牌

Mon, 02 Mar 2026 21:44:34 +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));

        // 读取第一行输入，分割为字符串数组
        String[] strA = br.readLine().trim().split("\\s+");

        int n = Integer.parseInt(strA[0]);
        long m = Long.parseLong(strA[1]);

        int[] c = new int[n];                   // 创建大小为n的整型数组

        // 读取第二行输入，分割为字符串数组
        String[] strB = br.readLine().trim().split("\\s+");

        // 将字符串数组转换为整型数组
        for(int i=0;i<n;i++){
            c[i]=Integer.parseInt(strB[i]);
        }



        // 初始化二分查找的边界和结果变量
        long low = 0,high = 10000000000L;      // 设置查找范围为0到100亿
        long ans = 0;

        // 执行二分查找
        while(low<=high){
            long mid = low +((high-low)>>1);   // 计算中间值，使用位运算优化

            // 检查中间值是否满足条件
            if(check(mid,n,m,c)){
                ans = mid;                     // 如果满足条件，更新答案
                low = mid+1;                   // 尝试更大的值
            }else{
                high = mid-1;                  // 如果不满足，尝试更小的值
            }
        }

        // 输出最终结果
        out.println(ans);

        // 刷新输出流
        out.flush();
        // 关闭输出流
        out.close();
        // 关闭输入流
        br.close();
    }

    private static boolean check(long x,int n,long m,int[] c){
        long need = 0; // 需要添加的资源总量
        for(int count:c){ // 遍历每种资源的当前数量
            if(count<x){ // 如果当前资源数量小于目标数量
                need +=(x-count); // 计算需要添加的资源数量
            }
        }

        return need <= m&& need <=x; // 判断需要添加的资源总量是否不超过m和x
    }

【二分】BISHI86 圆覆盖

Mon, 02 Mar 2026 20:59:32 +0000

思路

求解代码

 /**
     * 表示一个点的静态内部类
     * 包含两个属性：d2和v
     */
    static class Point {
        // 平方距离属性，通常用于表示点与点之间的距离平方
        long d2;
        // 权值属性
        long v;


        Point(long d2, long v) {
            // 使用this关键字将参数值赋给类的成员变量
            this.d2 = d2;
            this.v = v;
        }
    }

    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));

        // 读取第一行输入，分割为字符串数组
        String[] strA = br.readLine().trim().split("\\s+");
        // 获取点的数量n
        int n = Integer.parseInt(strA[0]);
        // 获取所需的最小权值S
        long S = Long.parseLong(strA[1]);

        // 创建二维数组存储每个点的坐标和权值
        long[][] a = new long[n][3];

        // 创建Point数组，用于存储每个点到原点的距离平方和权值
        Point[] points = new Point[n];
        // 初始化总权值
        long total = 0;
        // 读取每个点的数据并计算相关信息
        for (int i = 0; i < n; i++) {
            // 读取一行输入并分割
            String[] str = br.readLine().trim().split("\\s+");
            // 存储x坐标
            a[i][0] = Long.parseLong(str[0]);
            // 存储y坐标
            a[i][1] = Long.parseLong(str[1]);
            // 存储权值
            a[i][2] = Long.parseLong(str[2]);

            // 创建Point对象，计算点到原点的距离平方
            points[i] = new Point(a[i][0] * a[i][0] + a[i][1] * a[i][1], a[i][2]);

            // 累加总权值
            total += a[i][2];

        }

        // 如果总权值小于所需权值S，输出-1并返回
        if (total < S) {
            out.println("-1");
            out.flush();
            return;
        }

        // 对points数组进行排序，使用Lambda表达式作为比较器，按照d2属性值升序排序
        Arrays.sort(points, (x1, x2) -> Long.compare(x1.d2, x2.d2));

        // 创建前缀和数组preSum，长度为n
        long[] preSum = new long[n];
        // 初始化前缀和数组的第一个元素为points[0]的v值
        preSum[0] = points[0].v;
        // 计算前缀和数组，preSum[i]存储从points[0]到points[i]的v值之和
        for (int i = 1; i < n; i++) {
            preSum[i] = preSum[i - 1] + points[i].v;
        }

        // 初始化二分查找的边界，low为0，high为n-1
        int low = 0, high = n - 1;

        // 初始化index为n-1，用于存储满足条件的最小索引
        int index = n - 1;

        // 使用二分查找算法找到满足preSum[mid] >= S的最小mid值
        while (low <= high) {
            // 计算中间位置，使用位运算防止溢出
            int mid = low + ((high - low) >> 1);
            // 如果当前前缀和大于等于S，则更新index并向左查找更小的值
            if (preSum[mid] >= S) {
                index = mid;
                high = mid - 1;
            } else {
                // 否则向右查找
                low = mid + 1;
            }
        }

        // 输出满足条件的点的d2值的平方根
        out.println(Math.sqrt(points[index].d2));
        // 刷新输出流
        out.flush();
        // 关闭输出流
        out.close();
        // 关闭输入流
        br.close();
    }

【二分】BISHI85 【模板】整数域二分

Sun, 01 Mar 2026 21:36:42 +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));

        // 读取第一行输入，分割成字符串数组
        String[] strA = br.readLine().trim().split("\\s+");

        // 解析数组长度n和查询次数q
        int n = Integer.parseInt(strA[0]);
        int q = Integer.parseInt(strA[1]);
        // 创建数组a并读取输入数据
        int[] a = new int[n];
        String[] strB = br.readLine().trim().split("\\s+");
        for (int i = 0; i < n; i++) {
            a[i] = Integer.parseInt(strB[i]);
        }

        // 对数组进行排序，为后续查询做准备
        Arrays.sort(a);
        // 处理q次查询
        while (q-- > 0) {
            // 读取每次查询的左右边界
            String[] strC = br.readLine().trim().split("\\s+");

            int l = Integer.parseInt(strC[0]);
            int r = Integer.parseInt(strC[1]);

            // 使用二分查找计算下界和上界
            int left = lowerBound(a, l);
            int right = upperBound(a, r);

            // 输出结果：范围内的元素个数
            out.println(right - left);

        }

        // 关闭IO资源
        out.flush();
        out.close();
        br.close();
    }

    /**
     * 二分查找下界函数
     *
     * @param a      已排序的数组
     * @param target 目标值
     * @return 第一个大于等于target的元素的索引
     */
    private static int lowerBound(int[] a, int target) {
        // 初始化查找范围的 low 和 high 指针
        // low 从数组的起始位置 0 开始
        // high 从数组长度开始（不包括该位置）
        int low = 0, high = a.length;

        // 当 low 小于 high 时，继续查找
        // 这是循环查找的条件，确保查找范围有效
        while (low < high) {
            // 计算中间位置 mid
            // 使用位运算 (high-low)>>1 代替除法 2，提高效率
            // 防止整数溢出，同时确保 mid 总是在 low 和 high 之间
            int mid = low + ((high - low) >> 1);

            // 如果中间位置的元素大于等于目标值
            // 说明目标值可能在左半部分，或者 mid 就是我们要找的位置
            // 因此将 high 设置为 mid，继续在左半部分查找
            if (a[mid] >= target) {
                high = mid;
            } else {
                // 如果中间位置的元素小于目标值
                // 说明目标值一定在右半部分
                // 因此将 low 设置为 mid+1，继续在右半部分查找
                low = mid + 1;
            }

        }
        // 当循环结束时，low 指向第一个大于等于 target 的元素的位置
        // 如果所有元素都小于 target，则返回数组长度
        return low;
    }

    /**
     * 二分查找上界函数
     *
     * @param a      已排序的数组
     * @param target 目标值
     * @return 第一个大于target的元素的索引
     */
    private static int upperBound(int[] a, int target) {
        // 初始化查找范围的左右边界，左边界为0，右边界为数组长度
        int low = 0, high = a.length;

        // 当左边界小于右边界时，继续查找
        while (low < high) {
            // 计算中间位置，使用位运算防止溢出
            int mid = low + ((high - low) >> 1);

            // 如果中间位置的值大于目标值，则上界在左半部分
            if (a[mid] > target) {
                high = mid;
            } else {
                // 否则上界在右半部分，且不包括中间位置
                low = mid + 1;
            }

        }
        // 返回第一个大于target的元素的索引
        return low;
    }

【BFS】BISHI84 时津风的资源收集

Sun, 01 Mar 2026 20:38:54 +0000

思路

求解代码

// 定义一个静态数组dist，用于存储从数字10到其他数字的最小步数
    private static int[] dist = new int[301];

    public static void main(String[] args)throws IOException{
        // 调用bfs方法计算最小步数
        bfs();
        // 初始化输入输出流
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

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

        // 处理每个测试用例
        while (T-- >0){
            // 读取一行输入并分割成字符串数组
            String[] str = br.readLine().trim().split("\\s+");
            // 将字符串数组转换为四个整数
            int a = Integer.parseInt(str[0]);
            int b = Integer.parseInt(str[1]);
            int c = Integer.parseInt(str[2]);
            int d = Integer.parseInt(str[3]);

            // 计算四个数字的最小步数之和
            int ans = dist[a]+dist[b]+dist[c]+dist[d];
            // 输出结果
            out.println(ans);
        }
        // 刷新并关闭输出流
        out.flush();
        out.close();
        // 关闭输入流
        br.close();
    }

    /**
     * 使用BFS算法计算从数字10到其他数字的最小步数
     * 可以进行的操作包括：+1, -1, +10, -10, +100, -100
     * 特殊情况：可以直接跳到数字10或300
     */
    private static void bfs(){
        // 初始化dist数组，-1表示未访问
        Arrays.fill(dist,-1);
        // 创建队列用于BFS遍历
        Queue<Integer> queue = new LinkedList<>();

        // 设置起点数字10的步数为0
        dist[10]=0;
        // 将起点加入队列
        queue.add(10);
        // 定义可能的操作数组
        int[] ops = {1,-1,10,-10,100,-100};

        // 当队列不为空时继续遍历
        while (!queue.isEmpty()){
            // 取出队首元素
            int u = queue.poll();

            // 创建邻居列表
            List<Integer> neighbors = new ArrayList<>();

            // 应用所有可能的操作生成邻居
            for(int op:ops){
                neighbors.add(u+op);
            }

            // 添加特殊邻居：10和300
            neighbors.add(10);
            neighbors.add(300);

            // 遍历所有邻居
            for(int v:neighbors){
                // 如果邻居在有效范围内且未被访问过
                if(v>=10&&v<=300&&dist[v]==-1){
                    // 更新步数
                    dist[v]=dist[u]+1;
                    // 将邻居加入队列
                    queue.add(v);
                }
            }
        }
    }

【回溯】BISHI83 迷宫问题

Sat, 28 Feb 2026 22:45:36 +0000

思路

求解代码

private static List<int[]> path = new ArrayList<>();

    /**
     * 主方法，处理输入输出并调用回溯算法
     *
     * @param args 命令行参数
     * @throws IOException 可能抛出的IO异常
     */
    public static void main(String[] args) throws IOException {
        // 创建输入输出缓冲流
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取第一行输入，分割并转换为高度h和宽度w
        String[] strA = br.readLine().trim().split("\\s+");

        // 解析网格的高度和宽度
        int h = Integer.parseInt(strA[0]);
        int w = Integer.parseInt(strA[1]);

        // 创建网格数组和访问标记数组
        int[][] grid = new int[h][w];
        boolean[][] visited = new boolean[h][w];

        // 读取网格数据
        for (int i = 0; i < h; i++) {
            // 读取一行输入并分割
            String[] str = br.readLine().trim().split("\\s+");
            // 填充网格数据
            for (int j = 0; j < w; j++) {
                grid[i][j] = Integer.parseInt(str[j]);
            }
        }

        // 从起点(0,0)开始回溯
        backtrack(grid, h, w, 0, 0, visited);

        // 输出路径
        for (int[] pos : path) {
            out.println("(" + pos[0] + "," + pos[1] + ")");
        }

        // 刷新并关闭输出流和输入流
        out.flush();
        out.close();
        br.close();

    }

    /**
     * 使用回溯算法在网格中寻找路径
     *
     * @return 如果找到从起点到终点的路径则返回true，否则返回false
     */
    private static boolean backtrack(int[][] grid, int h, int w, int i, int j, boolean[][] visted) {
        // 检查当前位置是否有效：是否在网格范围内、是否是障碍物、是否已经访问过
        if (i < 0 || i >= h || j < 0 || j >= w || grid[i][j] == 1 || visted[i][j]) {
            return false;
        }

        // 标记当前位置为已访问，并将当前位置添加到路径中
        visted[i][j] = true;
        path.add(new int[]{i, j});

        // 如果当前位置是终点，则返回true
        if (i == h - 1 && j == w - 1) {
            return true;
        }

        // 定义四个方向：上、下、左、右
        int[] dx = {-1, 1, 0, 0};
        int[] dy = {0, 0, -1, 1};

        // 尝试向四个方向移动
        for (int k = 0; k < 4; k++) {
            // 递归调用backtrack方法，如果找到路径则返回true
            if (backtrack(grid, h, w, i + dx[k], j + dy[k], visted)) {
                return true;
            }
        }

        // 如果四个方向都无法继续前进，则回溯：从路径中移除当前位置
        path.remove(path.size() - 1);
        return false;
    }

【BFS】BISHI82 没挡住洪水

Sat, 28 Feb 2026 21:17:35 +0000

思路

求解代码


    /**
     * 主方法：处理吴铭市地图数据并统计被完全淹没的区域数量
     *
     * 业务逻辑：
     * 1. 读取 N*N 的城市地图。
     * 2. 通过遍历寻找每一个独立的“空地区域”（由 '#' 组成的四连通块）。
     * 3. 对每个区域进行洪水上涨模拟判定。
     *
     * @param args 命令行参数
     * @throws IOException IO异常处理
     */
    public static void main(String[] args) throws IOException {
        // 使用高效流读取地图数据与输出结果
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取地图尺寸 N
        int N = Integer.parseInt(br.readLine().trim());
        // grid: 地图矩阵，'.' 为已淹没，'#' 为空地
        char[][] grid = new char[N][N];
        // visit: 标记当前空地是否已被抗灾委员会统计过
        boolean[][] visit = new boolean[N][N];

        // 加载吴铭市当前受灾地图
        for (int i = 0; i < N; i++) {
            grid[i] = br.readLine().trim().toCharArray();
        }

        // ans: 记录洪水上涨一天后，完全消失的空地区域总数
        int ans = 0;

        // 逐格扫描地图
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                // 发现一块新的且未统计过的空地区域
                if (grid[i][j] == '#' && !visit[i][j]) {
                    /**
                     * 执行 BFS 模拟：
                     * 若该区域内所有格子在明天都会被淹没（即 bfs 返回 false），
                     * 则该区域属于“完全淹没区域”，计数加一。
                     */
                    if (!bfs(grid, N, i, j, visit)) {
                        ans++;
                    }
                }
            }
        }

        // 输出统计结果并释放资源
        out.println(ans);
        out.flush();
        out.close();
        br.close();
    }

    /**
     * 使用广度优先搜索 (BFS) 判定一个空地区域在洪水上涨后是否能“存活”
     *
     * 判定核心：
     * 一个区域能存活，当且仅当该区域内【至少有一个】格子是安全的。
     * 安全格子的定义：其上下左右四个相邻方向全部都是空地 '#'，洪水无法直接上涨淹没它。
     *
     * @param grid  城市地图矩阵
     * @param N     地图尺寸
     * @param i     区域起始点行坐标
     * @param j     区域起始点列坐标
     * @param visit 访问标记数组
     * @return 如果该区域上涨后仍有残留（不完全消失）返回 true，否则返回 false
     */
    private static boolean bfs(char[][] grid, int N, int i, int j, boolean[][] visit) {
        Queue<int[]> queue = new LinkedList<>();
        // 将当前区域的起点加入队列并标记
        queue.add(new int[]{i, j});
        visit[i][j] = true;

        // areaSurvived: 标识整个区域是否能存活（只要有一个格子不被淹，即为 true）
        boolean areaSurvived = false;

        // 四联通方向向量
        int[] dx = {-1, 1, 0, 0};
        int[] dy = {0, 0, -1, 1};

        while (!queue.isEmpty()) {
            int[] cur = queue.poll();
            int x = cur[0];
            int y = cur[1];

            // flag: 检查当前格子 (x, y) 是否为“避风港”
            // 默认假设它是安全的（四周无洪水 '.'）
            boolean flag = true;

            // 扫描当前格子的四周
            for (int k = 0; k < 4; k++) {
                int nextX = x + dx[k];
                int nextY = y + dy[k];

                // 如果邻居越界或者是洪水 '.'，则当前格子明早会被淹没
                if (nextX < 0 || nextX >= N || nextY < 0 || nextY >= N || grid[nextX][nextY] == '.') {
                    flag = false;
                    break;
                }
            }

            // 如果发现当前格子四周都是空地，它将保证该区域不被完全淹没
            if (flag) {
                areaSurvived = true;
            }

            // 继续探索该区域的其他空地格子
            for (int k = 0; k < 4; k++) {
                int nextX = x + dx[k];
                int nextY = y + dy[k];

                // 确保在地图范围内，且是同一区域的未访问空地
                if (nextX >= 0 && nextX < N && nextY >= 0 && nextY < N && grid[nextX][nextY] == '#' && !visit[nextX][nextY]) {
                    visit[nextX][nextY] = true;
                    queue.add(new int[]{nextX, nextY});
                }
            }
        }

        // 返回该区域是否完全消失
        return areaSurvived;
    }

【BFS】BISHI81 剪纸游戏

Fri, 27 Feb 2026 21:15:34 +0000

思路

求解代码

/**
     * 主方法，用于读取输入数据并处理网格问题
     *
     * @param args 命令行参数
     * @throws IOException 可能抛出的IO异常
     */
    public static void main(String[] args) throws IOException {

        // 使用BufferedReader读取输入流
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        // 使用PrintWriter输出结果
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取第一行输入并分割成字符串数组
        String[] str = br.readLine().trim().split("\\s+");
        // 解析网格的行数n
        int n = Integer.parseInt(str[0]);
        // 解析网格的列数m
        int m = Integer.parseInt(str[1]);

        // 创建n行m列的字符网格
        char[][] grid = new char[n][m];

        // 逐行读取网格数据
        for (int i = 0; i < n; i++) {
            // 将每行字符串转换为字符数组存入网格
            grid[i] = br.readLine().toCharArray();
        }

        // 创建n行m列的访问标记数组，初始值都为false
        boolean[][] visit = new boolean[n][m];
        // 初始化答案计数器
        int ans = 0;

        // 遍历网格的每个单元格
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                // 如果当前单元格是'.'且未被访问过
                if (grid[i][j] == '.' && !visit[i][j]) {
                    // 使用BFS方法处理，如果返回true则增加答案计数
                    if (bfs(grid, n, m, i, j, visit)) {
                        ans++;
                    }

                }
            }
        }
        // 输出最终结果
        out.println(ans);
        // 刷新输出流
        out.flush();
        // 关闭输出流
        out.close();
        // 关闭输入流
        br.close();

    }


    /**
     * 使用广度优先搜索(BFS)算法遍历连通区域，并判断该连通区域是否为矩形
     *
     * @param grid  二维字符网格，其中'.'表示可走区域
     * @param n     网格的行数
     * @param m     网格的列数
     * @param i     起始点的行坐标
     * @param j     起始点的列坐标
     * @param visit 记录访问状态的二维数组
     * @return 如果连通区域是完整的矩形则返回true，否则返回false
     */
    private static boolean bfs(char[][] grid, int n, int m, int i, int j, boolean[][] visit) {
        // 使用队列进行BFS遍历
        Queue<int[]> queue = new LinkedList<>();
        queue.add(new int[]{i, j});
        visit[i][j] = true;  // 标记起始点为已访问

        // 记录连通区域的最小和最大x、y坐标
        int minX = i, maxX = i;
        int minY = j, maxY = j;

        // 记录连通区域中点的数量
        int count = 0;

        // 定义四个方向的偏移量：上、下、左、右
        int[] dx = {-1, 1, 0, 0};
        int[] dy = {0, 0, -1, 1};

        // BFS遍历连通区域
        while (!queue.isEmpty()) {
            int[] cur = queue.poll();  // 取出队列中的当前点
            int x = cur[0];
            int y = cur[1];

            count++;  // 增加连通区域点计数

            // 更新连通区域的边界
            minX = Math.min(minX, x);
            maxX = Math.max(maxX, x);
            minY = Math.min(minY, y);
            maxY = Math.max(maxY, y);

            // 遍历四个方向
            for (int k = 0; k < 4; k++) {
                int nextX = x + dx[k];
                int nextY = y + dy[k];

                if (nextX >= 0 && nextX < n && nextY >= 0 && nextY < m && grid[nextX][nextY] == '.' && !visit[nextX][nextY]) {
                    visit[nextX][nextY] = true;
                    queue.add(new int[]{nextX, nextY});
                }
            }

        }

        // 判断是否填满整个区域
        // 当count等于整个区域的格子数量时，返回true，表示已填满
        // 整个区域的格子数量计算公式为：(maxX-minX+1) * (maxY-minY+1)
        return count == (maxX - minX + 1) * (maxY - minY + 1);
    }

【BFS-方向数组】BISHI80 走迷宫-方向数组

Fri, 27 Feb 2026 20:18:34 +0000

思路

求解代码

 /**
     * 主方法，处理输入输出并调用BFS算法
     *
     * @param args 命令行参数
     * @throws IOException 可能抛出IO异常
     */
    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]);  // 列数

        // 读取第二行输入，分割成字符串数组并解析为起点和终点的坐标
        String[] strB = br.readLine().trim().split("\\s+");
        int xs = Integer.parseInt(strB[0]) - 1;  // 起点x坐标（转换为0-based索引）
        int ys = Integer.parseInt(strB[1]) - 1;  // 起点y坐标（转换为0-based索引）
        int xt = Integer.parseInt(strB[2]) - 1;  // 终点x坐标（转换为0-based索引）
        int yt = Integer.parseInt(strB[3]) - 1;  // 终点y坐标（转换为0-based索引）

        // 读取n行输入，构建二维字符数组grid表示地图
        char[][] grid = new char[n][m];
        for (int i = 0; i < n; i++) {
            grid[i] = br.readLine().trim().toCharArray();
        }


        // 调用BFS方法计算最短路径长度，并将结果输出
        out.println(bfs(grid, n, m, xs, ys, xt, yt));
        // 刷新输出流，确保所有内容都被写出
        out.flush();
        // 关闭输出流和输入流
        out.close();
        br.close();

    }

    /**
     * 使用广度优先搜索(BFS)算法计算从起点到终点的最短路径
     *
     * @param grid 二维字符数组，表示网格地图，'.'表示可走的路径
     * @param n    网格的行数
     * @param m    网格的列数
     * @param xs   起点的x坐标
     * @param ys   起点的y坐标
     * @param xt   终点的x坐标
     * @param yt   终点的y坐标
     * @return 从起点到终点的最短距离，如果无法到达则返回-1
     */
    private static int bfs(char[][] grid, int n, int m, int xs, int ys, int xt, int yt) {
        // 如果起点和终点相同，直接返回0
        if (xs == xt && ys == yt) {
            return 0;
        }

        // 初始化距离数组，-1表示未访问过
        int[][] distance = new int[n][m];
        for (int i = 0; i < n; i++) {
            Arrays.fill(distance[i], -1);
        }

        // 使用队列实现BFS，存储待访问的节点坐标
        Queue<int[]> queue = new LinkedList<>();
        queue.add(new int[]{xs, ys});
        distance[xs][ys] = 0;  // 起点到自身的距离为0

        // 定义四个方向的偏移量，分别表示上、下、左、右
        int[] dx = {-1, 1, 0, 0};
        int[] dy = {0, 0, -1, 1};

        // BFS遍历
        while (!queue.isEmpty()) {
            // 取出队列中的当前节点
            int[] cur = queue.poll();

            int x = cur[0];
            int y = cur[1];

            // 遍历四个方向
            for (int i = 0; i < 4; i++) {
                // 计算下一个节点的坐标
                int nextX = x + dx[i];
                int nextY = y + dy[i];

                // 检查下一个节点是否在网格范围内，且是可走的路径，且未被访问过
                if (nextX >= 0 && nextX < n && nextY >= 0 && nextY < m && grid[nextX][nextY] == '.' && distance[nextX][nextY] == -1) {
                    // 更新距离
                    distance[nextX][nextY] = distance[x][y] + 1;

                    // 如果到达终点，返回距离
                    if (nextX == xt && nextY == yt) {
                        return distance[nextX][nextY];
                    }

                    // 将下一个节点加入队列
                    queue.add(new int[]{nextX, nextY});
                }
            }
        }
        // 如果无法到达终点，返回-1
        return -1;
    }

BISHI79 取数游戏

Thu, 26 Feb 2026 21:45:07 +0000

思路

求解代码

private static int N, M;  // 网格的行数和列数
    private static int[][] grid;  // 存储网格数据的二维数组
    private static boolean[][] used;  // 标记网格位置是否被使用过的二维数组
    private static long ans;  // 存储最终答案的最大值

    /**
     * 主方法，程序的入口点
     *
     * @param args 命令行参数
     * @throws IOException 可能抛出IO异常
     */
    public static void main(String[] args) throws IOException {
        // 使用BufferedReader从标准输入读取数据
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        // 使用PrintWriter向标准输出写入数据
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));


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

        // 处理每个测试用例
        for (int i = 0; i < T; i++) {
            String[] str = br.readLine().split("\\s+");
            N = Integer.parseInt(str[0]);
            M = Integer.parseInt(str[1]);

            grid = new int[N][M];  // 初始化网格数组
            used = new boolean[N][M];  // 初始化使用标记数组
            ans = 0;  // 重置答案为0

            // 读取网格数据
            for (int j = 0; j < N; j++) {
                String[] gridStr = br.readLine().trim().split("\\s+");
                for (int k = 0; k < M; k++) {
                    grid[j][k] = Integer.parseInt(gridStr[k]);  // 将字符串转换为整数存入网格
                }
            }
            backtrack(0, 0);  // 从第一个位置开始回溯
            out.println(Math.max(ans, 0));  // 输出最大答案，至少为0
        }

        out.flush();  // 刷新输出缓冲区
        out.close();  // 关闭输出流
        br.close();  // 关闭输入流


    }


    /**
     * 回溯算法方法，用于在网格中寻找最大可能值
     *
     * @param index  当前处理的位置索引，从0到N*M-1
     * @param curAns 当前累计的答案值
     */
    private static void backtrack(int index, long curAns) {
        // 基本情况：如果已经处理完所有网格位置
        if (index == N * M) {
            // 更新最大答案值
            ans = Math.max(ans, curAns);
            return;
        }

        // 计算当前索引对应的行和列
        int row = index / M;  // 计算当前行号
        int col = index % M;  // 计算当前列号

        // 情况1：不选择当前网格位置，直接处理下一个位置
        backtrack(index + 1, curAns);

        // 情况2：如果当前位置可以安全选择
        if (isSafe(row, col)) {
            // 标记当前位置为已使用
            used[row][col] = true;
            // 选择当前位置，累加其值并处理下一个位置
            backtrack(index + 1, curAns + grid[row][col]);
            // 回溯：撤销当前位置的使用标记
            used[row][col] = false;
        }
    }

    /**
     * 检查指定位置是否安全，即其周围8个方向（包括自身）是否都没有被使用过
     *
     * @param row 当前行索引
     * @param col 当前列索引
     * @return 如果周围8个方向都没有被使用过，返回true；否则返回false
     */
    private static boolean isSafe(int row, int col) {
        // 遍历当前位置的周围8个方向（包括自身）
        for (int drow = -1; drow <= 1; drow++) {
            for (int dcol = -1; dcol <= 1; dcol++) {
                // 计算下一个位置的行索引
                int nextRow = row + drow;
                // 计算下一个位置的列索引
                int nextCol = col + dcol;

                // 检查下一个位置是否在有效范围内
                if (nextRow >= 0 && nextRow < N && nextCol >= 0 && nextCol < M) {
                    // 如果下一个位置已经被使用过，则返回false
                    if (used[nextRow][nextCol]) {
                        return false;
                    }
                }

            }
        }
        // 如果周围8个方向都没有被使用过，则返回true
        return true;
    }

BISHI78 全排列

Thu, 26 Feb 2026 20:32:41 +0000

思路

【回溯】没有重复项数字的全排列这个是核心代码模式的题解。现在这题是ACM模式的题解。

求解代码

/**
     * 主方法，程序的入口点
     *
     * @param args 命令行参数
     * @throws IOException 可能抛出IO异常
     */
    public static void main(String[] args) throws IOException {
        // 使用BufferedReader从标准输入读取数据
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        // 使用PrintWriter向标准输出写入数据
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取整数n，并去除可能的空白字符
        int n = Integer.parseInt(br.readLine().trim());

        // 初始化一个长度为n的数组，用于存储排列结果
        int[] track = new int[n];
        // 初始化一个长度为n+1的布尔数组，用于标记数字是否已被使用
        boolean[] used = new boolean[n + 1];

        // 调用回溯方法生成全排列
        backtrack(n, 0, track, used, out);
        // 刷新输出流，确保所有数据都被写出
        out.flush();
        // 关闭输出流
        out.close();
        // 关闭输入流
        br.close();


    }

    /**
     * 回溯法生成全排列
     *
     * @param n     排列的数字范围，1到n
     * @param depth 当前递归的深度，即已经确定的前几个数字的数量
     * @param track 当前排列的路径，存储已经确定的数字序列
     * @param used  标记数组，记录数字是否已经在当前排列中使用过
     * @param out   用于输出结果的打印流
     */
    private static void backtrack(int n, int depth, int[] track, boolean[] used, PrintWriter out) {
        // 如果当前深度等于n，说明已经生成了一个完整的排列
        if (depth == n) {
            // 输出当前排列
            for (int i = 0; i < n; i++) {
                // 如果是最后一个数字，直接输出，否则输出数字加空格
                out.print(track[i] + (i == n - 1 ? "" : " "));
            }
            // 换行，准备输出下一个排列
            out.println();
            // 返回上一层递归
            return;
        }

        // 遍历所有可能的数字
        for (int i = 1; i <= n; i++) {
            // 如果数字i还没有被使用过
            if (!used[i]) {
                // 标记数字i为已使用
                used[i] = true;
                // 将数字i放入当前深度的位置
                track[depth] = i;

                // 递归处理下一个位置
                backtrack(n, depth + 1, track, used, out);

                // 回溯，撤销选择，将数字i标记为未使用，以便尝试其他可能性
                used[i] = false;
            }
        }
    }

【DFS】BISHI77数水坑

Wed, 25 Feb 2026 22:45:37 +0000

思路

求解代码

 /**
     * 主方法，程序的入口点
     *
     * @param args 命令行参数
     * @throws IOException 可能抛出IO异常
     */
    public static void main(String[] args) throws IOException {
        // 使用BufferedReader读取标准输入，用于高效读取输入数据
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        // 使用PrintWriter输出结果，提供高效的输出功能
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取第一行输入，并按空白字符分割成字符串数组
        String[] strA = br.readLine().trim().split("\\s+");


        // 解析第一行输入中的两个整数，n和m
        int n = Integer.parseInt(strA[0]);  // 网格的行数
        int m = Integer.parseInt(strA[1]);  // 网格的列数

        // 创建字符串数组用于存储网格数据
        String[] grid = new String[n];
        // 创建二维字符数组，用于存储网格的字符表示
        char[][] gridStr = new char[n][m];

        // 读取网格数据
        for (int i = 0; i < n; i++) {
            grid[i] = br.readLine().trim();  // 读取一行并去除首尾空白
            gridStr[i] = grid[i].toCharArray();  // 将字符串转换为字符数组
        }

        int ans = 0;  // 用于记录找到的'W'的数量

        // 遍历网格中的每个元素
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                // 如果当前元素是'W'，则增加计数器并执行深度优先搜索
                if (gridStr[i][j] == 'W') {
                    ans++;  // 增加计数器
                    dfs(gridStr, i, j);  // 执行深度优先搜索，标记相邻的'W'
                }

            }
        }

        // 输出结果
        out.println(ans);

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

    /**
     * 深度优先搜索(DFS)方法，用于遍历网格中的连通区域
     *
     * @param grid 二维字符网格
     * @param i    当前处理的行坐标
     * @param j    当前处理的列坐标
     */
    private static void dfs(char[][] grid, int i, int j) {
        // 检查当前坐标是否超出网格边界
        if (i < 0 || j < 0 || i >= grid.length || j >= grid[0].length) {
            return;
        }

        // 如果当前格子是'.'，表示已经是访问过的格子，直接返回
        if (grid[i][j] == '.') {
            return;
        }

        // 将当前格子标记为已访问（用'.'表示）
        grid[i][j] = '.';

        // 遍历当前格子的8个相邻方向（包括对角线方向）
        for (int di = -1; di <= 1; di++) {
            for (int dj = -1; dj <= 1; dj++) {
                // 跳过当前格子本身
                if (di == 0 && dj == 0) {
                    continue;
                }
                // 递归处理相邻格子
                dfs(grid, i + di, j + dj);
            }
        }

    }

【DFS】BISHI76 迷宫寻路

Wed, 25 Feb 2026 21:45:53 +0000

思路

求解代码

private static String ans = "No";

    /**
     * 主方法，程序的入口点
     *
     * @param args 命令行参数
     * @throws IOException 可能抛出IO异常
     */
    public static void main(String[] args) throws IOException {
        // 使用BufferedReader读取标准输入，用于高效读取输入数据
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        // 使用PrintWriter输出结果，提供高效的输出功能
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取第一行输入，并按空白字符分割成字符串数组
        String[] strA = br.readLine().trim().split("\\s+");


        // 解析第一行输入中的两个整数，n和m
        int n = Integer.parseInt(strA[0]);  // 网格的行数
        int m = Integer.parseInt(strA[1]);  // 网格的列数

        // 创建字符串数组用于存储网格数据
        String[] grid = new String[n];
        // 创建二维字符数组，用于存储网格的字符表示
        char[][] gridStr = new char[n][m];

        // 读取网格数据
        for (int i = 0; i < n; i++) {
            grid[i] = br.readLine().trim();  // 读取一行并去除首尾空白
            gridStr[i] = grid[i].toCharArray();  // 将字符串转换为字符数组
        }

        // 从起点(0,0)开始深度优先搜索
        dfs(gridStr, 0, 0);
        // 输出结果
        out.println(ans);

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

    /**
     * 深度优先搜索（DFS）方法，用于在二维网格中寻找从起点到终点的路径
     *
     * @param grid 二维字符网格，包含可走的路径和障碍物
     * @param i    当前搜索的行索引
     * @param j    当前搜索的列索引
     */
    private static void dfs(char[][] grid, int i, int j) {
        // 检查当前坐标是否超出网格边界
        if (i < 0 || j < 0 || i >= grid.length || j >= grid[0].length) {
            return;
        }

        // 检查当前单元格是否是障碍物（已访问过的标记为'#'）
        if (grid[i][j] == '#') {
            return;
        }

        // 检查是否到达终点（右下角）
        if (i == grid.length - 1 && j == grid[0].length - 1) {
            ans = "Yes";  // 找到路径，设置答案为"Yes"
            return;
        }

        // 标记当前单元格为已访问（使用'#'作为标记）
        grid[i][j] = '#';
        // 向上搜索
        dfs(grid, i - 1, j);
        // 向下搜索
        dfs(grid, i + 1, j);
        // 向左搜索
        dfs(grid, i, j - 1);
        // 向右搜索
        dfs(grid, i, j + 1);
    }

BISHI75 阶幂

Tue, 24 Feb 2026 21:40:06 +0000

如果 $a^b \ge m$，返回 $(a^b \bmod m) + m$；否则直接返回 $a^b$。

思路

代码实现

 private static long MOD = 1000000007;  // 定义模数常量，用于取模运算
    private static List<Long> mList = new ArrayList<>();  // 存储欧拉函数值的列表

    /**
     * 主方法，处理输入输出并计算结果
     *
     * @param args 命令行参数
     * @throws IOException 可能抛出IO异常
     */
    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
        long n = Long.parseLong(br.readLine().trim());

        // 初始化tmp为MOD值，并添加到mList列表中
        long tmp = MOD;
        mList.add(tmp);

        // 计算欧拉函数值直到tmp为1，并将结果添加到mList中
        while (tmp > 1) {
            tmp = getPhi(tmp);
            mList.add(tmp);
        }

        // 调用solve方法计算结果并输出，取模MOD
        out.println(solve(n, 0) % MOD);


        // 清空输出缓冲区并关闭资源
        out.flush();
        out.close();
        br.close();
    }

    /**
     * 递归求解模幂运算的结果
     *
     * @param curN 当前处理的数字
     * @param idx  当前处理的mList中的索引位置
     * @return 返回模幂运算的结果
     */
    private static long solve(long curN, int idx) {
        // 获取当前索引对应的模数
        long m = mList.get(idx);
        // 如果模数为1，任何数对1取模结果都是1
        if (m == 1) {
            return 1;
        }

        // 如果当前数字为1，1的任何次幂都是1
        if (curN == 1) {
            return 1;
        }

        // 递归计算指数部分，curN-1和idx+1表示递归处理下一个数字和下一个模数
        long exp = solve(curN - 1, idx + 1);

        // 计算curN的exp次幂对m取模的结果
        return safePow(curN, exp, m);
    }

    /**
     * 安全的幂运算函数，计算 a^b mod m，并处理可能的溢出情况
     *
     * @param a 底数
     * @param b 指数
     * @param m 模数
     * @return 计算结果，如果发生溢出则返回结果加上模数后的值
     */
    private static long safePow(long a, long b, long m) {
        long res = 1;        // 初始化结果为1
        boolean overflow = false;  // 溢出标志，初始为false

        // 如果底数大于等于模数，进行取模操作，并标记可能溢出
        if (a >= m) {
            overflow = true;
            a %= m;
        }

        // 使用快速幂算法计算幂运算
        while (b > 0) {
            // 如果当前指数的二进制最低位为1（即指数为奇数）
            if ((b & 1) == 1) {
                res = res * a;   // 将当前底数乘入结果
                // 如果结果大于等于模数，进行取模操作，并标记可能溢出
                if (res >= m) {
                    overflow = true;
                    res %= m;
                }
            }

            b >>= 1;   // 指数右移一位，相当于除以2
            // 如果指数还有剩余位
            if (b > 0) {
                a = a * a;   // 底数平方
                // 如果平方后的底数大于等于模数，进行取模操作，并标记可能溢出
                if (a >= m) {
                    overflow = true;
                    a %= m;
                }
            }
        }
        // 根据溢出标志返回结果，如果溢出则加上模数
        return overflow ? (res + m) : res;
    }

    /**
     * 计算欧拉函数Phi(n)的值
     * 欧拉函数Phi(n)表示小于n的正整数中与n互质的数的个数
     *
     * @param n 需要计算欧拉函数的正整数
     * @return 返回n的欧拉函数值
     */
    private static long getPhi(long n) {
        long res = n;  // 初始化结果为n

        // 遍历2到sqrt(n)的所有整数
        for (long i = 2; i * i <= n; i++) {
            // 如果i是n的因数
            if (n % i == 0) {
                // 应用欧拉函数的公式：res = res * (1 - 1/p)
                res = res / i * (i - 1);
                // 去除n中所有的i因子
                while (n % i == 0) {
                    n /= i;
                }
            }
        }

        // 如果n大于1，说明n本身是一个质数
        if (n > 1) {
            res = res / n * (n - 1);
        }
        return res;
    }

BISHI74 【模板】非质模数下的乘法逆元

Tue, 24 Feb 2026 20:34:31 +0000

乘法逆元 $a^{-1} \equiv x \pmod m$ 等价于求解线性同余方程：

$ax \equiv 1 \pmod m \implies ax + my = 1$

根据裴蜀定理，该方程有解的充要条件是 $\gcd(a, m) = 1$。
扩展欧几里得算法可以在计算 $\gcd(a, m)$ 的同时，求出一组整数 $(x, y)$ 满足 $ax + my = \gcd(a, m)$。

思路

实现代码

    private static long x;
    private static long y;

    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));

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

        // 处理每个测试用例
        for (int i = 0; i < T; i++) {

            String[] str = br.readLine().split("\\s+");
            long a = Long.parseLong(str[0]);
            long m = Long.parseLong(str[1]);

            exgcd(a, m);
            long ans = (x % m + m) % m;
            out.println(ans);
        }

        // 清空输出缓冲区并关闭资源
        out.flush();
        out.close();
        br.close();
    }


    /**
     * 扩展欧几里得算法，用于求解形如 ax + by = gcd(a,b) 的方程
     * 同时返回最大公约数和x、y的值
     *
     * @param a 第一个参数
     * @param b 第二个参数
     * @return a和b的最大公约数
     */
    private static long exgcd(long a, long b) {

        // 当b为0时，递归结束，此时a就是最大公约数
        if (b == 0) {
            x = 1;    // x初始化为1
            y = 0;    // y初始化为0
            return a;
        }

        // 递归调用，计算b和a mod b的最大公约数
        long d = exgcd(b, a % b);
        // 通过递归结果更新x和y的值
        long tmp = x;
        x = y;
        y = tmp - (a / b) * y;

        // 返回最大公约数
        return d;
    }

BISHI73 【模板】欧拉函数计算Ⅰ ‖ 朴素求值：试除法

Mon, 23 Feb 2026 21:59:20 +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));

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

        // 处理每个测试用例
        for (int i = 0; i < T; i++) {
            long x = Long.parseLong(br.readLine().trim());
            out.println(euler(x));  // 输出当前测试用例的结果
        }

        // 清空输出缓冲区并关闭资源
        out.flush();
        out.close();
        br.close();
    }


    /**
     * 使用欧拉函数计算小于等于x的正整数中与x互质的数的个数
     * 欧拉函数公式：φ(n) = n * (1 - 1/p1) * (1 - 1/p2) * ... * (1 - 1/pk)
     * 其中p1, p2, ..., pk是n的质因数
     *
     * @param x 需要计算欧拉函数的正整数
     * @return 小于等于x的正整数中与x互质的数的个数
     */
    private static long euler(long x) {
        // 如果x为1，直接返回1，因为1与1互质
        if (x == 1) {
            return 1;
        }
        // 初始化结果为x
        long res = x;
        // 遍历从2到√x的所有数，寻找x的质因数
        for (long i = 2; i * i <= x; i++) {
            // 如果i是x的因数
            if (x % i == 0) {
                // 应用欧拉函数公式，乘以(1-1/i)
                res = res / i * (i - 1);

                // 去除x中所有的i因子
                while (x % i == 0) {
                    x /= i;
                }
            }
        }
        // 如果x大于1，说明x本身是一个质数，应用欧拉函数公式
        if (x > 1) {
            res = res / x * (x - 1);
        }

        return res;
    }

BISHI72 中位数之和

Mon, 23 Feb 2026 21:10:27 +0000

由于数组 $a$ 仅包含 $0$ 和 $1$，对于长度为奇数 $k$ 的子序列，其中位数是 $1$ 的充要条件是：子序列中 $1$ 的个数不少于 $\frac{k+1}{2}$。

因此，求“中位数之和”等价于求“中位数为 $1$的子序列个数”。

思路

代码实现

   // 定义模数常量，用于所有取模运算
    private static final int MOD = 1000000007;
    // 定义最大计算范围常量
    private static final int MAX_N = 1000001;
    // 存储阶乘值的数组
    private static long[] fact = new long[MAX_N];
    // 存储阶乘逆元的数组
    private static long[] invFact = new long[MAX_N];


    /**
     * 主方法，处理输入输出并计算组合数学问题
     *
     * @param args 命令行参数
     * @throws IOException 可能抛出的IO异常
     */
    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));

        // 预计算阶乘和逆元，为后续计算做准备
        precompute();

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

        // 处理每个测试用例
        for (int i = 0; i < T; i++) {
            // 读取每行输入并分割，获取n和k的值
            String[] str = br.readLine().split("\\s+");
            int n = Integer.parseInt(str[0]);  // 总数
            int k = Integer.parseInt(str[1]);  // 选择数

            // 统计输入中"1"的数量
            int c1 = 0;
            String[] strA = br.readLine().split("\\s+");
            for (int j = 0; j < n; j++) {
                if (strA[j].equals("1")) {
                    c1++;  // 统计"1"的个数
                }
            }
            int c0 = n - c1;  // 计算"0"的个数

            // 计算至少需要选择的"1"的数量
            int m = (k + 1) / 2;
            long ans = 0;
            // 遍历所有可能的"1"的选择数量
            for (int j = m; j <= Math.min(k, c1); j++) {
                // 检查剩余的选择数是否不超过"0"的数量
                if (k - j <= c0) {
                    // 计算组合数并累加结果
                    long res = (nCr(c1, j) * nCr(c0, k - j)) % MOD;
                    ans = (ans + res) % MOD;
                }
            }
            out.println(ans);  // 输出当前测试用例的结果
        }

        // 清空输出缓冲区并关闭资源
        out.flush();
        out.close();
        br.close();
    }

    /**
     * 使用快速幂算法计算base的exp次方对MOD取模的结果
     * 快速幂算法是一种高效计算幂运算的算法，时间复杂度为O(log n)
     *
     * @param base 底数
     * @param exp  指数
     * @return base的exp次方对MOD取模的结果
     */
    private static long mypower(long base, long exp) {

        // 初始化结果为1对MOD取模，防止MOD为1时结果错误
        long ans = 1 % MOD;
        // 当指数exp大于0时继续循环
        while (exp > 0) {

            // 如果当前指数是奇数，将base乘入结果
            if (exp % 2 == 1) {
                ans = (ans * base) % MOD;
            }

            // base平方，指数减半
            base = (base * base) % MOD;
            exp /= 2;
        }

        // 返回最终结果
        return ans;
    }

    /**
     * 预计算阶乘和阶乘的逆元数组
     * 使用动态规划方法计算阶乘数组fact[]
     * 使用费马小定理计算逆元数组invFact[]
     */
    private static void precompute() {
        // 初始化0的阶乘和0的阶乘逆元为1
        fact[0] = 1;
        invFact[0] = 1;
        // 动态规划计算阶乘数组
        for (int i = 1; i < MAX_N; i++) {
            fact[i] = (fact[i - 1] * i) % MOD;
        }

        // 使用费马小定理计算最大阶乘的逆元
        invFact[MAX_N - 1] = mypower(fact[MAX_N - 1], MOD - 2);

        // 逆向递推计算其他阶乘的逆元
        for (int i = MAX_N - 2; i >= 1; i--) {
            invFact[i] = (invFact[i + 1] * (i + 1)) % MOD;
        }
    }

    /**
     * 计算组合数 nCr，即从n个物品中选取r个物品的组合数
     * 使用预计算阶乘和阶乘逆元的方法来高效计算组合数
     *
     * @param n 总物品数
     * @param r 选取物品数
     * @return 组合数结果，对MOD取模
     */
    private static long nCr(int n, int r) {
        // 如果r小于0或大于n，组合数为0
        if (r < 0 || r > n) {
            return 0;
        }

        // 使用公式 nCr = n! / (r! * (n-r)!) 计算
        // 通过预计算的阶乘数组fact和阶乘逆元数组invFact来计算
        // 并对MOD取模，防止数值溢出
        return (((fact[n] * invFact[r]) % MOD) * invFact[n - r]) % MOD;
    }

BISHI71 人员分组问题

Sun, 22 Feb 2026 23:25:15 +0000

思路

这题就是个组合问题，本质上是求C(n,5)+C(n,6)+C(n,7)的问题。

求解代码

// 定义模数常量，用于所有取模运算
    private static final int MOD = 1000000007;
    // 定义最大计算范围常量
    private static final int MAX_N = 1000001;
    // 存储阶乘值的数组
    private static long[] fact = new long[MAX_N];
    // 存储阶乘逆元的数组
    private static long[] invFact = new long[MAX_N];


    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));

        // 预计算阶乘和逆元
        precompute();

        int n = Integer.parseInt(br.readLine().trim());
        long ans = (nCr(n, 5) + nCr(n, 6) + nCr(n, 7))%MOD;
        out.println(ans);

        // 清空输出缓冲区并关闭资源
        out.flush();
        out.close();
        br.close();
    }

    /**
     * 使用快速幂算法计算base的exp次方对MOD取模的结果
     * 快速幂算法是一种高效计算幂运算的算法，时间复杂度为O(log n)
     *
     * @param base 底数
     * @param exp  指数
     * @return base的exp次方对MOD取模的结果
     */
    private static long mypower(long base, long exp) {

        // 初始化结果为1对MOD取模，防止MOD为1时结果错误
        long ans = 1 % MOD;
        // 当指数exp大于0时继续循环
        while (exp > 0) {

            // 如果当前指数是奇数，将base乘入结果
            if (exp % 2 == 1) {
                ans = (ans * base) % MOD;
            }

            // base平方，指数减半
            base = (base * base) % MOD;
            exp /= 2;
        }

        // 返回最终结果
        return ans;
    }

    /**
     * 预计算阶乘和阶乘的逆元数组
     * 使用动态规划方法计算阶乘数组fact[]
     * 使用费马小定理计算逆元数组invFact[]
     */
    private static void precompute() {
        // 初始化0的阶乘和0的阶乘逆元为1
        fact[0] = 1;
        invFact[0] = 1;
        // 动态规划计算阶乘数组
        for (int i = 1; i < MAX_N; i++) {
            fact[i] = (fact[i - 1] * i) % MOD;
        }

        // 使用费马小定理计算最大阶乘的逆元
        invFact[MAX_N - 1] = mypower(fact[MAX_N - 1], MOD - 2);

        // 逆向递推计算其他阶乘的逆元
        for (int i = MAX_N - 2; i >= 1; i--) {
            invFact[i] = (invFact[i + 1] * (i + 1)) % MOD;
        }
    }

    /**
     * 计算组合数 nCr，即从n个物品中选取r个物品的组合数
     * 使用预计算阶乘和阶乘逆元的方法来高效计算组合数
     *
     * @param n 总物品数
     * @param r 选取物品数
     * @return 组合数结果，对MOD取模
     */
    private static long nCr(int n, int r) {
        // 如果r小于0或大于n，组合数为0
        if (r < 0 || r > n) {
            return 0;
        }

        // 使用公式 nCr = n! / (r! * (n-r)!) 计算
        // 通过预计算的阶乘数组fact和阶乘逆元数组invFact来计算
        // 并对MOD取模，防止数值溢出
        return (((fact[n] * invFact[r]) % MOD) * invFact[n - r]) % MOD;
    }

BISHI70 【模板】组合数

Sun, 22 Feb 2026 21:40:22 +0000

思路

求解代码

// 定义模数常量，用于所有取模运算
    private static final int MOD = 1000000007;
    // 定义最大计算范围常量
    private static final int MAX_N = 500001;
    // 存储阶乘值的数组
    private static long[] fact = new long[MAX_N];
    // 存储阶乘逆元的数组
    private static long[] invFact = new long[MAX_N];

    /**
     * 主方法
     * 处理输入输出，调用预计算和组合数计算方法
     * @param args 命令行参数
     * @throws IOException 可能抛出的IO异常
     */
    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));

        // 预计算阶乘和逆元
        precompute();
        // 读取测试用例数量
        int T = Integer.parseInt(br.readLine().trim());

        // 处理每个测试用例
        for (int i = 0; i < T; i++) {
            // 读取每行输入并分割
            String[] str = br.readLine().split("\\s+");
            int n = Integer.parseInt(str[0]);
            int m = Integer.parseInt(str[1]);

            // 输出组合数计算结果
            out.println(nCr(m, n));
        }

        // 清空输出缓冲区并关闭资源
        out.flush();
        out.close();
        br.close();
    }

    /**
     * 使用快速幂算法计算base的exp次方对MOD取模的结果
     * 快速幂算法是一种高效计算幂运算的算法，时间复杂度为O(log n)
     *
     * @param base 底数
     * @param exp  指数
     * @return base的exp次方对MOD取模的结果
     */
    private static long mypower(long base, long exp) {

        // 初始化结果为1对MOD取模，防止MOD为1时结果错误
        long ans = 1 % MOD;
        // 当指数exp大于0时继续循环
        while (exp > 0) {

            // 如果当前指数是奇数，将base乘入结果
            if (exp % 2 == 1) {
                ans = (ans * base) % MOD;
            }

            // base平方，指数减半
            base = (base * base) % MOD;
            exp /= 2;
        }

        // 返回最终结果
        return ans;
    }

    /**
     * 预计算阶乘和阶乘的逆元数组
     * 使用动态规划方法计算阶乘数组fact[]
     * 使用费马小定理计算逆元数组invFact[]
     */
    private static void precompute() {
        // 初始化0的阶乘和0的阶乘逆元为1
        fact[0] = 1;
        invFact[0] = 1;
        // 动态规划计算阶乘数组
        for (int i = 1; i < MAX_N; i++) {
            fact[i] = (fact[i - 1] * i) % MOD;
        }

        // 使用费马小定理计算最大阶乘的逆元
        invFact[MAX_N - 1] = mypower(fact[MAX_N - 1], MOD - 2);

        // 逆向递推计算其他阶乘的逆元
        for (int i = MAX_N - 2; i >= 1; i--) {
            invFact[i] = (invFact[i + 1] * (i + 1)) % MOD;
        }
    }

    /**
     * 计算组合数 nCr，即从n个物品中选取r个物品的组合数
     * 使用预计算阶乘和阶乘逆元的方法来高效计算组合数
     *
     * @param n 总物品数
     * @param r 选取物品数
     * @return 组合数结果，对MOD取模
     */
    private static long nCr(int n, int r) {
        // 如果r小于0或大于n，组合数为0
        if (r < 0 || r > n) {
            return 0;
        }

        // 使用公式 nCr = n! / (r! * (n-r)!) 计算
        // 通过预计算的阶乘数组fact和阶乘逆元数组invFact来计算
        // 并对MOD取模，防止数值溢出
        return (((fact[n] * invFact[r]) % MOD) * invFact[n - r]) % MOD;
    }

BISHI69 [HNOI2008]越狱

Sun, 22 Feb 2026 00:00:54 +0000

这个问题可以通过计算“总方案数”减去“不越狱方案数”来得出结果。

总分配方案数：每个房间有 $M$ 种宗教选择，共有 $N$ 个房间。总数 = $M \times M \times \dots \times M = M^N$。

不越狱方案数: 第 1 个房间有 $M$ 种选择；第 2 个房间为了不与第 1 个重复，有 $M-1$ 种选择；第 3 个房间为了不与第 2 个重复，有 $M-1$ 种选择；以此类推，剩下的 $N-1$ 个房间每个都有 $M-1$ 种选择。不越狱总数 = $M \times (M-1)^{N-1}$。

可能发生越狱的方案数：越狱方案 = 总方案数 - 不越狱方案数 结果 = $M^N - M \times (M-1)^{N-1}$

流程图

代码实现

 private static final long MOD = 100003L;

    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));

        String[] str = br.readLine().split("\\s+");
        long M = Long.parseLong(str[0]);
        long N = Long.parseLong(str[1]);
        long total = mypower(M, N, MOD);
        long safe = M * mypower(M - 1, N - 1, MOD)%MOD;
        long ans = (total-safe+MOD)%MOD;

        out.println(ans);

        out.flush();
        out.close();
        br.close();
    }

    private static long mypower(long base, long exp, long mod) {

        long ans = 1 % mod;
        while (exp > 0) {

            if (exp % 2 == 1) {
                ans = (ans * base) % mod;
            }

            base = (base * base) % mod;
            exp /= 2;
        }

        return ans;
    }

BISHI68 刷题统计

Sat, 21 Feb 2026 23:32:54 +0000

这是一个经典的容斥原理应用题。

设三个集合分别为 $A$（新手）、$B$（算法入门）、$C$（算法进阶）。

已知 $n = |A \cup B \cup C|$ （至少刷过一个的总人数） $a = |A|, b = |B|, c = |C|$ （各题单人数） $d$: 恰好刷过两个题单的人数。设 $x$: 同时刷过三个题单的人数（我们要找的解）。

根据容斥原理：
$$|A \cup B \cup C| = |A| + |B| + |C| - (|A \cap B| + |A \cap C| + |B \cap C|) + |A \cap B \cap C|$$
其中，任意两个集合的交集（如 $|A \cap B|$）包含了“恰好刷过两个”的人和“刷过全部三个”的人。因此：$|A \cap B| + |A \cap C| + |B \cap C| = d + 3x$（因为 $x$ 这部分人在三个两两交集中各被算了一次）。

代入公式：
$$n = a + b + c - (d + 3x) + x$$

$$n = a + b + c - d - 2x$$
得出 $x$：
$$2x = a + b + c - n - d$$

$$x = \frac{a + b + c - n - d}{2}$$

流程图

代码实现

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));

        int T = Integer.parseInt(br.readLine().trim());

        for (int i = 0; i < T; i++) {
            String[] str = br.readLine().split("\\s+");
            long n = Long.parseLong(str[0]);
            long a = Long.parseLong(str[1]);
            long b = Long.parseLong(str[2]);
            long c = Long.parseLong(str[3]);
            long d = Long.parseLong(str[4]);
            long ans = (a+b+c-n-d)/2;

            out.println(ans);
        }

        out.flush();
        out.close();
        br.close();
    }

BISHI67 穿搭大挑战

Sat, 21 Feb 2026 23:03:31 +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));

        int T = Integer.parseInt(br.readLine().trim());

        for (int i = 0; i < T; i++) {
            String[] str = br.readLine().split("\\s+");
            long a = Long.parseLong(str[0]);
            long b = Long.parseLong(str[1]);
            long c = Long.parseLong(str[2]);
            long ans = a*b+a*c+b*c;

            out.println(ans);
        }

        out.flush();
        out.close();
        br.close();
    }

BISHI66 子数列求积

Sat, 21 Feb 2026 22:12:44 +0000

思路

求解代码

private static final int MOD = 1000000007;

    /**
     * 主函数，处理输入输出并计算区间乘积
     *
     * @param args 命令行参数
     * @throws IOException 可能抛出IO异常
     */
    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和q
        String[] str = br.readLine().trim().split("\\s+");
        int n = Integer.parseInt(str[0]);  // 数组长度
        int q = Integer.parseInt(str[1]);  // 查询次数


        // 创建前缀积数组，大小为n+1
        long[] preProduct = new long[n + 1];
        preProduct[0] = 1;  // 初始化前缀积的第一个元素为1
        // 读取数组元素并计算前缀积
        String[] numStr = br.readLine().trim().split("\\s+");
        for (int i = 1; i <= n; i++) {
            long val = Long.parseLong(numStr[i - 1]);  // 解析当前元素
            // 计算前缀积，并对MOD取模
            preProduct[i] = (preProduct[i - 1] * val) % MOD;
        }

        // 创建结果列表
        List<Long> res = new ArrayList<>();
        // 处理每个查询
        for (int i = 0; i < q; i++) {
            // 读取查询区间
            String[] strQ = br.readLine().split("\\s+");
            int l = Integer.parseInt(strQ[0]);  // 区间左端点
            int r = Integer.parseInt(strQ[1]);  // 区间右端点

            // 计算preProduct[l-1]的模逆元
            long invPreProduct = mypower(preProduct[l - 1], MOD - 2, MOD);
            // 计算区间[l,r]的乘积
            long ans = (preProduct[r] * invPreProduct) % MOD;
            res.add(ans);  // 将结果添加到列表中
        }

        // 使用StringBuilder构建输出字符串
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < res.size(); i++) {
            // 每个结果用空格分隔，最后一个结果后不加空格
            sb.append(res.get(i)).append(res.size() == n - 1 ? "" : " ");
        }


        // 输出结果并关闭流
        out.println(sb.toString());
        out.flush();
        out.close();
        br.close();
    }

    private static long mypower(long base, long exp, long mod) {

        long ans = 1 % mod;
        while (exp > 0) {

            if (exp % 2 == 1) {
                ans = (ans * base) % mod;
            }

            base = (base * base) % mod;
            exp /= 2;
        }

        return ans;
    }

BISHI65 【模板】分数取模

Sat, 21 Feb 2026 00:37:41 +0000

思路

求解代码

private static final int MOD = 1000000007;
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        int t = Integer.parseInt(br.readLine().trim());

        for (int i = 0; i < t; i++) {
            String[] str = br.readLine().split("\\s+");
            long a = Long.parseLong(str[0]);
            long b = Long.parseLong(str[1]);

            long bInv= mypower(b, MOD-2, MOD);
            long ans = (a%MOD+MOD)%MOD;
            ans = (ans*bInv)%MOD;

            out.println(ans);
        }

        out.flush();
        out.close();
        br.close();
    }

    private static long mypower(long base, long exp, long mod) {

        long ans = 1 % mod;
        while (exp > 0) {

            if (exp % 2 == 1) {
                ans = (ans * base) % mod;
            }

            base = (base * base) % mod;
            exp /= 2;
        }

        return ans;
    }

BISHI64 【模板】快速幂Ⅰ ‖ 模小整数

Fri, 20 Feb 2026 22:22:19 +0000

思路

求解代码

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        int T = Integer.parseInt(br.readLine().trim());

        for (int i = 0; i < T; i++) {
            String[] str = br.readLine().split("\\s+");
            long a = Long.parseLong(str[0]);
            long b = Long.parseLong(str[1]);
            long m = Long.parseLong(str[2]);

            out.println(mypower(a, b, m));
        }

        out.flush();
        out.close();
        br.close();
    }

    private static long mypower(long base, long exp, long mod) {

        long ans = 1 % mod;
        while (exp > 0) {

            if (exp % 2 == 1) {
                ans = (ans * base) % mod;
            }

            base = (base * base) % mod;
            exp /= 2;
        }

        return ans;
    }

BISHI63 计算阶乘

Thu, 19 Feb 2026 22:24:36 +0000

思路

求解代码

private static final int MOD = 1000000007;
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        int T = Integer.parseInt(br.readLine().trim());

        while (T-- > 0) {
            int n = Integer.parseInt(br.readLine().trim());

            long ans = 1;

            for(int i=1;i<=n;i++){
                ans = (ans*i)%MOD;
            }
            out.println(ans%MOD);
        }

        out.flush();
        out.close();
        br.close();
    }

BISHI61 小q的数列

Thu, 19 Feb 2026 21:23:17 +0000

思路

这道题本质上是要计算一个数字在二进制下“1”的个数，然后构造出另一个具有相同数量“1”但取值最小的数字。

求解代码

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        int T = Integer.parseInt(br.readLine().trim());

        while (T-- > 0) {
            String str = br.readLine();
            long n = Long.parseLong(str.trim());

            int c = Long.bitCount(n);
            long k = (1L << c) - 1;
            out.println(c + " " + k);
        }

        out.flush();
        out.close();
        br.close();
    }

BISHI59 阶乘末尾非零数字

Wed, 18 Feb 2026 21:33:04 +0000

思路

求解代码

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StreamTokenizer in = new StreamTokenizer(br);
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        in.nextToken();
        int n = (int)in.nval;

        out.println(find(n));
        out.flush();
        out.close();
        br.close();
    }

    private static int find(int n) {

        int n2 = 0, n5 = 0;
        int p = 1;

        for(int i=2;i<=n;i++){
            int tmp = i;
            while (tmp%5==0) {
                n5++;
                tmp/=5;
            }

            while (tmp%2==0) {
                n2++;
                tmp/=2;
            }

            p=(p*tmp)%10;
        }

        for(int i=0;i<n2-n5;i++){
            p=(p*2)%10;
        }
        return p;
    }

BISHI58 矩形游戏

Wed, 18 Feb 2026 20:38:20 +0000

思路

求解代码

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StreamTokenizer in = new StreamTokenizer(br);
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        in.nextToken();
        int n = (int)in.nval;

        long res = n;

        while (true) {
            int a = find(n);
            n/=a;
            if(n==1){
                res+=1;
                break;
            }else{
                res+=n;
            }
        }

        out.println(res);
        out.flush();
        out.close();
        br.close();
    }

    private static int find(int a) {

        if(a%2==0){
            return 2;
        }

        for(int i=3;i*i<=a;i++){
            if(a%i==0){
                return i;
            }
        }
        return a;
    }

BISHI57 最大公因数与最小公倍数

Tue, 17 Feb 2026 21:06:10 +0000

###思路

求解代码

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        String[] str = br.readLine().trim().split("\\s+");
        Long a = Long.parseLong(str[0]);
        Long b = Long.parseLong(str[1]);

        long g = gcd(a,b);

        long l = (a==0||b==0)?0:(a/g)*b;

        out.println(g+" "+l);
        out.flush();
        out.close();
        br.close();
    }

    private static long gcd(long a, long b) {

        while (b != 0) {
            long tmp = b;
            b = a%b;
            a=tmp;
        }
        return a;
    }

BISHI56 分解质因数

Tue, 17 Feb 2026 20:24:50 +0000

思路

求解代码

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        Long n = Long.parseLong(br.readLine().trim());

        for (long i = 2; i * i <= n; i++) {
            while (n % i == 0) {
                out.print(i+" ");
                n/=i;
            }
        }
        if(n>1){
            out.print(n+" ");
        }

        out.flush();
        out.close();
        br.close();
    }

小贴士

后面那个if语句主要是处理分解后剩余的、大于√n 的质因数。

如果不加这个判断，会导致部分质数或大质因数无法被输出，最终分解结果不完整。

因为代码中外层循环的终止条件是 i * i <= n，只检查到√n，

如果一个数 n 能被分解为 a × b（a ≤ b），则 a 必然 ≤ √n，b 必然 ≥ √n。

因此只需检查到√n，就能找到所有小质因数，剩余的未分解部分要么是 1，要么是一个大于√n 的质数。

BISHI55 判断质数

Tue, 17 Feb 2026 19:48:07 +0000

思路

求解代码

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        Long n = Long.parseLong(br.readLine().trim());

        if (isPrime(n)) {
            out.println("Yes");
        } else {
            out.println("No");
        }

        out.flush();
        out.close();
        br.close();
    }

    private static boolean isPrime(long n) {
        if (n == 1) {
            return false;
        }

        for (long i = 2; i * i <= n; i++) {
            if (n % i == 0) {
                return false;
            }
        }
        return true;
    }

BISHI54货物堆放

Mon, 16 Feb 2026 22:00:34 +0000

流程图

求解代码

static class Goods{
        long w;
        long v;
        long c;

        Goods(long w,long v,long c){
            this.w = w;
            this.v = v;
            this.c = c;
        }
    }


    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        int n = Integer.parseInt(br.readLine().trim());

        Goods[] goods = new Goods[n];
        long total = 0;
        for(int i=0;i<n;i++){
            String[] str = br.readLine().trim().split("\\s+");
            long w = Long.parseLong(str[0]);
            long v = Long.parseLong(str[1]);
            long c = Long.parseLong(str[2]);

            goods[i]=new Goods(w, v,c);
            total += v;
        }

        Arrays.sort(goods,(x,y)->Long.compare(x.c*y.w, y.c*x.w));

       // 总实际体积 = 初始体积总和 - sumCW，因此最大化sumCW是实现最小体积的关键
        long sumCW = 0;
        // 记录当前遍历商品的「上方总重量」，初始为0（第一个商品在最顶部，上方无重量）
        long upperWeight = 0;

        // 按"从上到下"的堆叠顺序遍历排序后的商品
        for (Goods g : goods) {
            // 计算当前商品的压缩贡献值：c_i × 上方总重量（W_i）
            // 这里必须先计算贡献，再更新上方重量（避免把当前商品算入自己的上方）
            sumCW += g.c * upperWeight;

            // 更新上方总重量：当前商品会成为后续商品的"上方重量"，需累加其重量
            upperWeight += g.w;
        }

        long res = total -sumCW;

        out.println(res);
        out.flush();
        out.close();
        br.close();
    }

BISHI53 [P1080] 国王游戏(简化版)

Mon, 16 Feb 2026 20:53:12 +0000

流程图

求解代码

static class Minister{
        long a;
        long b;

        Minister(long a,long b){
            this.a = a;
            this.b = b;
        }
    }


    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        int n = Integer.parseInt(br.readLine().trim());

        String[] str = br.readLine().trim().split("\\s+");

        long a0 = Long.parseLong(str[0]);

        Minister[] ministers = new Minister[n];
        for(int i=0;i<n;i++){
            String[] ministerStr = br.readLine().trim().split("\\s+");
            long a = Long.parseLong(ministerStr[0]);
            long b = Long.parseLong(ministerStr[1]);

            ministers[i]=new Minister(a, b);

        }

        Arrays.sort(ministers,(x,y)->Long.compare(x.a*x.b, y.a*y.b));

        // 计算最大金币数
        long maxCoin = 0;
        long productA = a0; // 前序左手数的乘积（初始为国王的a0）
        for (Minister m : ministers) {
            // 当前大臣的金币数 = 前序乘积 / 当前b
            long coin = productA / m.b;
            // 更新最大金币数
            if (coin > maxCoin) {
                maxCoin = coin;
            }
            // 前序乘积 *= 当前大臣的a
            productA *= m.a;
        }

        out.println(maxCoin);
        out.flush();
        out.close();
        br.close();
    }

BISHI51 低买高卖

Sun, 15 Feb 2026 20:24:29 +0000

思路

求解代码

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        int n = Integer.parseInt(br.readLine());

        String[] str = br.readLine().split("\\s+");

        long[] p = new long[n];

        for (int i = 0; i < n; i++) {
            p[i] = Long.parseLong(str[i]);
        }
        PriorityQueue<Long> minHeap = new PriorityQueue<>(); // 小顶堆：堆顶始终是当前堆中最小值
        long profit = 0; // 初始化总利润为0

        for (int i = 0; i < n; i++) {
            minHeap.add(p[i]); // 将当前价格加入堆
            if (minHeap.peek() < p[i]) { // 如果堆顶（当前最低价格）< 当前价格 → 可以低买高卖
                long buy = minHeap.poll(); // 取出堆顶（买入价）
                profit += p[i] - buy; // 累加本次利润（当前价-买入价）
                minHeap.add(p[i]); // 把当前价格重新入堆（相当于“卖出后再以当前价买入”，继续后续交易）
            }
        }
        out.println(profit);
        out.flush();
        out.close();
        br.close();

    }

BISHI50 [JSOI2007]建筑抢修

Sun, 15 Feb 2026 00:47:10 +0000

思路

求解代码

 public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        int n = Integer.parseInt(br.readLine());
        // 存储每个建筑的维修耗时t和报废时限d
        int[][] buildings = new int[n][2];

        for (int i = 0; i < n; i++) {
            String[] numStr = br.readLine().split("\\s+");
            buildings[i][0] = Integer.parseInt(numStr[0]);
            buildings[i][1] = Integer.parseInt(numStr[1]);
        }
        // 按报废时限d_i升序排序（优先处理时限早的）
        Arrays.sort(buildings, (a, b) -> a[1] - b[1]);

        // 初始化最大堆（存储已选建筑的耗时，优先弹出最大值）
        PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Collections.reverseOrder());
        long total = 0; // 当前累计维修时间

        for (int[] b : buildings) {

            int t = b[0];
            int d = b[1];
            // 加入当前建筑，累计时间
            maxHeap.add(t);
            total += t;
            // 若累计时间超过当前建筑的时限，移除耗时最长的建筑
            if (total > d) {
                int removeT = maxHeap.poll();
                total -= removeT;
            }

        }
        // 堆的大小即为最多可维修的建筑数量
        out.println(maxHeap.size());

        out.flush();
        out.close();
        br.close();
    }

BISHI49 小红闯关

Sun, 15 Feb 2026 00:11:29 +0000

思路

求解代码

 public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
        String[] str = br.readLine().split("\\s+");
        int n = Integer.parseInt(str[0]);
        int k = Integer.parseInt(str[1]);

        String[] numStr = br.readLine().split("\\s+");
        long[] a = new long[n];
        long total = 0;

        for (int i = 0; i < n; i++) {
            a[i] = Long.parseLong(numStr[i]);
            total += a[i];// 累加总耗时
        }
        // 初始化最大堆（优先队列），用于存储可跳过的关卡耗时（优先弹出最大值）
        // PriorityQueue默认是最小堆，Collections.reverseOrder()转为最大堆
        PriorityQueue<Long> maxHeap = new PriorityQueue<>(Collections.reverseOrder());
        long saveTime = 0;

        for (int i = n - 1; i >= 0; i--) {
            // (i+1)表示"已通过前i+1个关卡"（按顺序），满足每k个关卡则获得1个道具
            // 0-based索引转1-based计数，确保规则匹配
            if ((i + 1) % k == 0 && !maxHeap.isEmpty()) {
                // 获得道具，跳过堆中耗时最大的关卡，累加跳过的耗时
                saveTime += maxHeap.poll();
            }
            // 最小总耗时 = 全通关耗时 - 跳过的最大耗时之和
            maxHeap.add(a[i]);
        }

        out.println(total - saveTime);

        out.flush();
        out.close();
        br.close();
    }

【贪心】BISHI48 小红的整数配对

Sat, 14 Feb 2026 22:24:11 +0000

思路

求解代码

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
        String[] str = br.readLine().split("\\s+");
        int n = Integer.parseInt(str[0]);
        int k = Integer.parseInt(str[1]);

        String[] numStr = br.readLine().split("\\s+");
        int[] a = new int[n];

        for (int i = 0; i < n; i++) {
            a[i] = Integer.parseInt(numStr[i]);
        }

        Arrays.sort(a);

        long maxScore = 0;
        int i = n - 1;// 从末尾开始遍历
        // 从后往前贪心配对
        while (i >= 1) {
            if (a[i] - a[i - 1] <= k) {
                maxScore += (long) a[i] * a[i - 1];
                i -= 2;// 配对成功，跳过这两个元素
            } else {
                i -= 1;// 无法配对，只跳过当前元素
            }
        }

        out.println(maxScore);

        out.flush();
        out.close();
        br.close();
    }

【滑动窗口】BISHI47 交换到最大

Sat, 14 Feb 2026 21:39:48 +0000

思路

求解代码

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        int t = Integer.parseInt(br.readLine());

        while (t-- > 0) {

            String str = br.readLine();
            char[] s = str.toCharArray();
            int n = s.length;

            for (int i = 0; i < n; i++) {
                int max_val = s[i] - '0';
                int max_index = i;
                // 在窗口内寻找能产生最大价值的来源
                for (int j = i; j < Math.min(i + 10, n); j++) {
                    int cur_val = (s[j] - '0') - (j - i);
                    if (cur_val > max_val) {
                        max_val = cur_val;
                        max_index = j;
                    }
                }
                // 物理移动来源字符到当前位置i
                int tmp_index = max_index;
                while (tmp_index > i) {
                    char tmp_val = s[tmp_index];
                    s[tmp_index] = s[tmp_index - 1];
                    s[tmp_index - 1] = tmp_val;
                    tmp_index--;
                }
                // 将当前位置i的字符值更新为计算出的最优值
                s[i] = (char) (max_val + '0');
            }

            out.println(new String(s));
        }
        out.flush();
        out.close();
        br.close();
    }

BISHI46 小红的魔法药剂

Sat, 14 Feb 2026 20:09:43 +0000

流程图

求解代码

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        int n = Integer.parseInt(br.readLine());

        String[] str = br.readLine().split("\\s+");
        int[] redStr = new int[str.length];

        for (int i = 0; i < str.length; i++) {
            redStr[i] = Integer.parseInt(str[i]);
        }

        int sum = 0;
        // 遍历每种药剂
        for (int i = 0; i < n; i++) {
            // 读取合成第i种蓝色药剂所需的两种红色药剂的编号b和c
            String[] split = br.readLine().split("\\s+");
            int b = Integer.parseInt(split[0]);
            int c = Integer.parseInt(split[1]);

            // 计算合成第i种蓝色药剂的花费，即所需两种红色药剂价格之和
            int blue = redStr[b - 1] + redStr[c - 1];
            // 获取直接购买第i种红色药剂的花费
            int red = redStr[i];

            // 选择合成蓝色药剂和直接购买红色药剂两者花费较小的值，累加到总花费sum中
            sum += Math.min(blue, red);
        }

        out.println(sum);
        out.close();
        br.close();
    }

BISHI45 小红的矩阵染色

Fri, 13 Feb 2026 21:59:29 +0000

流程图

纵向遍历矩阵统计

贪心排序与 Score 计算

求解代码

public static void main(String[] args)throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        String[] str = br.readLine().split("\\s+");

        int n = Integer.parseInt(str[0]);
        int m = Integer.parseInt(str[1]);
        int k = Integer.parseInt(str[2]);

        char[][] matrix = new char[n][m];

        for(int i=0;i<n;i++){
            matrix[i]=br.readLine().toCharArray();
        }

        List<Integer> block = new ArrayList<>();
        for(int j = 0;j<m;j++){
            int current = 0;
            for(int i=0;i<n;i++){
                if(matrix[i][j]=='o'){
                    current++;
                }else{
                    if(current>=2){
                        block.add(current);
                    }
                    current = 0;
                }
            }

            if(current>=2){
                block.add(current);
            }
        }

        Collections.sort(block,Collections.reverseOrder());

        int score = 0;

        for(int len:block){
            if(k==0){
                break;
            }

            int cell = Math.min(k, len);
            if(cell>=2){
                score += cell-1;
            }
            k-=cell;
        }

        out.println(score);
        out.flush();
        out.close();
        br.close();
        
    }

题解 | 灵异背包？

Fri, 13 Feb 2026 00:18:28 +0000

求解代码

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        int n = Integer.parseInt(br.readLine());
        String[] str = br.readLine().split("\\s+");

        long sum = 0;
        int minOdd = Integer.MAX_VALUE;

        for (String s : str){
            int num = Integer.parseInt(s);

            sum += num;

            if((num&1)==1){
                minOdd=Math.min(num, minOdd);
            }
        }

        long res;

        if((sum&1)==0){
            res = sum;
        }else{
            if(minOdd!=Integer.MAX_VALUE){
                res = sum - minOdd;// 总和是奇数，需要减去最小的奇数（若存在）
            }else{
                res = 0;// 没有奇数，只能选空背包
            }
        }
        out.println(res);
        out.flush();
        out.close();
        br.close();

    }

BISHI43 讨厌鬼进货

Fri, 13 Feb 2026 00:00:30 +0000

求解代码

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
        String[] s = br.readLine().split("\\s+");

        int n = Integer.parseInt(s[0]);
        long x = Long.parseLong(s[1]);

        String[] strA = br.readLine().split("\\s+");
        String[] strB = br.readLine().split("\\s+");

        long sum = 0;

        for (int i = 0; i < n; i++) {
            int a = Integer.parseInt(strA[i]);
            int b = Integer.parseInt(strB[i]);

            sum += Math.min(a, b); // 每种货物选A/B中更便宜的
        }
        long res = Math.min(x, sum);// 比较单独买总和与网购成本
        out.println(res);
        out.flush();
        out.close();
        br.close();

    }

BISHI42 余数求和

Thu, 12 Feb 2026 23:18:07 +0000

求解思路

由于对任意正整数$k, i$，有$k \mod i = k - i \times \lfloor \frac{k}{i} \rfloor$

$$\sum_{i=1}^n (k \mod i) = \sum_{i=1}^n \left( k - i \times \lfloor \frac{k}{i} \rfloor \right) = n \times k - \sum_{i=1}^{\min(n,k)} \left( i \times \lfloor \frac{k}{i} \rfloor \right)$$

求解代码

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
        String[] str = br.readLine().split("\\s+");

        long n = Long.parseLong(str[0]);
        long k = Long.parseLong(str[1]);

        long total = n * k; // 原表达式的第一部分
        long m = Math.min(n, k); // 只需要计算到min(n,k)
        long i = 1;

        while (i <= m) {
            long v = k / i;
            long j = Math.min(k / v, m); // 当前块的右边界
            // 计算i到j的和：(i+j)*(j-i+1)/2，再乘以v
            total -= v * (i + j) * (j - i + 1) / 2;
            i = j + 1; // 跳到下一个块
        }
        out.println(total);
        out.flush();
        out.close();
        br.close();

    }

BISHI41 【模板】整除分块

Thu, 12 Feb 2026 22:28:33 +0000

求解思路

当 $n=5$ 时：

$i=1 \rightarrow \lfloor 5/1 \rfloor = 5$
$i=2 \rightarrow \lfloor 5/2 \rfloor = 2$
$i=3 \rightarrow \lfloor 5/3 \rfloor = 1$
$i=4 \rightarrow \lfloor 5/4 \rfloor = 1$
$i=5 \rightarrow \lfloor 5/5 \rfloor = 1$

可以看到：$i=3,4,5$ 对应的 $\lfloor 5/i \rfloor$ 都是 1，这一段可以批量计算。

对于当前的 $i$，设 $v = \lfloor \frac{n}{i} \rfloor$，则最大的 $j$ 满足 $\lfloor \frac{n}{j} \rfloor = v$ 是： $j = \left\lfloor \frac{n}{v} \right\rfloor$。

因此，我们可以按“值相同的区间”分块，每个区间的贡献是 $v \times (j - i + 1)$，然后直接跳到 $j+1$ 继续计算。

求解代码

public static void main(String[] args) throws IOException {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer in = new StringTokenizer(br.readLine());

        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        long n = Long.parseLong(in.nextToken());

        long res = 0;

        long i = 1;

        while (i <= n) {
            long v = n / i; // 当前块的取值
            long j = n / v; // 当前块的右边界
            res += v * (j - i + 1); // 计算当前块的贡献
            i = j + 1; // 跳到下一个块的起点
        }

        out.println(res);
        out.flush();
        out.close();
        br.close();
    }

BISHI40数组取精

Thu, 12 Feb 2026 21:12:37 +0000

求解思路

1.先分别计算序列A和B的总和sumA 和sumB

2.将所有元素按照$a_i +b_i$从大到小排序

3.依次选取排序后的元素，累加子集的A和、B和，直到同时满足超过总和的一半

4.输出选取的元素的原始索引

求解代码

static class Element {
        int a; // 对应数组A的元素值
        int b; // 对应数组B的元素值
        int index;// 该元素在原数组中的索引（从1开始）

        // 构造方法：初始化a、b、index
        Element(int a, int b, int index) {
            this.a = a;
            this.b = b;
            this.index = index;
        }
    }

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int n = Integer.parseInt(br.readLine());

        String[] strA = br.readLine().split(" ");
        String[] strB = br.readLine().split(" ");

        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        List<Element> elements = new ArrayList<>();

        long sumA = 0, sumB = 0;

        for (int i = 0; i < n; i++) {
            int a = Integer.parseInt(strA[i]); // 把strA的字符串转成整数
            int b = Integer.parseInt(strB[i]); // 把strB的字符串转成整数
            elements.add(new Element(a, b, i + 1)); // 封装成Element，索引从1开始
            sumA += a; // 累加A的总和
            sumB += b; // 累加B的总和
        }

        Collections.sort(elements, (e1, e2) -> {
            long s1 = (long) e1.a + e1.b;
            long s2 = (long) e2.a + e2.b;

            return Long.compare(s2, s1);// 按a+b从大到小排序
        });

        List<Integer> res = new ArrayList<>();
        long currentA = 0, currentB = 0;

        for (Element e : elements) {
            res.add(e.index); // 把当前元素的索引加入结果
            currentA += e.a; // 累加子集的A和
            currentB += e.b; // 累加子集的B和
            // 检查是否满足条件：子集和超过总和的一半
            if (currentA > sumA / 2 && currentB > sumB / 2) {
                break; // 满足条件则停止选取
            }
        }
        out.println(res.size());

        for (int i = 0; i < res.size(); i++) {
            out.print(res.get(i)+(i == res.size() - 1 ? "" : " "));
        }

        out.flush();
        out.close();
        br.close();
    }

数位差与数值和的构造

Wed, 11 Feb 2026 00:02:55 +0000

求解代码

 public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer in = new StringTokenizer(br.readLine());

        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        int t = Integer.parseInt(in.nextToken());
        for (int i = 0; i < t; i++) {
            in = new StringTokenizer(br.readLine());
            String s = in.nextToken();

            StringBuilder sb1 = new StringBuilder();
            StringBuilder sb2 = new StringBuilder();

            boolean flag = true;

            for (char c : s.toCharArray()) {
                int digit = c - '0';
                int half = digit / 2;

                //当前位是偶数 → 平分给sb1和sb2
                if (digit % 2 == 0) {
                    sb1.append(half);
                    sb2.append(half);
                } else {
                    //当前位是奇数 → 交替分配多的1（half+1）
                    if (flag) {
                        sb1.append(half + 1);
                        sb2.append(half);
                    } else {
                        sb1.append(half);
                        sb2.append(half + 1);
                    }

                    flag = !flag;
                }
            }
            out.println(Long.parseLong(sb1.toString()) + " " + Long.parseLong(
                    sb2.toString()));
        }

        out.flush();
        out.close();
        br.close();
    }

BISHI35 【模板】巴什博弈

Tue, 10 Feb 2026 22:52:34 +0000

求解代码

 public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StreamTokenizer in = new StreamTokenizer(br);

        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
        in.nextToken();
        int t = (int) in.nval;
        for (int i = 0; i < t; i++) {
            in.nextToken();
            int n = (int) in.nval;
             in.nextToken();
            int m = (int) in.nval; 
            
            if(n%(m+1)==0){
                out.println("NO");
            }else{
                out.println("YES");
            }
            
        }

        out.flush();
        out.close();
        br.close();
    }

小贴士

若 n = k*(m+1)（即 n%(m+1)==0）：无论先手取 x 个（1≤x≤m），后手都可以取 (m+1)-x 个，最终后手总能取到最后一个物品 ➡️ 先手必败；
若 n ≠ k*(m+1)：先手可以先取 n%(m+1) 个，让剩余物品数为 k*(m+1)，此时后手陷入必败局面➡️先手必胜。

BISHI34 甜蜜的博弈

Tue, 10 Feb 2026 21:59:29 +0000

求解代码

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StreamTokenizer in = new StreamTokenizer(br);

        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
        in.nextToken();
        int t = (int) in.nval;
        for (int i = 0; i < t; i++) {
            in.nextToken();
            int n = (int) in.nval;
            // 判断规则：n=3、n=6，或 n≥9 且为奇数 → Bob 赢，否则 Alice 赢；
            if (n == 3 || n == 6 || (n >= 9 && (n % 2 == 1))) {
                out.println("Bob");
            } else {
                out.println("Alice");
            }
        }

        out.flush();
        out.close();
        br.close();
    }

BISHI33 Poi 的新加法（Easy Version）

Tue, 10 Feb 2026 21:20:54 +0000

求解代码

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        // 拼接所有输入行：解决“数字可换行/空格分隔”的ACM输入特性
        StringBuilder sb = new StringBuilder();
        String line;
        // 逐行读取所有输入，直到输入结束（br.readLine()返回null）
        while ((line = br.readLine()) != null) {
            // trim()去掉行首行尾空格，append(" ")保证数字间用空格分隔
            sb.append(line.trim()).append(" ");
        }
        // 拼接后的字符串按“任意空格”拆分成一个个数字字符串
        StringTokenizer in = new StringTokenizer(sb.toString());
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        int t = Integer.parseInt(in.nextToken());

        for (int i = 0; i < t; i++) {
            long m = Long.parseLong(in.nextToken());
            long query = Long.parseLong(in.nextToken());

            long res = 0;

            for (int j = 0; j < m; j++) {
                // 读取第 j 个数值 val
                long val = Long.parseLong(in.nextToken());

                // 非第一个数，res 只保留和当前 val 二进制位 “都为 1” 的部分，其他位全部变成 0
                res = j > 0 ? ~(res ^ val) & res : val;

                // 非第一个数且 res>0 时，左移1位（等价于×2）
                if (res > 0 && j > 0) {
                    res <<= 1;
                }
            }
            int left = Integer.parseInt(in.nextToken());
            int right = Integer.parseInt(in.nextToken());
            out.println(res);
            res = 0;
        }

        out.flush();
        out.close();
        br.close();
    }

小贴士

反码：原码除符号位外全部取反
负数的补码 = 反码 + 1
~(res^val)&res的本质是筛选出 res 和 val 二进制中 “都为 1” 的位

BISHI30 二进制数1

Mon, 09 Feb 2026 22:09:39 +0000

求解代码

public static void main(String[] args) throws IOException {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));


        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        String str = br.readLine();
        long n =Long.parseLong(str.trim());

        int count = 0;
        while (n > 0) {
            count += n & 1;
            n = n >> 1;
        }
        out.println(count);

        out.flush();
        out.close();
        br.close();
    }

小贴士

StreamTokenizer 的 in.nval 是 double 类型（64 位浮点数），但 double 的有效整数精度只有 53 位，将其强转为 long（64 位整数）会造成精度丢失，所以这里需要用BufferedReader.readLine()读取字符串再转 long。

BISHI29 小红的排列构造①

Mon, 09 Feb 2026 21:12:30 +0000

求解代码

 public static void main(String[] args) throws IOException {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        StreamTokenizer in = new StreamTokenizer(br);

        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        in.nextToken();
        int n = (int) in.nval;

        int[] arr = new int[n];

        if(n<=2){
            out.println(-1);
        }else{
            arr[0]=3;// 第一个元素固定为3
            for (int i = 1; i < n; i++) {
                arr[i]=i+1;//从第2个元素开始，值为「索引+1」
            }
            arr[2]=1;// 第三个元素强制改为1

            for(int i=0;i<n;i++){
                out.print(arr[i]+(i == n - 1 ? "" : " "));
            }
        }



        out.flush();
        out.close();
        br.close();
    }

两种方式构造数独

Mon, 09 Feb 2026 20:25:17 +0000

循环矩阵

 public static void main(String[] args) throws IOException {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        StreamTokenizer in = new StreamTokenizer(br);

        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        in.nextToken();
        int n = (int) in.nval;

        in.nextToken();
        int k = (int) in.nval;
        
        int[] firstRow = new int[n];
        int q = k/n;
        int r = k%n;

        /**
         * sum(firstRow) = r*(q+1) + (n-r)*q = n*q + r = k
         */
        for(int i=0;i<n;i++){
            if(i<r){
                firstRow[i]=q+1;
            }else{
                firstRow[i]=q;
            }
        }

        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                //第i行是第一行循环左移 i 位的结果
                //加n可避免j-i为负数时取模出错
                out.print(firstRow[(j-i+n)%n]+(j==n-1?"":" "));
            }
            out.println();
        }

        out.flush();
        out.close();
        br.close();
    }

方法2-YYDS（有一点马叉虫）

public static void main(String[] args) throws IOException {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        StreamTokenizer in = new StreamTokenizer(br);

        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        in.nextToken();
        int n = (int) in.nval;

        in.nextToken();
        int k = (int) in.nval;

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (i == j) {
                    out.print(k + (j == n - 1 ? "" : " "));
                } else {
                    out.print(0 + (j == n - 1 ? "" : " "));
                }
            }
            out.println();
        }

        out.flush();
        out.close();
        br.close();
    }

【曼哈顿距离】BISHI25 最大 FST 距离

Sun, 08 Feb 2026 23:57:10 +0000

求解代码

public static void main(String[] args) throws IOException {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        StreamTokenizer in = new StreamTokenizer(br);

        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        in.nextToken();
        int n = (int) in.nval;

        long[] a = new long[n];

        for (int i = 0; i < n; i++) {
            in.nextToken();
            a[i] = (long) in.nval;
        }

        long maxU = Long.MIN_VALUE;
        long minU = Long.MAX_VALUE;
        long maxV = Long.MIN_VALUE;
        long minV = Long.MAX_VALUE;

        for (long i = 0; i < n; i++) {
            // 计算当前位置的索引（从1开始，而非0）
            long idx = i + 1;
            long val = a[(int) i];

            // 计算u值：位置索引的平方 + 数值的平方
            long u = idx * idx + val * val;
            // 计算v值：位置索引的平方 - 数值的平方
            long v = idx * idx - val * val;

            maxU = Math.max(maxU, u);
            minU = Math.min(minU, u);

            maxV = Math.max(maxV, v);
            minV = Math.min(minV, v);

        }
        long dist = Math.max(maxU - minU, maxV - minV);
        
        out.println(dist);

        out.flush();
        out.close();
        br.close();
    }

BISHI24 谐距下标对

Sun, 08 Feb 2026 22:46:33 +0000

求解代码

public static void main(String[] args) throws IOException {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        StreamTokenizer in = new StreamTokenizer(br);

        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        in.nextToken();
        int n = (int) in.nval;

        // 创建HashMap：键=差值diff（Integer），值=该diff出现的次数（Integer）
        Map<Integer, Integer> hMap = new HashMap<>();

        for (int i = 0; i < n; i++) {
            in.nextToken();
            int a = (int) in.nval;

            // diff = 前整数 - 它的位置索引
            int diff = a - i;
            hMap.put(diff, hMap.getOrDefault(diff, 0) + 1);
        }
        long total = 0;

        // 遍历Map中所有diff的出现次数
        for (int count : hMap.values()) {
            // 只有出现次数>1的diff，才能组成数对（至少2个元素才能配对）
            if (count > 1) {
                // 相同 diff 的数，两两之间都满足题目要求的条件，
                // 所以统计每个 diff 的出现次数，再算组合数就是答案。
                total += (long) count * (count - 1) / 2;
            }
        }

        out.println(total);

        out.flush();
        out.close();
        br.close();
    }

小贴士

$a_j -a_i = j-i$➡️$a_j - j= a_i-i$

BISHI23 小红书推荐系统

Sun, 08 Feb 2026 21:42:22 +0000

求解代码

public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    
    PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

    String str = br.readLine();
    
    String[] wordStrings = str.split("\\s+");

    Map<String, Integer> hMap = new HashMap<>();
    
    for (String word : wordStrings) {
        hMap.put(word, hMap.getOrDefault(word, 0) + 1);
    }

    //    Map.Entry<String, Integer>：表示Map中的一个键值对（包含key和value）
    List<Map.Entry<String, Integer>> keywords = new ArrayList<>();
    
    for (Map.Entry<String, Integer> entry : hMap.entrySet()) {
        // 只保留出现次数≥3的单词
        if (entry.getValue() >= 3) {
            keywords.add(entry);
        }
    }

    keywords.sort((o1, o2) -> {

        if (!o1.getValue().equals(o2.getValue()) ) {
            return o2.getValue() - o1.getValue();// 降序
        } else {
            return o1.getKey().compareTo(o2.getKey());// 升序
        }
    });

    for(Map.Entry<String,Integer> entry:keywords){
        out.println(entry.getKey());
    }

    out.flush();
    out.close();
    br.close();
}

小贴士

hMap.entrySet()返回一个包含所有 Entry 的集合（Set<Map.Entry>）；
Entry 是 Map 中键值对的最小封装单元，一个 Entry 对象 = 一个 key + 一个对应的 value。

BISHI22 分数线划定

Sun, 08 Feb 2026 00:29:26 +0000

求解代码

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StreamTokenizer in = new StreamTokenizer(br);

        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        in.nextToken();
        int n = (int) in.nval;
        in.nextToken();
        int m = (int) in.nval;

        List<int[]> a = new ArrayList<int[]>();
        for (int i = 0; i < n; i++) {
            in.nextToken();
            int x = (int) in.nval;
            in.nextToken();
            int y = (int) in.nval;

            a.add(new int[] { x, y });
        }

        int t = (int) (1.5 * m);

        a.sort((o1, o2) -> {
            if (o1[1] != o2[1]) {
                return o2[1] - o1[1];//降序
            } else {
                return o1[0] - o2[0];//升序
            }
        });

        List<int[]> b = new ArrayList<int[]>(); // 存储符合条件的元素
        int line = a.get(t - 1)[1]; // 取排序后第t个元素的y值（索引t-1，因为数组从0开始）
        for(int i=0;i<a.size();i++){
            if(a.get(i)[1]<line){ // 数组已降序，遇到y<line直接终止遍历
                break;
            }
            b.add(a.get(i)); // y≥line，加入结果集
        }
        out.println(line+" "+b.size());

        for(int i=0;i<b.size();i++){
            out.println(b.get(i)[0]+" "+b.get(i)[1]);
        }

        out.flush();
        out.close();
        br.close();

    }

BISHI20 回文日期

Sat, 07 Feb 2026 23:14:50 +0000

求解代码

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StreamTokenizer in = new StreamTokenizer(br);

        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
        in.nextToken();
        int a = (int) in.nval;

        in.nextToken();
        int b = (int) in.nval;

        int start = a / 10000;
        int end = b / 10000;

        int count = 0;

        for (int y = start; y <= end; y++) {
            // 年份转字符串（如2001→"2001"）
            String year = Integer.toString(y);
            // 反转年份得到MMDD
            String revYear = new StringBuilder(year).reverse().toString(); // 2001→"1002"

            // 拆分反转后的字符串为月份、日期（"1002"→month=10，day=02）
            int month = Integer.parseInt(revYear.substring(0, 2));
            int day = Integer.parseInt(revYear.substring(2, 4));

            // 拼接成8位日期
            int date = y * 10000 + month * 100 + day;

            // 日期在[a,b]区间内 并且 日期合法
            if (date >= a && date <= b) {
                if (isValidDate(y, month, day)) {
                    count++; // 符合条件则计数+1
                }
            }
        }
        out.println(count);

        out.flush();
        out.close();
        br.close();
    }

    private static boolean isValidDate(int y, int month, int day) {
        if (month < 1 || month > 12 || day < 1) {
            return false;
        }

        int[] monthDay = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
        if (isLeap(y)) {
            monthDay[2] = 29;
        }

        return day <= monthDay[month];
    }

    private static boolean isLeap(int y) {
        return (y % 4 == 0 && y % 100 != 0) || (y % 400 == 0);
    }

BISHI19 乒乓球

Sat, 07 Feb 2026 21:28:21 +0000

求解代码

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        StringTokenizer in = new StringTokenizer(br.readLine());

        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        String str = in.nextToken();

        char[] s = str.toCharArray();

        printScore(11, s, out);
        out.println();
        printScore(21, s, out);

        out.flush();
        out.close();
        br.close();
    }

    private static void printScore(int score, char[] s, PrintWriter out) {
        int w = 0;
        int l = 0;

        // 遍历每一个得分字符（W/L）
        for (int i = 0; i < s.length; i++) {
            // 统计得分：W则w+1，否则（L）l+1
            if (s[i] == 'W') {
                w++;
            } else {
                l++;
            }

            // 判断是否赢下本局：
            // 条件1：分差≥2
            // 条件2：任意一方达到目标分数（w≥score 或 l≥score）
            if (Math.abs(w - l) >= 2 && (w >= score || l >= score)) {
                out.println(w + ":" + l); // 输出本局最终比分
                w = 0; // 重置得分，开始下一局
                l = 0;
            }
        }
        // 遍历完所有字符后，输出最后未完成局的剩余比分
        out.println(w + ":" + l);
    }

BISHI18 多项式输出

Sat, 07 Feb 2026 20:50:20 +0000

求解代码

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StreamTokenizer in = new StreamTokenizer(br);
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        in.nextToken();
        int n = (int) in.nval;

        int[] a = new int[n + 1];

        for (int i = n; i >= 0; i--) {
            in.nextToken();
            a[i] = (int) in.nval;
        }

        for (int i = n; i >= 0; i--) { // 从最高次到0次遍历，按数学顺序输出
            // 跳过系数为0的项（比如x²项系数为0，就不输出这一项）
            if (a[i] == 0) {
                continue;
            }

            // 处理符号
            if (i == n) { // 最高次项
                if (a[i] < 0) { // 最高次项为负，输出"-"
                    out.print("-");
                }
            } else { // 非最高次项
                if (a[i] < 0) { // 负数输出"-"
                    out.print("-");
                } else { // 正数必须输出"+"
                    out.print("+");
                }
            }

            // 处理系数
            int val = Math.abs(a[i]);
            // 系数绝对值≠1 或 是常数项（i=0），才输出数字；否则不输出
            if (val != 1 || i == 0) {
                out.print(val);
            }

            // 处理x的次数格式
            if (i == 1) { // 一次项：输出"x"
                out.print("x");
            } else if (i > 1) { // 高于1次项：输出"x^次数"
                out.print("x^" + i);
            }

        }

        out.flush();
        out.close();
        br.close();

    }

【BISHI15】小红的夹吃棋

Fri, 06 Feb 2026 23:20:05 +0000

求解代码

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer in = new StringTokenizer(br.readLine());
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        int t = Integer.parseInt(in.nextToken());

        for (int i = 0; i < t; i++) {
            char[][] board = new char[3][3];

            for (int j = 0; j < 3; j++) {
                String s = br.readLine().trim();
                board[j] = s.toCharArray();
            }

            boolean redEat = hasEat(board, '*');
            boolean purpleEat = hasEat(board, 'o');

            if (redEat && !purpleEat) {
                out.println("yukari");
            } else if (!redEat && purpleEat) {
                out.println("kou");
            } else {
                out.println("draw");
            }
        }

        out.flush();
        out.close();
        br.close();
    }

    private static boolean hasEat(char[][] board, char piece) {
        char opponent = (piece == '*') ? 'o' : '*';

        //遍历 3 行（行索引 0-2），
        // 仅检查 “该行中间列（索引 1）是己方棋子，
        // 左右列（索引 0、2）全是对方棋子”
        for (int row = 0; row < 3; row++) {
            if (board[row][1] == piece &&
                    board[row][0] == opponent &&
                    board[row][2] == opponent) {
                return true;
            }
        }

        //遍历 3 列（列索引 0-2），
        // 仅检查 “该列中间行（索引 1）是己方棋子，
        // 上下行（索引 0、2）全是对方棋子”
        for (int col = 0; col < 3; col++) {
            if (board[1][col] == piece &&
                    board[0][col] == opponent &&
                    board[2][col] == opponent) {
                return true;
            }
        }

        return false;
    }

小贴士

逐行读取 3 行字符串时需要用br.readLine().trim()，可以避免StringTokenizer的分割符问题，其实这题用in.nextToken()还过不了。

BISHI13 九倍平方数

Fri, 06 Feb 2026 21:28:19 +0000

问题分析

由于每个数字的修改规则是仅x²<10时可改，并且只有2和3的修改会改变“各位和的模9值”，其他数字修改后模9值是不变的。

假设初始各位和为sum，模9得rest = sum %9；

如果rest=0，直接返回true；

否则，需要通过修改k个2和m个3，让增量总和k*2 + m*6和 (9 - rest) %9相等。

这样一来，问题就转化为判断是否存在k（≤count2）、m（≤count3）使得(k*2 + m*6) %9 == target。

另外，

由于2*9=18,所以改9个2和改0个2的效果是一样的，因此k的取值最多为min(count2,8)；

由于6*3=18，所以改3个3和改0个3的效果也是一样的，因此m的取值最多为min(count3,2)；

求解代码

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class Main {

    public static boolean isGoodNum(String s){
        long sum = 0;
        int count2= 0;
        int count3=0;
        for(char c:s.toCharArray()){
            int num = c-'0';
            sum += num;

            if(num == 2){
                count2++;
            }else if(num ==3){
                count3++;
            }
        }

        int rest  = (int)(sum%9);

        if(rest==0){
            return true;
        }

        int target = (9-rest)%9;

        for(int i=0;i<=Math.min(count2,8);i++){
            for(int j=0;j<=Math.min(count3,2);j++){
                if((i*2+j*6)%9==target){
                    return true;
                }
            }
        }
        return false;
    }
   public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer in = new StringTokenizer(br.readLine());
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        
        int t = Integer.parseInt(in.nextToken());


        for(int i=0;i<t;i++){
            in = new StringTokenizer(br.readLine());
            String s = in.nextToken();
            if(isGoodNum(s)){
                out.println("YES");
            }else{
                out.println("NO");
            }
        }
        out.flush();
        out.close();
        br.close();
   }
}