第十三届蓝桥杯大赛软件赛省赛（Java 大学C组）

---

  很难避免，需要在错误中成长的困境。

  毕竟人都是向下望就变得能坚强，

  我亦尔耳。

---

试题 A: 排列字母

本题总分：$5$ 分

---

【问题描述】

  小蓝要把一个字符串中的字母按其在字母表中的顺序排列。

  例如，$\mathrm{L}\mathrm{A}\mathrm{N}\mathrm{Q}\mathrm{I}\mathrm{A}\mathrm{O}$ 排列后为 $\mathrm{A}\mathrm{A}\mathrm{I}\mathrm{L}\mathrm{N}\mathrm{O}\mathrm{Q}$。

  又如，$\mathrm{G}\mathrm{O}\mathrm{O}\mathrm{D}\mathrm{G}\mathrm{O}\mathrm{O}\mathrm{D}\mathrm{S}\mathrm{T}\mathrm{U}\mathrm{D}\mathrm{Y}\mathrm{D}\mathrm{A}\mathrm{Y}\mathrm{D}\mathrm{A}\mathrm{Y}\mathrm{U}\mathrm{P}$ 排列后为 $\mathrm{A}\mathrm{A}\mathrm{D}\mathrm{D}\mathrm{D}\mathrm{D}\mathrm{D}\mathrm{G}\mathrm{G}\mathrm{O}\mathrm{O}\mathrm{O}\mathrm{O}\mathrm{P}\mathrm{S}\mathrm{T}\mathrm{U}\mathrm{U}\mathrm{Y}\mathrm{Y}\mathrm{Y}$。

  请问对于以下字符串，排列之后字符串是什么？

  $\mathrm{W}\mathrm{H}\mathrm{E}\mathrm{R}\mathrm{E}\mathrm{T}\mathrm{H}\mathrm{E}\mathrm{R}\mathrm{E}\mathrm{I}\mathrm{S}\mathrm{A}\mathrm{W}\mathrm{I}\mathrm{L}\mathrm{L}\mathrm{T}\mathrm{H}\mathrm{E}\mathrm{R}\mathrm{E}\mathrm{I}\mathrm{S}\mathrm{A}\mathrm{W}\mathrm{A}\mathrm{Y}$

【答案提交】

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

---

AAAEEEEEEHHHIIILLRRRSSTTWWWY

---

public class Test {

    public static void main(String[] args) {
        java.util.Arrays.stream("WHERETHEREISAWILLTHEREISAWAY".split("")).sorted().forEach(System.out::print);
    }
}

  整个活。

---

试题 B: 特殊时间

本题总分：$5$ 分

---

【问题描述】

  $2022$ 年 $2$ 月 $22$ 日 $22$:$20$ 是一个很有意义的时间，年份为 $2022$，由 $3$ 个 $2$ 和 $1$ 个 $0$ 组成，如果将月和日写成 $4$ 位，为 $0222$，也是由 $3$ 个 $2$ 和 $1$ 个 $0$ 组成，如果将时间中的时和分写成 $4$ 位，还是由 $3$ 个 $2$ 和 $1$ 个 $0$ 组成。

  小蓝对这样的时间很感兴趣，他还找到了其它类似的例子，比如 $111$ 年 $10$ 月 $11$ 日 $01$:$11$，$2202$ 年 $2$ 月 $22$ 日 $22$:$02$ 等等。

  请问，总共有多少个时间是这种年份写成 $4$ 位、月日写成 $4$ 位、时间写成 $4$ 位后由 $3$ 个一种数字和 $1$ 个另一种数字组成。注意 $1111$ 年 $11$ 月 $11$ 日 $11$:$11$ 不算，因为它里面没有两种数字。

【答案提交】

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

---

212

---

  在 $3$ 个相同的个位数中插入 $1$ 个个位数，显然可以组成 $4$ 个不同的数字（不一定是 $4$ 位数），于是我们可以另一个合法的 月日时分 与 $4$ 个不同的年份组成映射关系，只要统计出合法的 日月时分 个数，将其乘上一个 $4$，答案就被计算出来了。

import java.time.format.DateTimeFormatter;
import java.time.LocalDateTime;

