第十三届蓝桥杯大赛软件赛决赛（C/C++ 大学C组）

---

试题 A: 斐波那契与 7

本题总分：$5$ 分

---

【问题描述】

  斐波那契数列的递推公式为$：$$F_n=F_{n-1}+F_{n-2}$，其中 $F_1=F_2=1$。

  请问，斐波那契数列的第 $1$ 至 $202202011200$ 项（含）中，有多少项的个位是 $7$。

【答案提交】

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

---

26960268160

---

找循环节

---

  找到斐波那契数列在个位上的循环节，然后将答案拆分成三部分就完事了。

#include <stdio.h>

const long long n = 202202011200;

int map[10][10], sum[101];

int main() {
    int i = 1, x = 0, y = 1, z = 1;
    for (; !map[x][y]; ++i) {
        map[x][y] = 1;
        sum[i] = sum[i - 1] + (y == 7);
        x = y, y = z, z = (x + y) % 10;
    }
    printf("%lld",
            (n - map[x][y] + 1) / (i - map[x][y]) * (sum[i - 1] - sum[map[x][y] - 1])
            + sum[(n - map[x][y] + 1) % (i - map[x][y]) + map[x][y] - 1]
            );
}

---

试题 B: 小蓝做实验

本题总分：$5$ 分

---

【问题描述】

  小蓝很喜欢科研，他最近做了一个实验得到了一批实验数据，一共是两百万个正整数。如果按照预期，所有的实验数据 $x$ 都应该满足 $10^7\le x\le 10^8$。但是做实验都会有一些误差，会导致出现一些预期外的数据，这种误差数据 $y$ 的范围是 $10^3\le y\le 10^{12}$ 。由于小蓝做实验很可靠，所以他所有的实验数据中 $99.99\%$ 以上都是符合预期的。小蓝的所有实验数据都在 $primes.txt$ 中，现 在他想统计这两百万个正整数中有多少个是质数，你能告诉他吗？

【答案提交】

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

---

342693

---

欧拉筛

---

  首先排除 $\mathrm{Miller}$-$\mathrm{Robin}$，一般 $T$ 次询问的题目，$T$ 越大，对单次询问响应的复杂度要求越高，于是考虑欧拉筛线性筛出不大于 $1e8$ 的质数，$O(1)$ 响应 $99.99\%$ 的询问，而剩下询问中，$y$ 不会大于 $1e16$，利用因数的对称性，可以在 $O(\sqrt{y})$ 的复杂下响应。

#include <stdio.h>

const int N = 100000000;

int n, ans, p[5761456];

bool pb[N + 1];

int main() {
    for (int i = 2; i <= N; ++i) {
        if (!pb[i]) p[n++] = i;
        for (int j = 0; j < n; ++j) {
            if (i * p[j] > N) break;
            pb[i * p[j]] = 1;
            if (i % p[j] == 0) break;
        }
    }
    freopen("primes.txt", "r", stdin);
    for (long long i, n; ~scanf("%lld", &n);) {
        if (n > N) {
            for (i = 0; p[i] <= 1000000; ++i)
                if (n % p[i] == 0) break;
            if (p[i] > 1000000) ++ans;
        } else if (!pb[n]) ++ans;
    }
    printf("%d", ans);
}

---

试题 C: 取模

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

---

【问题描述】

  给定 $n,m$，问是否存在两个不同的数 $x,y$ 使得 $1\le x<y\le m$ 且 $n\mathrm{mod}x=n\mathrm{mod}y$。

【输入格式】

  输入包含多组独立的询问。

  第一行包含一个整数 $T$ 表示询问的组数。

  接下来 $T$ 行每行包含两个整数 $n,m$，用一个空格分隔，表示一组询问。

【输出格式】

  输出 $T$ 行，每行依次对应一组询问的结果。如果存在，输出单词 $\mathrm{Yes}$；如果不存在，输出单词 $\mathrm{No}$。

【样例输入】

3
1 2
5 2
999 99

【样例输出】

No
No
Yes

【评测用例规模与约定】

  对于 $20\%$ 的评测用例，$T\le 100，n,m\le 1000$；
  对于 $50\%$ 的评测用例，$T\le 10000，n,m\le 10^5$；
  对于所有评测用例，$1\le T\le 10^5，1\le n\le 10^9，2\le m\le 10^9$。

---

中国剩余定理

