数学 on Coder_Studio

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

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

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

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