public class Test {

    public static void main(String[] args) { new Test().run(); }

    void run() {
        DateTimeFormatter date = DateTimeFormatter.ofPattern("MMdd");
        DateTimeFormatter time = DateTimeFormatter.ofPattern("HHmm");
        LocalDateTime start = LocalDateTime.of(0000, 01, 01, 00, 00);
        LocalDateTime end = LocalDateTime.of(0000, 12, 31, 23, 59);
        int[] buff = new int[128];
        int ans = 0;
        for (; start.compareTo(end) <= 0; start = start.plusMinutes(1)) {
            for (char i = '0'; i <= '9'; ++i) buff[i] = 0;
            for (byte b : start.format(date).getBytes()) ++buff[b];
            boolean flag1 = true, flag3 = true;
            for (char i = '0'; i <= '9'; ++i)
                if (buff[i] == 1) flag1 = false;
                else if (buff[i] == 3) flag3 = false;
            if (flag1 || flag3) continue;
            for (byte b : start.format(time).getBytes()) --buff[b];
            for (char i = '0'; i <= '9'; ++i)
                if (buff[i] != 0) flag1 = true;
            if (!flag1) ++ans;
        }
        System.out.println(4 * ans);
    }
}

---

试题 C: 纸张尺寸

时间限制: $1.0\mathrm{s}$ 内存限制: $512.0\mathrm{M}\mathrm{B}$ 本题总分：$10$ 分

---

【问题描述】

  在 $\mathrm{I}\mathrm{S}\mathrm{O}$ 国际标准中定义了 $\mathrm{A}0$ 纸张的大小为 $1189\mathrm{m}\mathrm{m}\times 841\mathrm{m}\mathrm{m}$，将 $\mathrm{A}0$ 纸沿长边对折后为 $\mathrm{A}1$ 纸，大小为 $841\mathrm{m}\mathrm{m}\times 594\mathrm{m}\mathrm{m}$，在对折的过程中长度直接取下整（实际裁剪时可能有损耗）。将 $\mathrm{A}1$ 纸沿长边对折后为 $\mathrm{A}2$ 纸，依此类推。

  输入纸张的名称，请输出纸张的大小。

【输入格式】

  输入一行包含一个字符串表示纸张的名称，该名称一定是 $\mathrm{A}0$、$\mathrm{A}1$、$\mathrm{A}2$、$\mathrm{A}3$、$\mathrm{A}4$、$\mathrm{A}5$、$\mathrm{A}6$、$\mathrm{A}7$、$\mathrm{A}8$、$\mathrm{A}9$ 之一。

【输出格式】

  输出两行，每行包含一个整数，依次表示长边和短边的长度。

【样例输入 1】

A0

【样例输出 1】

1189
841

【样例输入 2】

A1

【样例输出 2】

841
594

---

  签到题，$\mathrm{J}\mathrm{a}\mathrm{v}\mathrm{a}8$ 支持 switch String 对象，

  直接用 switch 的特性写了。

import java.util.Scanner;

public class Main {

    public static void main(String[] args) { new Main().run(); }

    int length = 1189, wide = 841;

    void cut() {
        int temp = wide;
        wide = length / 2;
        length = temp;
    }

    void run() {
        switch (new Scanner(System.in).next()) {
            case "A9": cut();
            case "A8": cut();
            case "A7": cut();
            case "A6": cut();
            case "A5": cut();
            case "A4": cut();
            case "A3": cut();
            case "A2": cut();
            case "A1": cut();
            default: System.out.printf("%d\n%d", length, wide);
        }
    }
}

---

试题 D: 求和

时间限制: $1.0\mathrm{s}$ 内存限制: $512.0\mathrm{M}\mathrm{B}$ 本题总分：$10$ 分

---

【问题描述】

  给定 $n$ 个整数 $a_1,a_2,\cdots ,a_n$，求它们两两相乘再相加的和，即$$S=a_1\cdot a_2+a_1\cdot a_3+\cdots +a_1\cdot a_n+a_2\cdot a_3+\cdots +a_{n-2}\cdot a_{n-1}+a_{n-2}\cdot a_n+a_{n-1}\cdot a_n。$$