---

  依题意，对给定两个整数 $n,m$，$n\ge 1,m\ge 2$，判断其逆命题 $k=1,2,\cdots ,m$，$n\mathrm{mod}k$ 恰取遍 $[0,m-1]$ 是否成立，

  近一步引出等价逆命题，$n\mathrm{mod}k\equiv k-1$ 是否在 $k\in [1,m)$ 下都成立，因为 $n\mathrm{mod}1\equiv 0$，$n\mathrm{mod}2$ 若想使上述命题为真，只能取 $1$，以此类推。

  于是有同余方程组，当 $n$ 满足下列方程组时，无论如何也找不到两个不同的数 $x,y$ 使得 $1\le x<y\le m$ 且 $n\mathrm{mod}x=n\mathrm{mod}y$。$$\{\begin{array}{ll}n\equiv 1& (\mathrm{mod}2)\\ n\equiv 2& (\mathrm{mod}3)\\ ⋮& ⋮\\ n\equiv m-1& (\mathrm{mod}m)\end{array}$$  自顶向下合并同余方程 $2p-3q=2-1$，解得 $p=2,q=1$，代入 $\{\begin{array}{ll}n\equiv 2p+1& (\mathrm{mod}2)\\ n\equiv 3q+2& (\mathrm{mod}3)\end{array}$ 可得 $n\equiv 5(\mathrm{mod}\mathrm{lcm}(2,3)=6)$，假设 n = lcm ⁡ { k , 1 ≤ k ≤ m } − 1 n = \operatorname{lcm}\{k, 1\leq k \leq m\} - 1 n=lcm{k,1≤k≤m}−1，当 $m\le 3$ 时显然成立，考虑 $m+1$，联立同余方程： { n ≡ lcm ⁡ { k , 1 ≤ k ≤ m } − 1 ( m o d lcm ⁡ { k , 1 ≤ k ≤ m } ) n ≡ m ( m o d m + 1 ) \begin{cases} n \equiv \operatorname{lcm}\{k, 1\leq k \leq m\} - 1 & \pmod {\operatorname{lcm}\{k, 1\leq k \leq m\}} \\ n \equiv m & \pmod {m+1} \end{cases} {n≡lcm{k,1≤k≤m}−1n≡m​(modlcm{k,1≤k≤m})(modm+1)​  解： lcm ⁡ { k , 1 ≤ k ≤ m } p − ( m + 1 ) q = m − lcm ⁡ { k , 1 ≤ k ≤ m } + 1 \operatorname{lcm}\{k, 1\leq k \leq m\}p-(m+1)q = m -\operatorname{lcm}\{k, 1\leq k \leq m\}+1 lcm{k,1≤k≤m}p−(m+1)q=m−lcm{k,1≤k≤m}+1，得：$p=-1,q=-1$，联立可得 n ≡ − 1 ( m o d lcm ⁡ { k , 1 ≤ k ≤ m + 1 } ) n\equiv-1 \pmod {\operatorname{lcm}\{k, 1\leq k \leq m+1\}} n≡−1(modlcm{k,1≤k≤m+1})，即模 lcm ⁡ { k , 1 ≤ k ≤ m + 1 } \operatorname{lcm}\{k, 1\leq k \leq m+1\} lcm{k,1≤k≤m+1} 的加法逆元 lcm ⁡ { k , 1 ≤ k ≤ m + 1 } − 1 \operatorname{lcm}\{k, 1\leq k \leq m+1\}-1 lcm{k,1≤k≤m+1}−1。

  这启发了我们，只需枚举不超过 $22$ 个数（ lcm ⁡ { k , 1 ≤ k ≤ 23 } ≥ 1 e 9 \operatorname{lcm}\{k, 1\leq k \leq 23\} \geq 1e9 lcm{k,1≤k≤23}≥1e9），就可以判断 $n,m$ 是否满足上列同余式，继而判断 $n,m$ 是否满足原命题。

#include <stdio.h>

int _, n, m;

int main() {
    for (scanf("%d", &_); _--;) {
        scanf("%d %d", &n, &m);
        int flag = 0;
        if (m > 22) m = 22;
        for (int i = 2; i <= m; ++i)
            if (n % i != i - 1) flag = 1;
        puts(flag ? "Yes" : "No");
    }
}

---

试题 D: 内存空间

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

---

【问题描述】

  小蓝最近总喜欢计算自己的代码中定义的变量占用了多少内存空间。

  为了简化问题，变量的类型只有以下三种：

  $\mathrm{int}：$整型变量，一个 $\mathrm{int}$ 型变量占用 $4\mathrm{Byte}$ 的内存空间。
  $\mathrm{long}：$长整型变量，一个 $\mathrm{long}$ 型变量占用 $8\mathrm{Byte}$ 的内存空间。
  $\mathrm{String}：$字符串变量，占用空间和字符串长度有关，设字符串长度为 $L$，则字符串占用 $L\mathrm{Byte}$ 的内存空间，如果字符串长度为 $0$ 则占用 $0\mathrm{Byte}$ 的内存空间。

  定义变量的语句只有两种形式，第一种形式为$：$

$\mathrm{type}var1=value1,var2=value2\cdots ;$

  定义了若干个 $\mathrm{type}$ 类型变量 $var1$、$var2$、$\cdots$，并且用 $value1$、$value2\cdots$ 初始化，

  多个变量之间用 $’,’$ 分隔，语句以 $’;’$ 结尾，$\mathrm{type}$ 可能是 $\mathrm{int}$、$\mathrm{long}$ 或 $\mathrm{String}$。例如 $\mathrm{inta}=1,\mathrm{b}=5,\mathrm{c}=6;$ 占用空间为 $12\mathrm{Byte}$；$\mathrm{long}\mathrm{a}=1,\mathrm{b}=5;$ 占用空间为 $16\mathrm{Byte}$；$\mathrm{String}s1=””,s2=”hello”,s3=”world”;$ 占用空间为 $10\mathrm{Byte}$。

  第二种形式为$：$

$\mathrm{type}[]arr1=\mathrm{new}\mathrm{type}[size1],arr2=\mathrm{new}\mathrm{type}[size2]\cdots ;$

  定义了若干 $\mathrm{type}$ 类型的一维数组变量 $arr1$、$arr2\cdots$，且数组的大小为 $size1$、$size2\cdots$，多个变量之间用 $’,’$ 进行分隔，语句以 $’;’$ 结尾，$\mathrm{type}$ 只可能是 $\mathrm{int}$ 或 $\mathrm{long}$。例如 $\mathrm{int}[]a1=\mathrm{new}\mathrm{int}[10];$ 占用的内存空间为 $40\mathrm{Byte}$；$\mathrm{long}[]a1=\mathrm{new}\mathrm{long}[10],a2=\mathrm{new}\mathrm{long}[10];$ 占用的内存空间为 $160\mathrm{Byte}$。

  已知小蓝有 $T$ 条定义变量的语句，请你帮他统计下一共占用了多少内存空间。结果的表示方式为$：$$a\mathrm{GB}b\mathrm{MB}c\mathrm{KB}d\mathrm{B}$，其中 $a$、$b$、$c$、$d$ 为统计的结果，$\mathrm{GB}$、$\mathrm{MB}$、$\mathrm{KB}$、$\mathrm{B}$ 为单位。优先用大的单位来表示，$1GB=1024MB$，$1MB=1024KB$，$1KB=1024B$，其中 $B$ 表示 $\mathrm{Byte}$。如果 $a$、$b$、$c$、$d$ 中的某几个数字为 $0$，那么不必输出这几个数字及其单位。题目保证一行中只有一句定义变量的语句，且每条语句都满足题干中描述的定义格式，所有的变量名都是合法的且均不重复。题目中的数据很规整，和上述给出的例子类似，除了类型后面有一个空格，以及定义数组时 $\mathrm{new}$ 后面的一个空格之外，不会出现多余的空格。

【输入格式】

  输入的第一行包含一个整数 $T$ ，表示有 $T$ 句变量定义的语句。

  接下来 $T$ 行，每行包含一句变量定义语句。

【输出格式】

  输出一行包含一个字符串，表示所有语句所占用空间的总大小。

【样例输入 1】

1
long[] nums=new long[131072];

【样例输出 1】

1MB

【样例输入 2】

4
int a=0,b=0;
long x=0,y=0;
String s1="hello",s2="world";
long[] arr1=new long[100000],arr2=new long[100000];

【样例输出 2】

1MB538KB546B

【样例说明】
 样例 $1$，占用的空间为 $131072\times 8=1048576\mathrm{B}$，换算过后正好是 $1\mathrm{MB}$，其 它三个单位 $\mathrm{GB}$、$\mathrm{KB}$、$\mathrm{B}$ 前面的数字都为 $0$ ，所以不用输出。
 样例 $2$，占用的空间为 $4\times 2+8\times 2+10+8\times 100000\times 2B$，换算后是 $1\mathrm{MB}538\mathrm{KB}546\mathrm{B}$。

【评测用例规模与约定】

  对于所有评测用例，$1\le T\le 10$，每条变量定义语句的长度不会超过 $1000$。所有的变量名称长度不会超过 $10$，且都由小写字母和数字组成。对于整型变 量，初始化的值均是在其表示范围内的十进制整数，初始化的值不会是变量。 对于 $\mathrm{String}$ 类型的变量，初始化的内容长度不会超过 $50$，且内容仅包含小写 字母和数字，初始化的值不会是变量。对于数组类型变量，数组的长度为一个 整数，范围为$：$$[0,2^{30}]$，数组的长度不会是变量。$T$ 条语句定义的变量所占的内存空间总大小不会超过 $1\mathrm{GB}$，且大于 $0\mathrm{B}$。

---

  模拟题，没啥营养。

#include <stdio.h>

char code[1010], *unit[]{ "", "K", "M", "G" };;

int main() {
    long long n, size = 0;
    for (scanf("%d\n", &n); gets(code), n--;) {
        long long offset = 0;
        switch (code[0]) {
            case 'i': offset = 2;
            case 'l':
                if (!offset) offset = 3;
                if (code[4] == '[' || code[4] == ']') {
                    int arys = 0;
                    for (int i = 6; code[i]; ++i) {
                        if (code[i] == ']') size += arys << offset, arys = 0;
                        if (arys) arys = arys * 10 + code[i] - '0';
                        if (code[i] == '[') arys = 0x80000000;
                    }
                } else {
                    int cnt = 1;
                    for (int i = 6; code[i]; ++i)
                        if (code[i] == ',') ++cnt;
                    size += cnt << offset;
                }
                break;
            case 'S':
                for (int i = 6, j = 0, flag = 0; code[i]; ++i)
                    if (code[i] == '"') {
                        size += flag * (i - j - 1);
                        flag ^= 1;
                        j = i;
                    }
        }
    }
    for (int i = 30; i >= 0; i -= 10) {
        int d = size >> i & 0x3ff;
        if (d) printf("%d%sB", d, unit[i / 10]);
    }
}

---

试题 E: 斐波那契数组

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

---

【问题描述】

  如果数组 $A=(a_0,a_1,\cdots ,a_{n-1})$ 满足以下条件，就说它是一个斐波那契数组$：$

  $1.$ $n\ge 2$；
   $2.$ $a_0=a_1$；
  $3.$ 对于所有的 $i(i\ge 2)$，都满足 $a_i=a_{i-1}+a_{i-2}$。

  现在，给出一个数组 $A$ ，你可以执行任意次修改，每次修改将数组中的某个位置的元素修改为一个大于 $0$ 的整数。请问最少修改几个元素之后，数组 $A$ 会变成一个斐波那契数组。

【输入格式】

  输入的第一行包含一个整数 $n$，表示数组 $A$ 中的元素个数。

  第二行包含 $n$ 个整数 $a_0,a_1,\cdots ,a_{n-1}$，相邻两个整数之间用一个空格分隔。

【输出格式】

  输出一行包含一个整数表示最少需要修改数组 $A$ 中的几个元素之后，数组 $A$ 可以变为一个斐波那契数组。

【样例输入】

5
1 2 2 4 8

【样例输出】

3

【样例说明】
 将原数组修改为 $(1,1,2,3,5)$，最少修改三个元素变成了一个斐波那契数组。

【评测用例规模与约定】

  对于所有评测用例，$2\le n\le 10^5，1\le a_i\le 10^6$。

---

基本数论

---

  首先，$F_{31}>1e6$，而 $1\le a_i\le 10^6$，于是无论 $a_0,a_1$ 取哪个正整数，从 $A$ 的第 $30$ 项开始，所有的元素都需要修改，

  同时，令 $G$ 为 $G_1=G_2=g$ 的 “广义斐波那契数列”（这个名词其实已经被定义了），观察 $F$ 与 $G$ 各项$:$

  $G_1=g{F}_1$
  $G_2=g{F}_2$
  $G_3=g{F}_1+g{F}_2=g(F_1+F_2)=g{F}_3$
  $⋮$
  $G_n=g(F_{n-1}+F_{n-2})=g{F}_n$

  于是我们只需统计 $A$ 中，与 $F$ 比值出现频率最高的项集，然后将其的补集替换为对应的 “广义斐波那契数列” 就行了。

#include <stdio.h>
#include <map>

std::map<int, int> map;

int ans, a, max;

int main() {
    scanf("%d", &ans);
    int x = 0, y = 0, z = 1;
    for (int i = 0; i < 30; ++i) {
        if (scanf("%d", &a) <= 0) break;
        x = y, y = z, z = x + y;
        if (a % y) continue;
        int t = ++map[a / y];
        if (t > max) max = t, --ans;
    }
    printf("%d", ans);
}

---

试题 F: 近似 GCD

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

---

【问题描述】

  小蓝有一个长度为 $n$ 的数组 $A=(a_1,a_2,\cdots ,a_n)$，数组的子数组被定义为从原数组中选出连续的一个或多个元素组成的数组。数组的最大公约数指的是数组中所有元素的最大公约数。如果最多更改数组中的一个元素之后，数组的最大公约数为 $g$，那么称 $g$ 为这个数组的近似 $\mathrm{GCD}$。一个数组的近似 $\mathrm{GCD}$ 可能有多种取值。

  具体的，判断 $g$ 是否为一个子数组的近似 $\mathrm{GCD}$ 如下$：$

  $1.$ 如果这个子数组的最大公约数就是 $g$，那么说明 $g$ 是其近似 $\mathrm{GCD}$。
  $2.$ 在修改这个子数组中的一个元素之后（可以改成想要的任何值），子数组的最大公约数为 $g$，那么说明 $g$ 是这个子数组的近似 $\mathrm{GCD}$。

  小蓝想知道，数组 $A$ 有多少个长度大于等于 $2$ 的子数组满足近似 $\mathrm{GCD}$ 的值为 $g$。

【输入格式】

  输入的第一行包含两个整数 $n,g$，用一个空格分隔，分别表示数组 $A$ 的长度和 $g$ 的值。

  第二行包含 $n$ 个整数 $a_1,a_2,\cdots ,a_n$，相邻两个整数之间用一个空格分隔。

【输出格式】

  输出一行包含一个整数表示数组 $A$ 有多少个长度大于等于 $2$ 的子数组的近似 $\mathrm{GCD}$ 的值为 $g$。

【样例输入】

5 3
1 3 6 4 10

【样例输出】

5

【样例说明】
  满足条件的子数组有 $5$ 个$：$
  $[1,3]$$：$将 $1$ 修改为 $3$ 后，这个子数组的最大公约数为 $3$，满足条件。
  $[1,3,6]$$：$将 $1$ 修改为 $3$ 后，这个子数组的最大公约数为 $3$，满足条件。
  $[3,6]$$：$这个子数组的最大公约数就是 $3$，满足条件。
  $[3,6,4]$$：$将 $4$ 修改为 $3$ 后，这个子数组的最大公约数为 $3$，满足条件。
  $[6,4]$$：$将 $4$ 修改为 $3$ 后，这个子数组的最大公约数为 $3$，满足条件。

【评测用例规模与约定】

  对于 $20\%$ 的评测用例，$2\le n\le 10^2$；
  对于 $40\%$ 的评测用例，$2\le n\le 10^3$；
  对于所有评测用例，$2\le n\le 10^5，1\le g,a_i\le 10^9$。

---

基本数论

---

  $\gcd$ 是一种满足结合律的运算，即 $\gcd (a,b,c)=\gcd (\gcd (a,b),c)$，若一个序列中所有元素与 $g$ 的 $\gcd$ 都为 $g$，则这个序列的所有子序列任取一个元素修改为 $g$ 都满足题意，这个序列在某一侧添加一个 $g$ 也满足题意，双指针枚举累计以当前元素结尾的满足题意序列的个数即可。

#include <stdio.h>

int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }

int n, g, a, last;

int main() {
    scanf("%d %d", &n, &g);
    long long ans = -n;
    for (int i = 1, j = 0; i <= n; ++i) {
        scanf("%d", &a);
        if (gcd(a, g) != g) j = last, last = i;
        ans += i - j;
    }
    printf("%lld", ans);
}

  上示程序中last维护着最后一个不满足 $\gcd ($last$,g)$ 的变量，j则是最后一个，于是以当前第i个元素为尾能组成的满足题意的序列个数为i$-$j$-1$，其中 $-1$ 为排除长度为 $1$ 的序列，共有 $n$ 个，初始化在ans里就完了。

---

试题 G: 数组个数

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

---

【问题描述】

  小蓝有一个长度为 $n$ 的数组 $B=(b_0,b_1,\cdots ,b_{n-1})$，数组 $B$ 是由另一个长度为 $n$ 的环形数组 $A=(a_0,a_1,\cdots ,a_{n-1})$ 经过一次相邻最大化操作得到的，其中 $a_i$ 与 $a_{i+1}$ 相邻，$a_0$ 与 $a_{n-1}$ 相邻。

  形式化描述为$：$ $$b_i=\{\begin{array}{ll}\max (a_{n-1},a_0,a_1),& (i=0);\\ \max (a_{i-1},a_i,a_{i+1}),& (0<i<n-1);\\ \max (a_{n-2},a_{n-1},a_0),& (i=n-1).\end{array}$$  小蓝想知道，可能有多少个满足条件的数组 $A$，经过一次相邻最大化操作后能得到数组 $B$，注意 $A$ 中的每个元素都要求为非负整数。

【输入格式】

  输入的第一行包含一个整数 $n$，表示数组长度。

  第二行包含 $n$ 个整数 $b_0,b_1,\cdots ,b_{n-1}$，相邻两个整数之间用一个空格分隔。

【输出格式】

  输出一行包含一个整数表示答案，答案可能很大，请输出答案除以 $1000000007$ 后的余数。

【样例输入】

5
8 6 1 8 8

【样例输出】

7

【样例说明】
  可能的 $A$ 数组有 $7$ 个$：$$(6,0,0,1,8)$、$(6,0,1,0,8)$、$(6,0,1,1,8)$、$(6,1,0,0,8)$、$(6,1,0,1,8)$、$(6,1,1,0,8)$、$(6,1,1,1,8)$。

【评测用例规模与约定】

  对于 $30\%$ 的评测用例，$3\le n\le 10$；
  对于 $60\%$ 的评测用例，$3\le n\le 100$；
  对于所有评测用例，$3\le n\le 1000，0\le b_i\le 10$。

---

动态规划

---

  一定存在最小的索引 $i$，对某个序列 $A$ 的任意索引 $j$ 满足 $a_i\ge a_j$，显然当 $A$ 进行一次相邻最大化操作后得到的序列 $B$ 中，$b_{i-1\mathrm{mod}n}=b_i=b_{i+1\mathrm{mod}n}=a_i$。反之对于给定的序列 $B$，也一定存在最小的索引 $i^{\prime }$，对任意索引 $j^{\prime }$ 满足 $a_{i^{\prime }}\ge a_{j^{\prime }}$，在不考虑 $b_0=b_{n-1}$ 的情况下显然有 $b_{i^{\prime }-1\mathrm{mod}n}<b_{i^{\prime }}$，显然 $b_{i^{\prime }}$ 不能由 $a_{i^{\prime }-1\mathrm{mod}n}、a_{i^{\prime }}$ 确定，这样会使 $b_{i^{\prime }-1\mathrm{mod}n}=b_{i^{\prime }}$，因此 $a_{i^{\prime }+1\mathrm{mod}n}$ 与 $b_{i^{\prime }}$ 相互唯一确定，我们可以根据这个性质将题目给定的序列 $B$ 的环拆开。

  然后定义 $f_{i,j}$ 为长度为 $i$ 的可以确定 $B$ 长度为 $i+j-1$ 的前缀的序列个数，我们将 $B$ 从 $i^{\prime }\sim i^{\prime }+1$ 处断开，显然 $f_{i^{\prime }+1,2}=1$，以 $(8,6,1,8,8)$为例，拆开环后为序列 { 8 , 8 , 6 , 1 , 8 } \{8,8,6,1,8\} {8,8,6,1,8}，第一位只能填 $8$，可以确定长度为 $1+2-1$ 的前缀 { 8 , 8 } \{8,8\} {8,8}，因此 $f_{i^{\prime },2}=1$。

  因为 $\max (b_i)=10$，它的规模很小，所以我们可以对每一个 $i$ 都枚举可能的 $b_i$ 然后去累计它加入后能拼凑起 $B$ 到某个长度的方案数即可，代码写的太大坨了就不用文字具体描述了，总之算法复杂度为 $O(N\max (b_i))$。

#include <stdio.h>

const int mod = 1000000007;

int n, m, b[2022], dp[2022][3];

int main() {
    scanf("%d", &n);
    for (int i = 0; i < n; ++i) {
        scanf("%d", &b[i]), b[n + i] = b[i];
        if (b[i] > b[m]) m = i;
    }
    if (!m) for (int i = n - 1; i && b[i] == b[m]; --i) m = i;
    if (m == n - 1) m = 0;
    else n += ++m;
    dp[m][2] = 1;
    for (int i = m + 1; i < n; ++i)
        for (int k = 0; k <= 10; ++k) {
            if (k < b[i - 1] && k < b[i] && k < b[i + 1]) {
                dp[i][0] = (dp[i][0] + dp[i - 1][1]) % mod;
                dp[i][1] = (dp[i][1] + dp[i - 1][2]) % mod;
            } else if (k == b[i + 1] && k <= b[i - 1] && k <= b[i]) {
                dp[i][2] = (dp[i][2] + dp[i - 1][2]) % mod;
                if (k == b[i - 1]) dp[i][2] = (dp[i][2] + dp[i - 1][0]) % mod;
                if (k == b[i]) dp[i][2] = (dp[i][2] + dp[i - 1][1]) % mod;
            } else if (k == b[i] && k <= b[i - 1] && k <= b[i + 1]) {
                dp[i][1] = ((long long) dp[i][1] + dp[i - 1][1] + dp[i - 1][2]) % mod;
                if (k == b[i - 1]) dp[i][1] = (dp[i][1] + dp[i - 1][0]) % mod;
            } else if (k == b[i - 1] && k <= b[i] && k <= b[i + 1]) {
                dp[i][0] = ((long long) dp[i][0] + dp[i - 1][0] + dp[i - 1][1] + dp[i - 1][2]) % mod;
            } else break;
        }
    printf("%d", dp[n - 1][0]);
}

---

试题 H: 六六大顺

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

---

【问题描述】

  六六大顺，本指农历六月初六。多用于祝福中年人士家庭幸福，工作顺利， 事业有成，身体健康。源自《左传》“君义，臣行，父慈，子孝，兄爱，弟敬， 此数者累谓六顺也。”

  $6$ 在我国自古以来是一个吉祥的数字，定义数列 $A=(a_1,a_2,\cdots ,a_i,\cdots )$，其中 $a_1=6,a_2=66,\cdots ,a_i=10\cdot a_{i-1}+6$。

  定义一个数列 $B=(b_1,b_2,\cdots ,b_i,\cdots )$，其中 $b_1 = $6\times 6,b_2=66\times 66,\cdots ,b_i=a_i\cdot a_i$。

  现在小蓝想知道数列 $B$ 的前 $n$ 项的和是多少，你能帮帮小蓝吗？

【输入格式】

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

【输出格式】

  输出一行包含一个整数表示数列 $B$ 前 $n$ 项的和。

【样例输入】

3

【样例输出】

447948

【样例说明】
  $b_1=6\times 6=36,b_2=66\times 66=4356,b_3=666\times 666=443556$，所以前三项的和为 $36+4356+443556=447948$。

【评测用例规模与约定】

  对于 $20\%$ 的评测用例，$1\le n\le 100$；
  对于 $50\%$ 的评测用例，$1\le n\le 100000$；
  对于所有评测用例，$1\le n\le 10000000$。

---

找规律

---

  $b_i=\frac{4}{9}{\underset{\text{i}}{\underbrace{9\cdots 9}}}^2=\frac{4}{9}(10^i-1{)}^2=\frac{4}{9}(10^{2i}-2\times 10^i+1)$.

  ${\sum }_{i=1}^n{b}_i=\frac{4}{9}{\sum }_{i=1}^n(10^{2i}-2\times 10^i+1)=\frac{4}{9}(\underset{\text{2n+1}}{\underbrace{1010\cdots 100}}-\underset{\text{n+1}}{\underbrace{22\cdots 20}}+n)$.

  高精度嗯算就完了。

#include <stdio.h>

int n, mag[20000001];

int main() {
    scanf("%d", &n);
    mag[0] = 4 * n % 10, mag[1] = 4 * n / 10;
    for (int i = 1; i <= n; ++i) {
        mag[i << 1] = 4, mag[i] -= 8;
        mag[i + 1] += mag[i] / 10, mag[i] %= 10;
        if (mag[i] < 0)
            mag[i] += 10, --mag[i + 1];
    }
    for (int i = n + 1, t; mag[i] < 0; ++i)
        mag[i + 1] += mag[i] / 10, mag[i] %= 10,
        mag[i] += 10, --mag[i + 1];
    for (int i = 2 * n - 1; ~i; --i) {
        mag[i] += 10 * mag[i + 1];
        putchar(mag[i] / 9 + ' 0');
        mag[i] %= 9;
    }
}

---

试题  I: 打折

时间限制: $2.0\mathrm{s}$ 内存限制: $256.0\mathrm{MB}$ 本题总分：$25$ 分

---

【问题描述】

  小蓝打算采购 $n$ 种物品，每种物品各需要 $1$ 个。

  小蓝所住的位置附近一共有 $m$ 个店铺，每个店铺都出售着各种各样的物品。

  第 $i$ 家店铺会在第 $s_i$ 天至第 $t_i$ 天打折，折扣率为 $p_i$，对于原件为 $b$ 的物品，折后价格为 $\lfloor \frac{b\cdot p_j}{100}\rfloor$。其它时间需按原价购买。

  小蓝很忙，他只能选择一天的时间去采购这些物品。请问，他最少需要花多少钱才能买到需要的所有物品。

  题目保证小蓝一定能买到需要的所有物品。

【输入格式】

  输入的第一行包含两个整数 $n,m$，用一个空格分隔，分别表示物品的个数和店铺的个数。

  接下来依次包含每个店铺的描述。每个店铺由若干行组成，其中第一行包含四个整数 $s_i,t_i,p_i,c_i$，相邻两个整数之间用一个空格分隔，分别表示商店优惠的起始和结束时间、折扣率以及商店内的商品总数。之后接 $c_i$ 行，每行包含两个整数 $a_j,b_j$，用一个空格分隔，分别表示该商店的第 $j$ 个商品的类型和价格。商品的类型由 $1$ 至 $n$ 编号。

【输出格式】

  输出一行包含一个整数表示小蓝需要花费的最少的钱数。

【样例输入】

2 2
1 2 89 1
1 97
3 4 77 1
2 15

【样例输出】

101

【评测用例规模与约定】

  对于 $40\%$ 的评测用例，$n,m\le 500，s_i\le t_i\le 100，\Sigma c_i\le 2000$；
  对于 $70\%$ 的评测用例，$n,m\le 5000，\Sigma c_i\le 20000$；
  对于所有评测用例，$1\le n,m\le 100000，1\le c_i\le n，\Sigma c_i\le 400000，1\le s_i\le t_i\le 10^9，1<p_i<100，1\le a_j\le n，1\le b_j\le 10^9$。

---

  将商品拆分成三部分：打折前、打折中、打折后，然后用set维护最小值，再排序或用小根堆维护某个商店开始打折或结束打折时间，结合起来计算购买所有物品的最小花费更新答案，复杂度为 $O(\sum c_i\log m)$。
  由于打折后的物品在决策中一定在相同（同一家店的同一编号）物品前面，因此在打折时可用不用删除原价格。

#include <stdio.h>
#include <algorithm>
#include <set>

const int inf = 0x3f3f3f3f;

std::multiset<int> gms[100001];

struct node {
    int s, a, b;

    inline bool operator< (const node n) const { return s < n.s; }
} gds[800000];

int n, m, s, t, p, c, a, b, gs;

int main() {
    scanf("%d %d", &n, &m);
    for (int i = 0; i < m; ++i) {
        scanf("%d %d %d %d", &s, &t, &p ,&c);
        for (int j = 0; j < c; ++j) {
            scanf("%d %d", &a, &b);
            gms[a].insert(b);
            int pb = (long long) p * b / 100;
            gds[gs++] = { s, a, pb };
            gds[gs++] = { t + 1, a, -pb - 1 };
        }
    }
    std::sort(gds, gds + gs);
    long long sum = 0, ans = (long long) n * inf;
    for (int i = 1; i <= n; ++i) sum += *gms[i].begin();
    for (int i = 0, j; i < gs; i = j) {
        for (j = i; j < gs && gds[j].s == gds[i].s; ++j) {
            sum -= *gms[gds[j].a].begin();
            if (gds[j].b < 0) gms[gds[j].a].erase(gms[gds[j].a].find(-1 - gds[j].b));
            else gms[gds[j].a].insert(gds[j].b);
            sum += *gms[gds[j].a].begin();
        }
        ans = std::min(ans, sum);
    }
    printf("%lld", ans);
}

---

试题 J: 替换字符

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

---

【问题描述】

  给定一个仅含小写英文字母的字符串 $s$，每次操作选择一个区间 $[l_i,r_i]$ 将 $s$ 的该区间中的所有字母 $x_i$ 全部替换成字母 $y_i$，问所有操作做完后，得到的字符串是什么。

【输入格式】

  输入的第一行包含一个字符串 $s$。

  第二行包含一个整数 $m$。

  接下来 $m$ 行，每行包含 $4$ 个参数 $l_i,r_i,x_i,y_i$，相邻两个参数之间用一个空格分隔，其中 $l_i,r_i$ 为整数，$x_i,y_i$ 为小写字母。

【输出格式】

  输出一行包含一个字符串表示答案。

【样例输入】

abcaaea
4
1 7 c e
3 3 e b
3 6 b e
1 4 a c

【样例输出】

cbecaea

【评测用例规模与约定】

  对于 $40\%$ 的评测用例，$|s|,m\le 5000$；
  对于所有评测用例，$1\le |s|,m\le 10^5，1\le l_i\le r_i\le |s|，x_i,\ne y_i$，其中 $|s|$ 表示字符串 $s$ 的长度。

---

  记恒等函数 $\mathrm{id}(c)=c$，记函数序列 F = { f i = id ⁡ } , ∣ F ∣ = ∣ s ∣ F=\{f_i=\operatorname{id}\},|F|=|s| F={fi​=id},∣F∣=∣s∣，则 $s$ 可用通过 $F$ 逐位映射得到，即 $s={\mathrm{join}}_{i=1}^{|s|}{f}_i(s_i)$，其中 $\mathrm{join}$ 为字符串拼接操作，那么对 $s[l,r]$ 中 $x$ 替换成 $y$ 的操作可用变更为在 $F[l,r]$ 外复合上函数 $g(c)=\{\begin{array}{ll}y& \text{if }c=x\\ c& \text{otherwise}\end{array}$，即令 $f_i=g(f_i),l\le i\le r$。
  通过线段树维护 $F$，最终复杂度在 $O(Dm\log n)$，其中 $D$ 为 $f$ 的映射表大小，为 $26$。

#include <stdio.h>
#include <string.h>

char s[100015], &x = s[100005], &y = s[100010], f[1 << 18][26], *g = f[0];

bool id[1 << 18];

inline void composite(int g, int k) {
    if (id[k])
        for (int i = 0; i < 26; ++i) f[k][i] = f[g][f[k][i]];
    else
        memcpy(f[k], f[g], 26), id[k] = 1;
}

inline void push_down(int n) {
    if (id[n]) {
        composite(n, n << 1);
        composite(n, (n << 1) | 1);
        id[n] = 0;
    }
}

void modify(int n, int l, int r, int L, int R) {
    if (L <= l && R >= r) {
        composite(0, n);
        return;
    }
    push_down(n);
    int mid = (l + r) >> 1;
    if (mid >= L) modify(n << 1, l, mid, L, R);
    if (mid < R) modify((n << 1) | 1, mid + 1, r, L, R);
}

void print(int n, int l, int r) {
    if (l == r) {
        if (id[n]) putchar(f[n][s[l] - 'a'] + 'a');
        else putchar(s[l]);
    } else {
        push_down(n);
        int mid = (l + r) >> 1;
        print(n << 1, l, mid);
        print((n << 1) | 1, mid + 1, r);
    }
}

int m, l, r;

int main() {
    gets(s + 1);
    int n = strlen(s + 1);
    for (int i = 0; i < 26; ++i) g[i] = i;
    for (scanf("%d", &m); m--;) {
        scanf("%d %d %s %s", &l, &r, &x, &y);
        g[x - 'a'] = y - 'a';
        modify(1, 1, n, l, r);
        g[x - 'a'] = x - 'a';
    }
    print(1, 1, n);
}