第十二届蓝桥杯 2021年省赛真题 (Java 大学C组) 第二场

---

简单的离谱

---

#A 浮点数

本题总分：5 分

---

问题描述

IEEE 754 规定一个双精度浮点数由 $1$ 位符号位、$11$ 位阶和 $52$ 位尾数组成（以上位数都表示二进制位数）。
请问，按此规定一个双精度浮点数占用几个字节？

---

答案提交

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

---

8

calcCode：

public class Test {
     

    public static void main(String[] args) {
     
        System.out.println(1 + 11 + 52 >> 3);
    }
}

警惕新型攻击言论

---

#B 求余

本题总分：5 分

---

问题描述

在 C/C++/Java/Python 等语言中，使用 % 表示求余，请问 2021%20 的值是多少？

---

答案提交

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

---

1

calcCode：

public class Test {
     

    public static void main(String[] args) {
     
        System.out.println(2021 % 20);
    }
}

怎么都是些能一眼看出答案的题啊

---

#C 双阶乘

本题总分：10 分

---

问题描述

一个正整数的双阶乘，表示不超过这个正整数且与它有相同奇偶性的所有正整数乘积。$n$ 的双阶乘用 $n!!$ 表示。
例如：
$3!!=3\times 1=3$。
$8!!=8\times 6\times 4\times 2=384$。
$11!!=11\times 9\times 7\times 5\times 3\times 1=10395$。
请问，$2021!!$ 的最后 $5$ 位（这里指十进制位）是多少？
注意：$2021!!=2021\times 2019\times \cdot \cdot \cdot \times 5\times 3\times 1$。
提示：建议使用计算机编程解决问题。

---

答案提交

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

---

59375

calcCode：

public class Test {
     

    public static void main(String[] args) {
     
        long ans = 1;
        for (long n = 2021; n > 1; n -= 2)
            ans = (ans * n) % (int)1e5;
        System.out.println(ans);
    }
}

Java 的话还可以用 BigInteger

import java.math.BigInteger;

public class Test {
     

    public static void main(String[] args) {
     
        BigInteger ans = BigInteger.ONE;
        for (int i = 2021; i > 1; i -= 2)
            ans = ans.multiply(BigInteger.valueOf(i));
        System.out.println(ans);
    }
}

手动复制就可以了

挂这里是介绍 BigInteger.valueOf 这个方法，效率会比 new 高一点，原理可以自行从源码中找到

---

#D 格点

本题总分：10 分

---

问题描述

如果一个点 $(x,y)$ 的两维坐标都是整数，即 $x\in Z$ 且 $y\in Z$，则称这个点为一个格点。
如果一个点 $(x,y)$ 的两维坐标都是正数，即 $x>0$ 且 $y>0$，则称这个点在第一象限。
请问在第一象限的格点中，有多少个点 $(x,y)$ 的两维坐标乘积不超过 $2021$，即 $x\cdot y\le 2021$。
提示：建议使用计算机编程解决问题。

---

答案提交

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

---

15698

calcCode：

public class Test {
     

    public static void main(String[] args) {
     
        int ans = 0;
        for (int i = 1; i <= 2021; i++)
            for (int j = 1; j <= 2021; j++)
                if (i * j <= 2021) ans++;
        System.out.println(ans);
    }
}

我们显然可以得知 $x\le \frac{2021}{y}\le 2021$
然后符号交换范围出来暴力就行了

---

#E 整数分解

本题总分：15 分

---

问题描述

将 $3$ 分解成两个正整数的和，有两种分解方法，分别是 $3=1+2$ 和 $3=2+1$。注意顺序不同算不同的方法。
将 $5$ 分解成三个正整数的和，有 $6$ 种分解方法，它们是 $1+1+3=1+2+2=1+3+1=2+1+2=2+2+1=3+1+1$。
请问，将 $2021$ 分解成五个正整数的和，有多少种分解方法？

---

答案提交

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

---

691677274345

calcCode：

public class Test {
     

    public static void main(String[] args) {
     
        long[][] dp = new long[6][2022];
        java.util.Arrays.fill(dp[1], 1);
        for (int k = 2; k <= 5; k++)
            for (int i = k; i <= 2021; i++)
                dp[k][i] = dp[k][i - 1] + dp[k - 1][i - 1];
        System.out.println(dp[5][2021]);
    }
}

套 for 复杂度太高了，不想去等结果，就打了个草稿找规律。

也不知道是对是错

---

#F 3 的倍数

时间限制: 1.0s 内存限制: 512.0MB 本题总分: 15 分

---

问题描述

小蓝对 $3$ 的倍数很感兴趣。现在他手头有三个不同的数 $a,b,c$，他想知道，这三个数中是不是有两个数的和是 $3$ 的倍数。
例如，当 $a=3,b=4,c=6$ 时，可以找到 $a$ 和 $c$ 的和是 $3$ 的倍数。
例如，当 $a=3,b=4,c=7$ 时，没办法找到两个数的和是 $3$ 的倍数。