【输入格式】

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

  第二行包含 $n$ 个整数 $a_1,a_2,\cdots ,a_n$。

【输出格式】

  输出一个整数 $S$，表示所求的和。请使用合适的数据类型进行运算。

【样例输入】

4
1 3 6 9

【样例输出】

117

【评测用例规模与约定】

  对于 $30\%$ 的数据，$1\le n\le 1000，1\le a_i\le 100$。
  对于所有评测用例，$1\le n\le 200000，1\le a_i\le 1000$。

---

公式递推

---

  将 $S$ 中包含 $a_1$ 的项整理出来，有：

  $S=a_1\cdot (a_2+a_3+\cdots +a_n)+a_2\cdot a_3+\cdots +a_{n-2}\cdot a_{n-1}+a_{n-2}\cdot a_n+a_{n-1}\cdot a_n$

  同样的将余项中包含 $a_2$、$a_3$、$\cdots$、$a_n$ 的项整理出来：

  $\begin{array}{rl}S& =a_1\cdot (a_2+a_3+\cdots +a_n)+a_2\cdot (a_3+a_4+\cdots +a_n)+\cdots +a_{n-1}\cdot a_n\\ & =a_1\cdot \sum _{i=2}^n{a}_i+a_2\cdot \sum _{i=3}^n{a}_i+\cdots +a_{n-1}\cdot \sum _{i=n}^n{a}_i\end{array}$

  也就 $S$ 等于每个元素乘以右边所有元素的和的和，考虑到实现计算的代码量，我们将 $S$ 的项重排，重新整理出：

  $S=a_1\cdot \sum _{i=1}^0{a}_i+a_2\cdot \sum _{i=1}^1{a}_i+\cdots +a_n\cdot \sum _{i=1}^{n-1}{a}_i$

import java.io.StreamTokenizer;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.io.IOException;

public class Main {

    public static void main(String[] args) { new Main().run(); }

    void run() {
        int n = nextInt(), sum = 0;
        long a, ans = 0;
        while(n-- > 0) {
            a = nextInt();
            ans += a * sum;
            sum += a;
        }
        System.out.println(ans);
    }

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

    int nextInt() {
        try {
            in.nextToken();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return (int)in.nval;
    }
}

---

试题 E: 矩形拼接

时间限制: $1.0\mathrm{s}$ 内存限制: $512.0\mathrm{M}\mathrm{B}$ 本题总分：$15$ 分

---

【问题描述】

  已知 $3$ 个矩形的大小依次是 $a_1\times b_1$、$a_2\times b_2$ 和 $a_3\times b_3$。用这 $3$ 个矩形能拼出的所有多边形中，边数最少可以是多少？

  例如用 $3\times 2$ 的矩形（用 $\mathrm{A}$ 表示）、$4\times 1$ 的矩形（用 $\mathrm{B}$ 表示）和 $2\times 4$ 的矩形（用 $\mathrm{C}$ 表示）可以拼出如下 $4$ 边形。

  例如用 $3\times 2$ 的矩形（用 $\mathrm{A}$ 表示）、$3\times 1$ 的矩形（用 $\mathrm{B}$ 表示）和 $1\times 1$ 的矩形（用 $\mathrm{C}$ 表示）可以拼出如下 $6$ 边形。

【输入格式】

  输入包含多组数据。

  第一行包含一个整数 $T$，代表数据组数。

  以下 $T$ 行，每行包含 $6$ 个整数 $a_1,b_1,a_2,b_2,a_3,b_3$，其中 $a_1,b_1$ 是第一个矩形的边长，$a_2,b_2$ 是第二个矩形的边长，$a_3,b_3$ 是第三个矩形的边长。

【输出格式】

  对于每组数据，输出一个整数代表答案。

【样例输入】

2
2 3 4 1 2 4
1 2 3 4 5 6

【样例输出】

4
8

【评测用例规模与约定】

