2020年 第11届 蓝桥杯 Java B组 省赛真题详解及小结第1场省赛 2020.7.5
Posted 宇宙超级无敌狂拽霹雳魔法暴龙战神
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了2020年 第11届 蓝桥杯 Java B组 省赛真题详解及小结第1场省赛 2020.7.5相关的知识，希望对你有一定的参考价值。
目录
一、试题 A: 解密
本题总分：5 分
【问题描述】
小明设计了一种文章加密的方法：对于每个字母 c，将它变成某个另外的字符 Tc。下表给出了字符变换的规则：
例如，将字符串 YeRi 加密可得字符串 EaFn。
小明有一个随机的字符串，加密后为
EaFnjISplhFviDhwFbEjRjfIBBkRyY
（由 30 个大小写英文字母组成，不包含换行符），请问原字符串是多少？
（如果你把以上字符串和表格复制到文本文件中，请务必检查复制的内容是否与文档中的一致。在试题目录下有一个文件 str.txt，第一行为上面的字符串，后面 52 行依次为表格中的内容。）
【答案提交】
这是一道结果填空题，你只需要算出结果后提交即可。本题的结果为一个只包含 30 个大小写英文字母的字符串，在提交答案时只填写这个字符串，填写多余的内容将无法得分。
【答案】：YeRikGSunlRzgDlvRwYkXkrGWWhXaA
二、试题 B: 纪念日
本题总分：5 分
题目链接：2020年 第11届 蓝桥杯 C/C++ B组 省赛真题详解及小结【第1场省赛2020.7.5】【Java版】
【答案】：52038720
三、试题 C: 合并检测
本题总分：10 分
【答案】：10
四、试题 D: 分配口罩
本题总分：10 分
【问题描述】
某市市长获得了若干批口罩，每一批口罩的数目如下：（如果你把以下文字复制到文本文件中，请务必检查复制的内容是否与文档中的一致。在试题目录下有一个文件 mask.txt，内容与下面的文本相同）
9090400
8499400
5926800
8547000
4958200
4422600
5751200
4175600
6309600
5865200
6604400
4635000
10663400
8087200
4554000
现在市长要把口罩分配给市内的 2 所医院。由于物流限制，每一批口罩只能全部分配给其中一家医院。市长希望 2 所医院获得的口罩总数之差越小越好。请你计算这个差最小是多少？
【答案提交】
这是一道结果填空题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
五、试题 E: 斐波那契数列最大公约数
本题总分：15 分
【问题描述】
斐波那契数列满足 F1 = F2 = 1，从 F3 开始有 Fn = Fn−1 + Fn−2。请你计算 GCD(F2020, F520)，其中 GCD(A, B) 表示 A 和 B 的最大公约数。
【答案提交】
这是一道结果填空题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
六、试题F: 分类计数
【问题描述】
输入一个字符串，请输出这个字符串包含多少个大写字母，多少个小写字母，多少个数字。
【输入格式】
输入一行包含一个字符串。
【输出格式】
输出三行，每行一个整数，分别表示大写字母、小写字母和数字的个数。
【样例输入】
1+a=Aab
【样例输出】
1 3 1
【评测用例规模与约定】
对于所有评测用例，字符串由可见字符组成，长度不超过 100。
自己的代码：
import java.io.*;
import java.math.BigInteger;
import java.util.*;
public class Main
static PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
static int N = (int)1e5 + 10;
public static void main(String[] args) throws NumberFormatException, IOException
char s[] = rd.nextLine().toCharArray();
int res_A = 0;
int res_a = 0;
int res_num = 0;
for(int i = 0 ; i < s.length ; i ++)
if(s[i] >= 'A' && s[i] <= 'Z') res_A ++;
if(s[i] >= 'a' && s[i] <= 'z') res_a ++;
if(s[i] >= '0' && s[i] <= '9') res_num ++;
pw.print(res_A + " " + res_a + " " + res_num);
pw.flush();
class MyComparator implements Comparator<Integer>
@Override
public int compare(Integer o1, Integer o2)
return o2 - o1;
class rd
static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
static StringTokenizer tokenizer = new StringTokenizer("");
static String nextLine() throws IOException return reader.readLine();
static String next() throws IOException
while(!tokenizer.hasMoreTokens()) tokenizer = new StringTokenizer(reader.readLine());
return tokenizer.nextToken();
static int nextInt() throws IOException return Integer.parseInt(next());
static double nextDouble() throws IOException return Double.parseDouble(next());
static long nextLong() throws IOException return Long.parseLong(next());
static BigInteger nextBigInteger() throws IOException
BigInteger d = new BigInteger(rd.nextLine());
return d;
class PII implements Comparable<PII>
long x,y;
public PII(long x ,long y)
this.x = x;
this.y = y;
public int compareTo(PII a)
if(this.y-a.y != 0)
return Math.toIntExact(this.y - a.y); //按x升序排序
else return Math.toIntExact(this.x - a.x); //如果x相同，按y升序排序
class Edge
int a,b,c;
public Edge(int a ,int b, int c)
this.a = a;
this.b = b;
this.c = c;
七、试题G: 八次求和
时间限制: 1.0s 内存限制: 512.0MB 本题总分：20 分
【问题描述】
给定正整数 n, 求
+
+ · · · +
mod 123456789 。其中 mod 表示取余。
【输入格式】
输入的第一行包含一个整数 n。
【输出格式】
输出一行，包含一个整数，表示答案。
【样例输入】
2
【样例输出】
257
【样例输入】
987654
【样例输出】
43636805
【评测用例规模与约定】
对于 20% 的评测用例，1 ≤ n ≤ 20。
对于 60% 的评测用例，1 ≤ n ≤ 1000。
对于所有评测用例，1 ≤ n ≤ 1000000。
自己的代码：
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;
public class Main
static PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
static int N = (int)1e5 + 10;
static int n;
static int w[] = new int[N];
public static void main(String[] args ) throws IOException
int n = rd.nextInt();
BigInteger sum = BigInteger.ZERO; // BigInteger初始成0，香的嘞
for(int i = 1 ; i <= n ; i ++)
BigInteger k = BigInteger.valueOf(i).multiply(BigInteger.valueOf(i)).multiply(BigInteger.valueOf(i)).multiply(BigInteger.valueOf(i)).multiply(BigInteger.valueOf(i)).multiply(BigInteger.valueOf(i)).multiply(BigInteger.valueOf(i)).multiply(BigInteger.valueOf(i));//不知道这个地方为为什么直接用pow（8）第二个样例结果不对
sum = sum.add(k);
pw.println(sum.mod(BigInteger.valueOf(123456789)));
pw.flush();
class rd
static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
static StringTokenizer tokenizer = new StringTokenizer("");
static String nextLine() throws IOException return reader.readLine();
static String next() throws IOException
while (!tokenizer.hasMoreTokens()) tokenizer = new StringTokenizer(reader.readLine());
return tokenizer.nextToken();
static int nextInt() throws IOException return Integer.parseInt(next());
static double nextDouble() throws IOException return Double.parseDouble(next());
static long nextLong() throws IOException return Long.parseLong(next());
static BigInteger nextBigInteger() throws IOException
BigInteger d = new BigInteger(rd.nextLine());
return d;
class PII
int x,y;
public PII(int x ,int y)
this.x = x;
this.y = y;
八、试题 H: 字符串编码
时间限制: 1.0s 内存限制: 512.0MB 本题总分：25 分
【问题描述】
小明发明了一种给由全大写字母组成的字符串编码的方法。对于每一个大写字母，小明将它转换成它在 26 个英文字母中序号，即 A → 1, B → 2, ... Z → 26。
这样一个字符串就能被转化成一个数字序列：
比如 ABCXYZ → 123242526。
现在给定一个转换后的数字序列，小明想还原出原本的字符串。当然这样的还原有可能存在多个符合条件的字符串。小明希望找出其中字典序最大的字符串。
【输入格式】
一个数字序列。
【输出格式】
一个只包含大写字母的字符串，代表答案。
【样例输入】
123242526
【样例输出】
LCXYZ
【评测用例规模与约定】
对于 20% 的评测用例，输入的长度不超过 20。
对于所有评测用例，输入的长度不超过 200000。
自己的代码：
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;
public class Main
static PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
static Map<String,Character> map = new HashMap<>();
static List<Character> list = new ArrayList<>();
static void init()
map.put("1",'A');
map.put("2",'B');
map.put("3",'C');
map.put("4",'D');
map.put("5",'E');
map.put("6",'F');
map.put("7",'G');
map.put("8",'H');
map.put("9",'I');
map.put("10",'J');
map.put("11",'K');
map.put("12",'L');
map.put("13",'M');
map.put("14",'N');
map.put("15",'O');
map.put("16",'P');
map.put("17",'Q');
map.put("18",'R');
map.put("19",'S');
map.put("20",'T');
map.put("21",'U');
map.put("22",'V');
map.put("23",'W');
map.put("24",'X');
map.put("25",'Y');
map.put("26",'Z');
public static void main(String[] args) throws IOException
init();
String s = rd.nextLine();
int i = 0;
while(i != s.length())
if(s.substring(i,i + 2).compareTo("0") >= 0 && s.substring(i,i + 2).compareTo("26") <= 0 && i != s.length() - 1) // 子串字典序"1"~“26”，i != s.length() - 1是防止最后剩下一个数字字符，然后i指针跳两下，就寄了
list.add(map.get(s.substring(i,i + 2))); // 将该字符子串加入list
i += 2;
else
list.add(map.get(s.substring(i,i + 1)));
i += 1;
for(Character c: list) pw.print(c);
pw.flush();
class rd
static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
static StringTokenizer tokenizer = new StringTokenizer("");
static String nextLine() throws IOException return reader.readLine();
static String next() throws IOException
while (!tokenizer.hasMoreTokens()) tokenizer = new StringTokenizer(reader.readLine());
return tokenizer.nextToken();
static int nextInt() throws IOException return Integer.parseInt(next());
static double nextDouble() throws IOException return Double.parseDouble(next());
static long nextLong() throws IOException return Long.parseLong(next());
static BigInteger nextBigInteger() throws IOException
BigInteger d = new BigInteger(rd.nextLine());
return d;
class PII implements Comparable<PII>
int x,y;
public PII(int x ,int y)
this.x = x;
this.y = y;
@Override
public int compareTo(PII o)
return this.x - o.x;
九、试题 I: BST 插入节点问题
时间限制: 1.0s 内存限制: 512.0MB 本题总分：25 分
【问题描述】
给定一棵包含 N 个节点的二叉树，节点编号是 1 ∼ N。其中 i 号节点具有权值
，并且这些节点的权值恰好形成了一棵排序二叉树 (BST)。
现在给定一个节点编号 K，小明想知道，在这 N 个权值以外，有多少个整数 X (即 X 不等于任何
例如在下图中，括号外的数字表示编号、括号内的数字表示权值。即编号 1 ∼ 4 的节点权值依次是 0、10、20、30。
如果 K = 1，那么答案为 0。因为 1 号节点已经有左右子节点，不能再增加子节点了。
如果 K = 2，那么答案为无穷多。因为任何一个负数都可以作为 2 的左子节点。
如果 K = 3，那么答案为 9。因为 X = 11, 12, · · · , 19 都可以作为 3 的左子节点。
【输入格式】
第一行包含 2 个整数 N 和 K。
以下 N 行每行包含 2 个整数，其中第 i 行是编号为 i 的节点的父节点编号 Pi 和权值
输入保证是一棵 BST。
【输出格式】
一个整数代表答案。如果答案是无穷多，输出 −1。
【样例输入】
4 3
0 10
1 0
1 20
3 30
【样例输出】
9
【评测用例规模与约定】
对于 60% 的评测用例，1 ≤ K ≤ N ≤ 100，0 ≤
对于所有评测用例，1 ≤ K ≤ N ≤ 10000，0 ≤
十、试题 J: 网络分析
时间限制: 1.0s 内存限制: 256.0MB 本题总分：25 分
【问题描述】
小明正在做一个网络实验。
他设置了 n 台电脑，称为节点，用于收发和存储数据。
初始时，所有节点都是独立的，不存在任何连接。
小明可以通过网线将两个节点连接起来，连接后两个节点就可以互相通信了。两个节点如果存在网线连接，称为相邻。
小明有时会测试当时的网络，他会在某个节点发送一条信息，信息会发送到每个相邻的节点，之后这些节点又会转发到自己相邻的节点，直到所有直接或间接相邻的节点都收到了信息。所有发送和接收的节点都会将信息存储下来。一条信息只存储一次。
给出小明连接和测试的过程，请计算出每个节点存储信息的大小。
【输入格式】
输入的第一行包含两个整数 n, m，分别表示节点数量和操作数量。节点从 1 至 n 编号。
接下来 m 行，每行三个整数，表示一个操作。
如果操作为 1 a b，表示将节点 a 和节点 b 通过网线连接起来。当 a = b 时，表示连接了一个自环，对网络没有实质影响。
如果操作为 2 p t，表示在节点 p 上发送一条大小为 t 的信息。
【输出格式】
输出一行，包含 n 个整数，相邻整数之间用一个空格分割，依次表示进行完上述操作后节点 1 至节点 n 上存储信息的大小。
【样例输入】
4 8
1 1 2
2 1 10
2 3 5
1 4 1
2 2 2
1 1 2
1 2 4
2 2 1
【样例输出】
13 13 5 3
【评测用例规模与约定】
对于 30% 的评测用例，1 ≤ n ≤ 20，1 ≤ m ≤ 100。
对于 50% 的评测用例，1 ≤ n ≤ 100，1 ≤ m ≤ 1000。
对于 70% 的评测用例，1 ≤ n ≤ 1000，1 ≤ m ≤ 10000。
对于所有评测用例，1 ≤ n ≤ 10000，1 ≤ m ≤ 100000，1 ≤ t ≤ 100。
小结
仔细、认真，注意日期类、大整数BigInteger的使用。
2022 第十三届蓝桥杯大赛软件赛省赛（第二场），C/C++ 大学B组题解
2022 第十三届蓝桥杯大赛软件赛省赛（第二场），C/C++ 大学B组题解
文章目录
补题链接：地址
第1题 —— 练习 （5分）
- 题意：过了样例交上去0分，问可能是ABC的哪一种
- 显然都是，答案：ABC
#include <iostream>
using namespace std;
int main()
// 请在此输入您的代码
cout<<"ABC";
return 0;
第2题 —— 三角回文数 （5分）
-
题意：求第一个大于某2e8的数的回文数，且满足他可以等于1+2+…某个k。
-
一种是从2e8开始往上枚举，判断每个数是不是回文+三角，三角可以根号再乘附近的几个数特判一下。
另一种是枚举三角，1+2+…k，判断是不是回文和大于2e8，+k加到后面就是指数级了，上升也很快。 -
答案：35133153
#include<bits/stdc++.h>
using namespace std;
int main()
int x = 0;
for(int i = 1; ; i++)
x += i;
if(x <= 20220514)continue;
string s = to_string(x);
string t = s;
reverse(t.begin(),t.end());
if(s==t)break;
cout<<x<<"\\n";
return 0;
第3题 —— 卡片 （10分）
- 题意：n个人，给每个人随机发两张卡片（可以相同，没有顺序），求至少需要有多少种卡片，才能让n个人拿到的卡片组合都不同。
- 看一下样例，明显C（k,2）>=n，求k。(k-1)k/2>=n，可以跟上一题一样枚举，a[i]=a[i-1]+1递推上去即可。
#include<bits/stdc++.h>
using namespace std;
int main()
int n; cin>>n;
int i, x = 0;
for(i = 1; ; i++)
x += i;
if(x < n)continue;
break;
cout<<i<<"\\n";
return 0;
第4题 —— 考勤刷卡 （10分）
- 题意：n（1e4）条考勤记录，按顺序输出每个考勤了的员工的编号。
- 丢到set里输出就行，时间不用管。
#include<bits/stdc++.h>
using namespace std;
int main()
int n; cin>>n;
set<int>se;
for(int i = 1; i <= n; i++)
string t; int id; cin>>t>>id;
se.insert(id);
for(auto x : se)
cout<<x<<"\\n";
return 0;
第5题 —— 最大和 （15分）
- 题意：1-n共n个格子，每个格子有个分数（可能负数），开始站在1，下次可以跳到p+1到p+D(n-p)中的任意格子，D(x)为x的最小质因数，问能获得的最大分是多少。
- 数据范围n是1e4，感觉是个dp，状态到n为止能获得的最大分。 宝物绝对值不超过1e5，暴力转移的时候质因数分解logn（或者根号n直接暴力1e3最小质因数也可以的）， nlogn刚好可以过。
#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5+10;
int a[maxn], f[maxn];
int isprime(int x) //判断素数
for(int i = 2; i*i <= x; i++)
if(x%i==0)return 0;
return 1;
int find(int x)//找最小质因数
if(x==0 || x==1)return x;
for(int i = 2; i*i <= x; i++)
if(x%i==0 && isprime(i))return i;
int main()
int n; cin>>n;
for(int i = 1; i <= n; i++)cin>>a[i];
memset(f, 0xc0, sizeof(f));
f[1] = a[1];
for(int i = 1; i <= n; i++)
int x = i+find(n-i); //最小质因数
for(int j = i+1; j <= x; j++)
f[j] = max(f[j], f[i]+a[j]);
cout<<f[n]<<"\\n";
return 0;
第6题 —— 染色时间 （15分）
- 题意：给出nm的棋盘，初始都是白色，每个格子被染色后等aij秒变色，变色后对四周的格子都染色，每个格子只能被染色一次。时刻0对a00染色，求多少时间染完棋盘。
- 感觉暴力bfs遍历就行，加个堆每次取出当前最早变色的格子出来给周围的染一下，然后维护下每个格子有没有都被染过就行。数据范围500可以说是随便怎么写都行了。
#include<bits/stdc++.h>
using namespace std;
const int maxn = 510;
int a[maxn][maxn], vis[maxn][maxn];
struct nodeint x, y, time;; //完成变色的时间
bool operator < (node a, node b) return a.time > b.time;
priority_queue<node, vector<node>, less<node> >q;
int dx[] = 0,0,1,-1 ;
int dy[] = 1,-1,0,0 ;
int main()
int n, m; cin>>n>>m;
for(int i = 1; i <= n; i++)
for(int j = 1; j <= m; j++)
cin>>a[i][j];
int res = 0;
q.push((node)1, 1, a[1][1]);
vis[0][0] = 1;
while(q.size())
node t = q.top(); q.pop();
res = max(res, t.time);
for(int i = 0; i < 4; i++)
int nx = t.x+dx[i], ny = t.y+dy[i];
if(nx>=1&&nx<=n && ny>=1&&ny<=m && vis[nx][ny]==0)//没染过色
vis[nx][ny] = 1;
q.push((node)nx,ny, t.time+a[nx][ny]);
cout<<res<<"\\n";
return 0;
第7题 —— k 倍区间 （20分）
- 题意： 给出一个序列和一个k，求有多少个子区间的区间和是k的整数倍。
- 数据范围1e5，枚举所有区间是做不到了的， nlogn估计往数据结构去想，但是求子区间和无非也就是差分前缀和。
- 考虑前缀和求区间和，a[r]-a[l-1]是k的倍数，那么只要%k余数相同就好了，不难处理出过程中的前缀和值，然后前面有多少个跟当前%k余数相同的值，就是有多少个区间，扫一遍O(n)就行了（当然排序二分也是可以的，复杂度都一样，map查询logn，大家半斤八两）。
- 注意到一个坑点，不能是负整数倍，所以不能简单的累加，每次要遍历一遍%k余数的，要满足前面那个数比当前这个大才行。还有就是1e9的前缀和要开longlong。
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
map<int,vector<LL>>mp; //mp[x]: 维护余数为x的前缀和有哪些
LL s[4]; //前缀和, 滚动数组
int main()
int n, k; cin>>n>>k;
LL ans = 0;
mp[0].push_back(0); //别忘了
for(int i = 1; i <= n; i++)
int x; cin>>x;
s[i%2] = s[(i-1+2)%2]+x;
int r = (s[i%2]%k+k)%k; //%k余数
int len = mp[r].size();
for(int j = 0; j < len; j++)
if(mp[r][j] <= s[i%2])ans++;
// sort(mp[r].begin(), mp[r].end());
// ans += upper_bound(mp[r].begin(), mp[r].end(), s[i%2])-mp[r].begin();
mp[r].push_back(s[i%2]);
cout<<ans<<"\\n";
return 0;
第8题 —— 选素数 （20分）
- 题意：给你两个数，s和t，每回合可以选一个小于s且不是s因数的素数p，然后找到p的倍数中刚好大于s的那个数y，并让s=y，进入下一回合。 求多少回合后s>t。
- 这题官网没有提交链接啊，代码补了对不对也不知道，我就不写了。。。（名正言顺的翘了摸鱼去了）
- 思路方向：
最大数据询问2e5，st 1e7，明显是个结论题， 可以找找规律。
20%的数据明显照着模拟就送。
50%数据500组，5e5，大概是优化下暴力，nlogn的复杂度，素数可以线性筛O(n)筛出来，个数大概是根号n，每次枚举每个素数，然后找倍数O1就够，如果满足条件就进入下一回合了，复杂度n根号n应该是可以拿到50%的。
或者，emmm，s-1，s-2这种很接近的数里应该有素数吧，并且肯定不是s的因数了，那么就O1过去了？ 结论的话，盲猜跟gcd有点关系，不知道对不对，可以找找规律蛤。
第9题 —— 第几小 （25分）
- 题意：给一个数组，支持单点修改，以及求区间中比a[p]小的数的个数, a[p]在区间内。n是1e5，操作是2e5。
- 思路：首先，感觉暴力扫区间乱搞之类的可以拿40%。。1e5这种明显数据结构，区间操作就线段树。分块之类的应该也可以，一下子没想到线段树怎么维护，主席树第k小值应该可以做，感觉都有点长懒得写了，直接放一个可以过的分块代码
//分块可以AC 20个点的块长， sqrt(n)*5
#include<bits/stdc++.h>
using namespace std;
int main()
ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
int n; cin>>n;
vector<int> a(n+1,0);
//分块
int len = sqrt(n)*5; //块长
int k = (n%len==0)?n/len:n/len+1;//块数
vector<int> block[k+1]; //本体
vector<int> belong(n+1,0);
int blockNum = 0;
for(int i=1;i<=n;i++) //分块
cin>>a[i];
blockNum=(i-1)/len+1;
belong[i]=blockNum;
block[blockNum].push_back(a[i]);
for(int i=1;i<=k;i++) //块排序
sort(block[i].begin(),block[i].end(),less<int>());
//输入操作
int m; cin>>m;
vector<vector<int>> op(m,vector<int>(4,0));
for(int i=0;i<m;i++)
cin>>op[i][0];
cin>>op[i][1]>>op[i][2];
if(op[i][0]==2)cin>>op[i][3];
//执行
vector<int> res;
for(int i = 0; i < m; i++)
int num1=op[i][1], num2=op[i][2], num3=op[i][3];
if(op[i][0]==1) //修改
auto it=lower_bound(block[belong[num1]].begin(),block[belong[num1]].end(),a[num1]);
block[belong[num1]].erase(it);
it=lower_bound(block[belong[num1]].begin(),block[belong[num1]].end(),num2);
if(it==block[belong[num1]].end())block[belong[num1]].push_back(num2);
else block[belong[num1]].insert(it,num2);
a[num1] = num2;
else //查询
int count = 0, mid = a[num3];
//先查左右两端分块中满足条件的元组数,因为num1和num2所在的块不一定一整块都参与比较
for(int j=num1;j<=min(num2,belong[num1]*len);j++)
if(a[j]<mid)count++;
if(belong[num1]!=belong[num2])
for(int j=(belong[num2]-1)*len+1;j<=num2;j++)
if(a[j]<mid)count++;
//区间查询,用二分法查询每个块中小于a[p]的元素个数
for(int j=belong[num1]+1;j<=belong[num2]-1;j++)
count+=lower_bound(block[j].begin(),block[j].end(),a[num3第12届蓝桥杯青少组steam测评开始报名，成绩优秀者方可报名省赛！
2022 第十三届蓝桥杯大赛软件赛省赛，C/C++ 大学B组题解