---

输入格式

输入三行，每行一个整数，分别表示 $a,b,c$。

---

输出格式

如果可以找到两个数的和是 $3$ 的倍数，输出 $yes$，否则输出 $no$。

---

测试样例₁

Input：
3
4
6

Output：
yes

测试样例₂

Input：
3
4
7

Output：
no

---

评测用例规模与约定

对于所有评测用例，$1\le a\le b\le c\le 100$。

---

code：

import java.util.Scanner;

public class Main {
     

    public static void main(String[] args) {
     
        Scanner in = new Scanner(System.in);
        boolean flag = false, torch[] = new boolean[4];
        for (int i = 0, n; i < 3; i++) {
     
            n = in.nextInt();
            if (torch[n % 3]) flag = true;
            else torch[mod(-n, 3)] = true;
        }
        System.out.println(flag ? "yes" : "no");
    }

    static int mod(int a, int b) {
      return a - Math.floorDiv(a, b) * b; }
}

想写的优雅一点，但Java并没有取模运算，艹

---

#G 特殊年份

时间限制: 1.0s 内存限制: 512.0MB 本题总分：20 分

---

问题描述

今年是 $2021$ 年，$2021$ 这个数字非常特殊，它的千位和十位相等，个位比百位大 $1$，我们称满足这样条件的年份为特殊年份。
输入 $5$ 个年份，请计算这里面有多少个特殊年份。

---

输入格式

输入 $5$ 行，每行一个 $4$ 位十进制数（数值范围为 $1000$ 至 $9999$），表示一个年份。

---

输出格式

输出一个整数，表示输入的 $5$ 个年份中有多少个特殊年份。

---

测试样例₁

Input：
2019
2021
1920
2120
9899

Output：
2

Explanation：
2021 和 9899 是特殊年份，其它不是特殊年份。

---

code：

import java.util.Scanner;

public class Main {
     

    public static void main(String[] args) {
     
        Scanner in = new Scanner(System.in);
        int i = 5, ans = 0;
        char[] buff;
        while (i-- > 0) {
     
            buff = in.next().toCharArray();
            if (buff[0] == buff[2] && buff[1] + 1 == buff[3]) ans++;
        }
        System.out.println(ans);
    }
}

题出的都是些什么玩意

---

#H 小平方

时间限制: 1.0s 内存限制: 512.0MB 本题总分：20 分

---

问题描述

小蓝发现，对于一个正整数 $n$ 和一个小于 $n$ 的正整数 $v$，将 $v$ 平方后对 $n$ 取余可能小于 $n$ 的一半，也可能大于等于 $n$ 的一半。
请问，在 $1$ 到 $n-1$ 中，有多少个数平方后除以 $n$ 的余数小于 $n$ 的一半。
例如，当 $n=4$ 时，$1,2,3$ 的平方除以 $4$ 的余数都小于 $4$ 的一半。
又如，当 $n=5$ 时，$1,4$ 的平方除以 $5$ 的余数都是 $1$，小于 $5$ 的一半。而 $2,3$ 的平方除以 $5$ 的余数都是 $4$，大于等于 $5$ 的一半。

---

输入格式

输入一行包含一个整数 $n$。

---

输出格式

输出一个整数，表示满足条件的数的数量。

---

测试样例₁

Input：
5

Output：
2

---

评测用例规模与约定

对于所有评测用例，$1\le n\le 10000$。

---

code：

import java.util.Scanner;

public class Main {
     

    public static void main(String[] args) {
     
        int n = new Scanner(System.in).nextInt();
        int ans = 0, mid = n + 1 >> 1;
        for (int i = 1; i < n; i++)
            if (i * i % n < mid) ans++;
        System.out.println(ans);
    }
}

弱智题写的就会让人很暴躁知道吧

---

#I 完全平方数

时间限制: 2.0s 内存限制: 512.0MB 本题总分：25 分

---

问题描述

一个整数 $a$ 是一个完全平方数，是指它是某一个整数的平方，即存在一个整数 $b$，使得 $a=b^2$。
给定一个正整数 $n$，请找到最小的正整数 $x$，使得它们的乘积是一个完全平方数。

---

输入格式

输入一行包含一个正整数 $n$。

---

输出格式

输出找到的最小的正整数 $x$。

---

测试样例₁

Input：
12

Output：
3

测试样例₂

Input：
15

Output：
15

---

评测用例规模与约定

对于 $30$% 的评测用例，$1\le n\le 1000$，答案不超过 $1000$。
对于 $60$% 的评测用例，$1\le n\le 10^8$，答案不超过 $10^8$。
对于所有评测用例，$1\le n\le 10^{12}$，答案不超过 $10^{12}$。

---

code：

import java.util.Scanner;

public class Main {
     

    public static void main(String[] args) {
     
        long n = new Scanner(System.in).nextLong(), x = 1;
        for (int k = 2, i, j; k <= n; k ++) {
     
            i = 0;
            while (n % k == 0) {
     
                n /= k;
                i++;
            }
            if (i > 0) {
     
                j = -i & i;
                if (i != 1 && i == j) continue;
                x *= Math.pow(k, (j << 1) - i);
            }
        }
        System.out.println(x);
    }
}