  对于 $10\%$ 的评测用例，$1\le T\le 5，1\le a_1,b_1,a_2,b_2,a_3,b_3\le 10，a_1=a_2=a_3$。
  对于 $30\%$ 的评测用例，$1\le T\le 5，1\le a_1,b_1,a_2,b_2,a_3,b_3\le 10$。
  对于 $60\%$ 的评测用例，$1\le T\le 10，1\le a_1,b_1,a_2,b_2,a_3,b_3\le 20$。
  对于所有评测用例，$1\le T\le 1000，1\le a_1,b_1,a_2,b_2,a_3,b_3\le 100$。

---

分类讨论

---

// 因为是分类讨论，所以不想写了。

---

试题 F: 选数异或

时间限制: $1.0\mathrm{s}$ 内存限制: $512.0\mathrm{M}\mathrm{B}$ 本题总分：$15$ 分

---

【问题描述】

  给定一个长度为 $n$ 的数列 $A_1,A_2,\cdots ,A_n$ 和一个非负整数 $x$，给定 $m$ 次查询, 每次询问能否从某个区间 $[l,r]$ 中选择两个数使得他们的异或等于 $x$。

【输入格式】

  输入的第一行包含三个整数 $n,m,x$。

  第二行包含 $n$ 个整数 $A_1,A_2,\cdots ,A_n$。

  接下来 $m$ 行，每行包含两个整数 $l_i,r_i$ 表示询问区间 $[l_i,r_i]$。

【输出格式】

  对于每个询问, 如果该区间内存在两个数的异或为 $x$ 则输出 $\mathrm{y}\mathrm{e}\mathrm{s}$, 否则输出 $\mathrm{n}\mathrm{o}$。

【样例输入】

4 4 1
1 2 3 4
1 4
1 2
2 3
3 3

【样例输出】

yes
no
yes
no

【样例说明】
  显然整个数列中只有 $2,3$ 的异或为 $1$。

【评测用例规模与约定】

  对于 $20\%$ 的评测用例，$1\le n,m\le 100$；
  对于 $40\%$ 的评测用例，$1\le n,m\le 1000$；
  对于所有评测用例，$1\le n,m\le 100000，0\le x<2^{20}，1\le l_i\le r_i\le n，0\le A_i<2^{20}$。

---

莫队分块

---

  对于 $[l_i,r_i]$ 中的某个数 $A_k$，若其中还存在一个数 $A_g$ 使得 $A_k\oplus A_g=x$，根据异或自反性质有：$$\begin{array}{rl}{A}_k\oplus A_g\oplus A_k& =x\oplus A_k\\ A_g& =x\oplus A_k\end{array}$$  容易想到离线莫队来处理这个问题，具体地说：

  我们声明一个整形 $\mathrm{c}\mathrm{n}\mathrm{t}$ 并建立一个 $\mathrm{m}\mathrm{a}\mathrm{p}$，一开始它存储了 $[0,0]$ 间每个数出现的次数，对于每次往区间里面加入一个数 $A_k$，将 $\mathrm{c}\mathrm{n}\mathrm{t}$ 加上一个 $A_g$ 出现次数，每次减去一个数 $A_k$，将 $\mathrm{c}\mathrm{n}\mathrm{t}$ 减去一个 $A_g$ 出现次数，直至区间变为 $[l_i,r_i]$，

  此时，根据 $\mathrm{c}\mathrm{n}\mathrm{t}$ 是否大于 $1$ 来回答是否存在题目所述的两个数。

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.io.*;

public class Main {

    public static void main(String[] args) { new Main().run(); }

    int block, x, cnt = 0;

    Map<Integer, Integer> map = new HashMap();

    void run() {
        PrintWriter out = new PrintWriter(System.out);
        int n = nextInt(), m = nextInt();
        boolean[] ans = new boolean[m];
        Query[] querys = new Query[m];
        block = (int)Math.sqrt(n);
        int[] A = new int[n + 1];
        x = nextInt();
        for (int i = 1; i <= n; ++i) A[i] = nextInt();
        for (int i = 0; i < n; ++i)
            querys[i] = new Query(i, nextInt(), nextInt());
        Arrays.sort(querys);
        int l = 1, r = 0;
        for (int i = 0; i < m; ++i) {
            while (querys[i].r > r) add(A[++r]);
            while (querys[i].l < l) add(A[--l]);
            while (querys[i].r < r) move(A[r--]);
            while (querys[i].l > l) move(A[l++]);
            ans[querys[i].idx] = cnt > 0;
        }
        for (int i = 0; i < m; ++i)
            out.println(ans[i] ? "yes" : "no");
        out.flush();
    }

    void add(int a) {
        if (map.containsKey(a ^ x))
            cnt += map.get(a ^ x);
        map.put(a, map.getOrDefault(a, 0) + 1);
    }

    void move(int a) {
        if (map.containsKey(a ^ x))
            cnt -= map.get(a ^ x);
        int tmp = map.get(a);
        if (tmp == 1) map.remove(a);
        else map.put(a, tmp - 1);
    }

    class Query implements Comparable<Query> {

        int l, r, idx;

        Query(int idx, int l, int r) {
            this.idx = idx;
            this.l = l;
            this.r = r;
        }

        @Override
        public int compareTo(Query q) {
            return this.l / block == q.l / block ? ((this.l / block) % 2 == 0 ? this.r - q.r : q.r - this.r) : this.l - q.l;
        }
    }

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

    int nextInt() {
        try {
            in.nextToken();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return (int)in.nval;
    }
}

---

动态规划

---

  但其实可以预处理出 $f_r$，其意义为 $[f_r,r]$ 中存在一对 $k$、$g$ ，$f_r\le k\le g\le r$ 使得 $A_k\oplus A_g=x$ 且 $f_r$ 最大，若不存在则另 $f_r=0$。

  对于每一次询问 $[l_i,r_i]$，我们只需判断 $li$ 和 $f_{r_i}$ 的大小关系就能确定 $[l_i,r_i]$ 之间是否存在两个数，它们的异或等于 $x$。

  现在考虑转移，对于每一个 $r$，我们判断下标大于 $r$ 的元素中是否存在 $A_r\oplus x$，其中最靠 $r$ 的是 $f_r$ 的一个候选值，同时我们还要考虑 $[f_{r-1},r-1]$ 中是否有更优的方案，最终有状态转移方程：$$f_r=\max \{f_{r-1},\max \{i|A_i=A_r\oplus x\}\}$$

import java.io.*;

public class Main {

    public static void main(String[] args) { new Main().run(); }

    void run() {
        PrintWriter out = new PrintWriter(System.out);
        int n = nextInt(), m = nextInt(), x = nextInt();
        int[] map = new int[1 << 20];
        int[] f = new int[n + 1];
        for (int r = 1; r <= n; ++r) {
            int a = nextInt();
            f[r] = max(f[r - 1], map[a ^ x]);
            map[a] = r;
        }
        for (int i = 0; i < m; ++i) {
            int l = nextInt();
            int r = nextInt();
            out.println(f[r] >= l ? "yes" : "no");
        }
        out.flush();
    }

    int max(int arg1, int arg2) { return arg1 > arg2 ? arg1 : arg2; }

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

    int nextInt() {
        try {
            in.nextToken();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return (int)in.nval;
    }
}

---

试题 G: GCD

时间限制: $1.0\mathrm{s}$ 内存限制: $512.0\mathrm{M}\mathrm{B}$ 本题总分：$20$ 分

---

【问题描述】

  给定两个不同的正整数 $a,b$，求一个正整数 $k$ 使得 $\gcd (a+k,b+k)$ 尽可能大，其中 $\gcd (a,b)$ 表示 $a$ 和 $b$ 的最大公约数，如果存在多个 $k$，请输出所有满足条件的 $k$ 中最小的那个。

【输入格式】

  输入一行包含两个正整数 $a,b$，用一个空格分隔。

【输出格式】

  输出一行包含一个正整数 $k$。

【样例输入】

5 7

【样例输出】

1

【评测用例规模与约定】

  对于 $20\%$ 的评测用例，$a<b\le 10^5$；
  对于 $40\%$ 的评测用例，$a<b\le 10^9$；
  对于所有评测用例，$1\le a<b\le 10^{18}$。

---

更相减损术

---

  更相减损术告诉我们，对于整数 $a,b$，若 $a\ge b$，都有 $\gcd (a,b)=\gcd (a-b,b)=\gcd (a,a-b)$。