还是基本算式定理

答案逻辑一联立就可得知不包含0，不用特判

---

#J 负载均衡

时间限制: 2.0s 内存限制: 512.0MB 本题总分: 25 分

---

问题描述

有 $n$ 台计算机，第 $i$ 台计算机的运算能力为 $v_i$。
有一系列的任务被指派到各个计算机上，第 $i$ 个任务在 $a_i$ 时刻分配，指定计算机编号为 $b_i$ ，耗时为 $c_i$ 且算力消耗为 $d_i$ 。如果此任务成功分配，将立刻开始运行，期间持续占用 $b_i$ 号计算机 $d_i$ 的算力，持续 $c_i$ 秒。
对于每次任务分配，如果计算机剩余的运算能力不足则输出 $-1$，并取消这次分配，否则输出分配完这个任务后这台计算机的剩余运算能力。

---

输入格式

输入的第一行包含两个整数 $n,m$，分别表示计算机数目和要分配的任务数。
第二行包含 $n$ 个整数 $v_1,v_2,\cdot \cdot \cdot v_n$，分别表示每个计算机的运算能力。
接下来 $m$ 行每行 $4$ 个整数 $a_i,b_i,c_i,d_i$，意义如上所述。数据保证 $a_i$ 严格递增，即 $a_i<a_{i+1}$。

---

输出格式

输出 $m$ 行，每行包含一个数，对应每次任务分配的结果。

---

测试样例₁

Input：
2 6
5 5
1 1 5 3
2 2 2 6
3 1 2 3
4 1 6 1
5 1 3 3
6 1 3 4

Output：
2
-1
-1
1
-1
0

Explanation：
时刻 1，第 1 个任务被分配到第 1 台计算机，耗时为 5 ，这个任务时刻 6 会结束，占用计算机 1 的算力 3。
时刻 2，第 2 个任务需要的算力不足，所以分配失败了。
时刻 3，第 1 个计算机仍然正在计算第 1 个任务，剩余算力不足 3，所以失败。
时刻 4，第 1 个计算机仍然正在计算第 1 个任务，但剩余算力足够，分配后剩余算力 1。
时刻 5，第 1 个计算机仍然正在计算第 1, 4 个任务，剩余算力不足 4，失败。
时刻 6，第 1 个计算机仍然正在计算第 4 个任务，剩余算力足够，且恰好用完。

---

评测用例规模与约定

对于 $20$% 的评测用例，$n,m\le 200$。
对于 $40$% 的评测用例，$n,m\le 2000$。
对于所有评测用例，$1\le n,m\le 200000$，$1\le a_i,c_i,d_i,v_i\le 10^9$，$1\le b_i\le n$。

---

code：

import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.util.PriorityQueue;
import java.util.Queue;

public class Main {
     

    public static void main(String[] args) {
     
        InputReader in = new InputReader(System.in);
        PrintWriter out = new PrintWriter(System.out);
        Queue<Item> queue = new PriorityQueue();
        int n = in.nextInt(), m = in.nextInt();
        int[] comp = new int[n + 1];
        int a, b, c, d, time = 1;
        for (int i = 1; i <= n; i++)
              comp[i] = in.nextInt();
        for (int i = 0; i < m; i++) {
     
            a = in.nextInt();
            b = in.nextInt();
            c = in.nextInt();
            d = in.nextInt();
            if (a > time) time = a;
            while (queue.size() > 0) {
     
                Item item = queue.peek();
                if (item.time > time) break;
                comp[item.idx] += item.val;
                queue.remove();
            }
            if (comp[b] >= d) {
     
                queue.add(new Item(b, d, time + c));
                out.println(comp[b] -= d);
            } else out.println("-1");
        }
        out.flush();
    }

    static class Item implements Comparable<Item> {
     

        int time, idx, val;

        Item(int idx, int val, int time) {
     
            this.time = time;
            this.idx = idx;
            this.val = val;
        }

        @Override
        public int compareTo(Item o) {
     
            return this.time - o.time;
        }
    }

    static class InputReader {
     

        BufferedReader read;
        StringTokenizer token;
        String delimiters;

        InputReader (InputStream in) {
      this(in, " \t\n\r\f"); }

        InputReader (InputStream in, String delimiters) {
     
            this.read = new BufferedReader(new InputStreamReader(in));
            this.token = new StringTokenizer("", this.delimiters = delimiters);
        }

        String next() {
     
            while (!token.hasMoreTokens())
                try {
     
                    token = new StringTokenizer(read.readLine(), delimiters);
                } catch (IOException e) {
     
                    e.printStackTrace();
                }
            return token.nextToken();
        }

        int nextInt() {
      return Integer.parseInt(next()); }
    }
}

一个大模拟

---

就感觉没啥含量，有手就能A