  将 $k$ 代入到式中，我们的目标就是使 $\gcd (a+k,a-b)$、$\gcd (b+k,a-b)$ 最大。

  显然最大为 $|a-b|$，此时 $k$ 取 $\min \{-a,-b\}(\mathrm{m}\mathrm{o}\mathrm{d}|a-b|)$ 最小。

import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;

public class Main {

    public static void main(String[] args) { new Main().run(); }

    void run() {
        InputReader in = new InputReader(System.in);
        long a = in.nextLong(), b = in.nextLong();
        long c = abs(a - b);
        if (c == 0 || c == 1) System.out.print("1");
        else System.out.print(min((-a % c + c) % c, (-b % c + c) % c));
    }

    long min(long arg1, long arg2) { return arg1 < arg2 ? arg1 : arg2; }

    long abs(long arg) { return arg > 0 ? arg : -arg; }

    class InputReader {

        BufferedReader reader;
        StringTokenizer token;

        InputReader(InputStream in) { this.reader = new BufferedReader(new InputStreamReader(in)); }

        String next() {
            if (token == null || !token.hasMoreTokens()) {
                try {
                    token = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return token.nextToken();
        }

        long nextLong() { return Long.parseLong(next()); }
    }
}

  表达式写出来后，

  感觉怪怪的。。。

---

试题 H: 青蛙过河

时间限制: $1.0\mathrm{s}$ 内存限制: $512.0\mathrm{M}\mathrm{B}$ 本题总分：$20$ 分

---

【问题描述】

  小青蛙住在一条河边，它想到河对岸的学校去学习。小青蛙打算经过河里的石头跳到对岸。

  河里的石头排成了一条直线，小青蛙每次跳跃必须落在一块石头或者岸上。不过，每块石头有一个高度，每次小青蛙从一块石头起跳，这块石头的高度就会下降 $1$，当石头的高度下降到 $0$ 时小青蛙不能再跳到这块石头上$($某次跳跃后使石头高度下降到 $0$ 是允许的$)$。

  小青蛙一共需要去学校上 $x$ 天课，所以它需要往返 $2x$ 次。当小青蛙具有一个跳跃能力 $y$ 时，它能跳不超过 $y$ 的距离。

  请问小青蛙的跳跃能力至少是多少才能用这些石头上完 $x$ 次课。

【输入格式】

  输入的第一行包含两个整数 $n,x$，分别表示河的宽度和小青蛙需要去学校的天数。请注意 $2x$ 才是实际过河的次数。

  第二行包含 $n-1$ 个非负整数 $H_1,H_2,\cdots ,H_{n-1}$，其中 $H_i>0$ 表示在河中与小青蛙的家相距 $i$ 的地方有一块高度为 $H_i$ 的石头，$H_i=0$ 表示这个位置没有石头。

【输出格式】

  输出一行，包含一个整数，表示小青蛙需要的最低跳跃能力。

【样例输入】

5 1
1 0 1 0

【样例输出】

4

【样例解释】
  由于只有两块高度为 $1$ 的石头，所以往返只能各用一块。第 $1$ 块石头和对岸的距离为 $4$，如果小青蛙的跳跃能力为 $3$ 则无法满足要求。所以小青蛙最少需要 $4$ 的跳跃能力。

【评测用例规模与约定】

  对于 $30\%$ 的评测用例，$n\le 100$；
  对于 $60\%$ 的评测用例，$n\le 1000$；
  对于所有评测用例，$1\le n\le 10^5,1\le x\le 10^9,1\le H^i\le 10^4$。

---

二分最大流

---

  可以将转成最大流模型，然后二分答案。

  但应付 $10^5$ 的数据还是显得捉襟见肘，

  摆了，不写了。

---

试题  I: 因数平方和

时间限制: $1.0\mathrm{s}$ 内存限制: $512.0\mathrm{M}\mathrm{B}$ 本题总分：$25$ 分

---

【问题描述】

  记 $f(x)$ 为 $x$ 的所有因数的平方的和。例如$：f(12)=1^2+2^2+3^2+4^2+6^2+12^2$。

  定义 $g(n)={\sum }_{i=1}^{n}f(i)$。给定 $n$， 求 $g(n)$ 除以 $10^9+7$ 的余数。

【输入格式】

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

【输出格式】

  输出一个整数表示答案 $g(n)$ 除以 $10^9+7$ 的余数。

【样例输入】

100000

【样例输出】

680584257

【评测用例规模与约定】

  对于 $20\%$ 的评测用例，$n\le 10^5$。
  对于 $30\%$ 的评测用例，$n\le 10^7$。
  对于所有评测用例，$1\le n\le 10^9$。

---

数论分块

---

  根据倍数法求 $[1,n]$ 中每个数的因数的完备性可得知：

  $[1,n]$ 中因数有 $1$ 的数有 $\lfloor \frac{n}{1}\rfloor$ 个；
  $[1,n]$ 中因数有 $2$ 的数有 $\lfloor \frac{n}{2}\rfloor$ 个；
  $\cdots \cdots$
  $[1,n]$ 中因数有 $n$ 的数有 $\lfloor \frac{n}{n}\rfloor$ 个。

  于是我们可以将和式 $g(n)={\sum }_{i=1}^{n}f(i)$ 演绎为

  $\begin{array}{rl}g(n)& =\sum _{i=1}^n(\lfloor \frac{n}{i}\rfloor i^2)\\ & =\sum _{l|l\in \mathrm{u}\mathrm{n}\mathrm{i}\mathrm{q}\mathrm{u}\mathrm{e}\{\lfloor \frac{\mathrm{n}}{\mathrm{i}}\rfloor |\mathrm{i}\in [1,\mathrm{n}]\}}\left(\lfloor \frac{n}{\lfloor \frac{n}{l}\rfloor }\rfloor -l+1\right)(l^2+(l+1{)}^2+\cdots +{\lfloor \frac{n}{\lfloor \frac{n}{l}\rfloor }\rfloor }^2)\end{array}$

  求解。

  容易想到使用数论分块将和式计算的复杂度优化至 $O(\sqrt{n})$。

import java.io.StreamTokenizer;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.io.IOException;

public class Main {

    public static void main(String[] args) { new Main().run(); }

    int p = 1000000007, inv6 = 166666668;

    void run() {
        int n = nextInt();
        long tmp, sum = 0, ans = 0;
        for (int l = 1, r; l <= n; l = r + 1) {
            r = n / (n / l);
            tmp = sum;
            sum = r * (r + 1L) % p * (2 * r + 1) % p * inv6 % p;
            ans = (ans + (n / l) * (sum - tmp) + p) % p;
        }
        System.out.println(ans);
    }

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

    int nextInt() {
        try {
            in.nextToken();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return (int)in.nval;
    }
}

---

试题 J: 最长不下降子序列

时间限制: $1.0\mathrm{s}$ 内存限制: $512.0\mathrm{M}\mathrm{B}$ 本题总分：$25$ 分

---

【问题描述】

  给定一个长度为 $N$ 的整数序列$：A_1,A_2,\cdots ,A_N$。现在你有一次机会，将其中连续的 $K$ 个数修改成任意一个相同值。请你计算如何修改可以使修改后的数列的最长不下降子序列最长，请输出这个最长的长度。

  最长不下降子序列是指序列中的一个子序列，子序列中的每个数不小于在它之前的数。

【输入格式】

  输入第一行包含两个整数 $N$ 和 $K$。

  第二行包含 $N$ 个整数 $A_1,A_2,\cdots ,A_N$。

【输出格式】

  输出一行包含一个整数表示答案。

【样例输入】

5 1
1 4 2 8 5

【样例输出】

4

【评测用例规模与约定】

  对于 $20\%$ 的评测用例，$1\le K\le N\le 100$；
  对于 $30\%$ 的评测用例，$1\le K\le N\le 1000$；
  对于 $50\%$ 的评测用例，$1\le K\le N\le 10000$；
  对于所有评测用例，$1\le K\le N\le 10^5，1\le A_i\le 10^6$。

---

动态规划

---

  动态规划然后线性扫描一遍，吃个饭回来写。