AI测试1（CSP-J2022初赛、复赛认证）
xueyuhui917 · · 休闲·娱乐
为了测试AI们的水平，我们进行了AI测试。本次测试为第1场，测试题目为CSP-J2022初赛、复赛题目。
其中，由于AI很强（真的吗？），所有分数线全部以ZJ的为准。即，此次初赛晋级分数线为78.5分，复赛一等分数线250分。
另外，每一名AI选手都有一个以AI-J开头的准考证号，这个准考证号，初赛与复赛相同（这一点显然与真实的比赛不同）：
AI-J00001：ChatGPT https://chat-shared3.zhile.io/shared.html?v=2 镜像3.5版本。
AI-J00002：文心一言。
AI-J00003：MiniMax abab5.5。
答题过程
初赛
1.以下哪种功能没有涉及 C++ 语言的面向对象特性支持：（ ）。
A. C++ 中调用 printf 函数
B. C++ 中调用用户定义的类成员函数
C. C++ 中构造一个 class 或 struct
D. C++ 中构造来源于同一基类的多个派生类
ANS: A
AI-J00001: A
AI-J00002: A
AI-J00003: A
评价：这道题对于AI们来说太水了
2.有 6 个元素，按照 6,5,4,3,2,1 的顺序进入栈 S，请问下列哪个出栈序列是非法的（ ）。
A.5,4,3,6,1,2 B.4,5,3,1,2,6 C.3,4,6,5,2,1 D.2,3,4,1,5,6
ANS: C
AI-J00001: C&D
AI-J00002: C&D
AI-J00003: C
评价：看到AI-J00003的回答之前，我还特意看了一下D的选项（因为其他两个AI都说D有问题），结果D没问题，看来这题只有MiniMax对了。
3.运行以下代码片段的行为是（ ）。
int x = 101;
int y = 201;
int *p = &x;
int *q = &y;
p = q;
A. 将 x 的值赋为 201
B. 将 y 的值赋为 101
C. 将 q 指向 x 的地址
D. 将 p 指向 y 的地址
ANS: D
AI-J00001: D
AI-J00002: D
AI-J00003: D
4.链表和数组的区别包括（ ）。
A. 数组不能排序，链表可以
B. 链表比数组能存储更多的信息
C. 数组大小固定，链表大小可动态调整
D. 以上均正确
ANS: C
AI-J00001: C
AI-J00002: D
AI-J00003: C
评价：数组不能排序 -- by 文心一言
5.对假设栈 S 和队列 Q 的初始状态为空。存在 e1~e6 六个互不相同的数据，每个数据按照进栈 S、出栈 S、进队列 Q、出队列 Q 的顺序操作，不同数据间的操作可能会交错。已知栈 S 中依次有数据e1、e2、e3、e4、e5 和 e6 进栈，队列 Q 依次有数据 e2、e4、e3、e6、e5 和 e1 出队列。则栈 S 的容量至少是（ ）个数据。
A. 2 B. 3 C. 4 D. 6
ANS: B
AI-J00001: B
AI-J00002: C
AI-J00003: C
评价：至此，所有AI的AK梦破灭。
6.对表达式 a+(b-c)*d 的前缀表达式为（ ），其中 +、-、* 是运算符。
A. *+a-bcd B. +a*-bcd C. abc-d*+ D. abc-+d
ANS: B
AI-J00001: C
AI-J00002: B
AI-J00003: C
评价：论AI不知道什么是前缀表达式
7.假设字母表 {a,b,c,d,e} 在字符串出现的频率分别为 10%，15%，30%，16%，29%。若使用哈夫曼编码方式对字母进行不定长的二进制编码，字母 d 的编码长度（ ）位。
A. 1 B. 2 C. 2 或 3 D. 3
ANS: B
AI-J00001: C
AI-J00002: B
AI-J00003: D
评价：三个答案互不相同，但只有一个是对的
8.一棵有 n 个结点的完全二叉树用数组进行存储与表示，已知根结点存储在数组的第 1 个位置。若存储在数组第 9 个位置的结点存在兄弟结点和两个子结点，则它的兄弟结点和右子结点的位置分别是（ ）。
A. 8、18 B. 10、18 C. 8、19 D.10、19
ANS: C
AI-J00001: A（解析的回答是8、10，兄弟节点：
AI-J00002: D（父节点：
AI-J00003: C
评价：父子兄弟分不清
9.考虑由 N 个顶点构成的有向连通图，采用邻接矩阵的数据结构表示时，该矩阵中至少存在（ ）个非零元素。
A. N−1
B. N
C. N+1
D. N*N（原题是
ANS: B（因为是有向图。这里的连通指强连通，我就撞过这个坑，详见我写的游记）
AI-J00001: B
AI-J00002: C
AI-J00003: B
评价：好像没一个跟当时的我一样选了A的……还有两个AI对了，orz。
10.以下对数据结构的表述不恰当的一项为：（ ）。
A. 图的深度优先遍历算法常使用的数据结构为栈。
B. 栈的访问原则后进先出，队列的访问原则是先进先出。
C. 队列常常被用于广度优先搜索算法。
D. 栈与队列存在本质不同，无法用栈实现队列。
ANS: D
AI-J00001: D
AI-J00002: D
AI-J00003: D
11.以下哪组操作能完成在双向循环链表结点 p 之后插入结点 s 的效果（其中，next 域为结点的直接后继，prev 域为结点的直接前驱）：（ ）。
A. p->next->prev=s; s->prev=p; p->next=s; s->next=p->next;
B. p->next->prev=s; p->next=s; s->prev=p; s->next=p->next;
C. s->prev=p; s->next=p->next; p->next=s; p->next->prev=s;
D. s->next=p->next; p->next->prev=s; s->prev=p; p->next=s;
ANS: D
AI-J00001: C
AI-J00002: D
AI-J00003: C
12.以下排序算法的常见实现中，哪个选项的说法是错误的：（ ）。
A. 冒泡排序算法是稳定的
B. 简单选择排序是稳定的
C. 简单插入排序是稳定的
D. 归并排序算法是稳定的
ANS: B
AI-J00001: B
AI-J00002: B
AI-J00003: B
13.八进制数 32.1 对应的十进制数是（ ）。
A. 24.125 B. 24.250 C. 26.125 D. 26.250
ANS: C
AI-J00001: A
AI-J00002: C
AI-J00003: D
评价：论AI连八进制转十进制都不会
14.一个字符串中任意个连续的字符组成的子序列称为该字符串的子串，则字符串 abcab 有（ ）个内容互不相同的子串。
A. 12
B. 13
C. 14
D. 15
ANS: B
AI-J00001: B（但是是蒙的，因为它列举的互不相同的子串中有两个a和两个b什么的，列举严重错误，也算一种实力吧）
AI-J00002: B（也是蒙的，甚至把ac都归为其子串）
AI-J00003: C
评价：AI颠覆了我对子串的认知。
15.以下对递归方法的描述中，正确的是：（ ）。
A. 递归是允许使用多组参数调用函数的编程技术
B. 递归是通过调用自身来求解问题的编程技术
C. 递归是面向对象和数据而不是功能和逻辑的编程语言模型
D. 递归是将用某种高级语言转换为机器代码的编程技术
ANS: B
AI-J00001: B
AI-J00002: B
AI-J00003: B
选择题汇总：
AI-J00001:
AI-J00002:
AI-J00003:
总体评价：这三个AI，水平不相上下，但它们仅仅选择题就扣了至少
16.阅读以下代码，完成判断题和选择题。判断题对的选A，错的选B。
01 #include <iostream>
02
03 using namespace std；
04
05 int main()
06 {
07 unsigned short x, y；
08 cin >> x >> y；
09 x = (x | x << 2)& 0x33；
10 x = (x | x << 1)& 0x55；
11 y = (y | y << 2)& 0x33；
12 y = (y | y << 1)& 0x55；
13 unsigned short z = x | y << 1；
14 cout << z << endl；
15 return 0；
16 }假设输入的 x,y 均是不超过 15 的自然数。
(1)删去第7 行与第 13 行的 unsigned，程序行为不变。()
(2)将第 7 行与第 13 行的 short 均改为 char，程序行为不变。()
(3)程序总是输出一个整数“0”。()
(4)当输入为 2 2 时，输出为 10。()
(5)当输入为 2 2 时，输出为 59。()
(6)当输入为 13 8 时，输出为（ ）。
A.0
B.209
C.197
D.226
ANS: ABBBBB
AI-J00001: BABABB（6分）
AI-J00002: BBBBBC（6分）
AI-J00003: BABABC（3分）
17.阅读以下代码，完成判断题和选择题。判断题对的选A，错的选B。使用 a^b 表示a的b次方。
1 #include <algorithm>
2 #include <iostream>
3 #include <limits>
4
5 using namespace std;
6
7 const int MAXN = 105;
8 const int MAXK = 105;
9
10 int h[MAXN][MAXK];
11
12 int f(int n, int m)
13 {
14 if (m == 1) return n;
15 if (n == 0) return 0;
16
17 int ret = numeric_limits<int>::max();
18 for (int i = 1; i <= n; i++)
19 ret = min(ret, max(f(n - i,m), f(i - 1, m - 1)) + 1);
20 return ret;
21 }
22
23 int g(int n, int m)
24 {
25 for (int i = 1;i <= n; i++)
26 h[i][1]= i;
27 for (int j = 1;j<= m; j++)
28 h[0][j]= 0;
29
30 for (int i= 1; i <= n; i++){
31 for (int j= 2; j <= m; j++){
32 h[i][j] = numeric_limits<int>::max();
33 for (int k = 1;k <= i;k++)
34 h[i][j]= min(
35 h[i][j],
36 max(h[i - k][j],h[k - 1][j - 1]) +1);
37 }
38 }
39
40 return h[n][m];
41 }
42
43 int main()
44 {
45 int n,m;
46 cin >> n>> m;
47 cout << f(n, m) << endl << g(n, m)<< endl;
48 return 0;
49 }假设输入的n、m均是不超过100 的正整数。
(1)当输入为 7 3 时，第 19 行用来取最小值的 min 函数执行了449 次。()
(2)输出的两行整数总是相同的。()
(3)当 m 为 1 时，输出的第一行总为 n。()
(4)算法 g(n,m) 最为准确的时间复杂度分析结果为（ ）。
A.O((n^(3/2))*m)
B.O(n*m)
C.O((n^2)*m)
D.O(n*(m^2))
(5)当输入为 20 2 时，输出的第一行为（ ）。
A.4 B.5 C.6 D.20
(6)当输入 100 100 时，输出的第一行为（ ）。
A.6 B.7 C.8 D.9
ANS: BAACCB
AI-J00001: AAACAC(6分)
AI-J00002: BAACCB(14.5分)
AI-J00003: BAAACD(7.5分)
评价：orz 文心一言，这一题6小题全部答对！（尽管其中有蒙的成分）
18.阅读以下代码，完成判断题和选择题。判断题对的选A，错的选B。
1 #include <iostream>
2
3 using namespace std;
4
5 int n,k;
6
7 int solve1()
8 {
9 int l = 0, r = n;
10 while(l <= r){
11 int mid = (l + r) / 2;
12 if (mid * mid <= n) l = mid + 1;
13 else r = mid - 1;
14 }
15 return l - 1;
16 }
17
18 double solve2(double x)
19 {
20 if (x == 0) return x;
21 for (int i = 0; i < k; i++)
22 x = (x + n / x) / 2;
23 return x;
24 }
25
26 int main()
27 {
28 cin >> n >> k;
29 double ans = solve2(solve1());
30 cout << ans << ' ' << (ans * ans == n) << endl;
31 return 0;
32 }假设 int 为32位有符号整数类型，输入的 n 是不超过47000的自然数、k 是不超过 int 表示范围的自然数。
(1)该算法最准确的时间复杂度分析结果为 O((log n)+k)。()
(2)当输入为 9801 1 时，输出的第一个数为 99。()
（3）对于任意输入的n，随着所输入 k 的增大，输出的第二个数会变成 1。（）
（4）该程序有存在缺陷。当输入的n 过大时，第 12 行的乘法有可能溢出，因此应当将 mid 强制转换为 64 位整数再计算。（）
（5）当输入为 2 1 时，输出的第一个数最接近（ ）。
A.1 B.1.414 C.1.5 D.2
（6）当输入为 3 10 时，输出的第一个数最接近（ ）。
A.1.7 B.1.732 C.1.75 D.2
（7）当输入为 256 11 时，输出的第一个数（ ）。
A. 等于 16
B. 接近但小于 16
C. 接近但大于 16
D. 前三种情况都有可能
ANS: AABBCBA
AI-J00001: AABABCC(4.5分)
AI-J00002: AAAABBB（6分）
AI-J00003: AABABBC（7.5分）
程序阅读题汇总：
AI-J00001: 16.5分
AI-J00002: 26.5分
AI-J00003: 18分
19.（枚举因数）从小到大打印正整数 n 的所有正因数。试补全枚举程序。
#include <bits/stdc++.h>
using namespace std;
int main(){
int n;
cin >> n;
vector<int> fac;
fac.reserve((int)ceil(sqrt(n)));
int i;
for (i = 1; i * i < n; ++i){
if (①){
fac.push_back(i);
}
}
for (int k = 0; k < fac.size(); ++k){
cout << ② << "";
}
if (③) {
cout << ④ << "";
}
for (int k = fac.size() - 1; k >= 0; --k){
cout << ⑤ << "";
}
}①~⑤处应填（ ）
1. A. n % i == 0
B. n % i == 1
C. n % (i-1) == 0
D. n % (i-1) == 1
2.
A. n / fac[k]
B. fac[k]
C. fac[k]-1
D. n / (fac[k]-1)
3.
A. (i-1)*(i-1)== n
B. (i-1)*i == n
C. i*i == n
D. i*(i-1) == n
4.
A. n-i B. n-i+1 C. i-1 D. i
5. A. n / fac[k]
B. fac[k]
C. fac[k]-1
D. n / (fac[k]-1)
ANS: ABCDA
AI-J00001: ABCBB（9分）
AI-J00002: ABCBA(12分)
AI-J00003: ABABA（9分）
20.（洪水填充）现有用字符标记像素颜色的 8×8 图像。颜色填充的操作描述如下：给定起始像素的位置待填充的颜色，将起始像素和所有可达的像素（可达的定义：经过一次或多次的向上、下、左、右四个方向移动所能到达且终点和路径上所有像素的颜色都与起始像素颜色相同），替换为给定的颜色。
试补全程序。
#include<bits/stdc++.h>
using namespace std;
const int ROWS = 8;
const int COLS = 8;
struct Point {
int r, c;
Point(int r, int c): r(r), c(c) {}
};
bool is_valid(char image[ROWS][COLS], Point pt,
int prev_color, int new_color) {
int r = pt.r;
int c = pt.c;
return (0 <= r && r < ROWS && 0 <= c && c < COLS &&
① && image[r][c] != new_color);
}
void flood_fill(char image[ROWS][COLS], Point cur, int new_color) {
queue<Point> queue;
queue.push(cur);
int prev_color = image[cur.r][cur.c];
②;
while (!queue.empty()) {
Point pt = queue.front ();
queue.pop ();
Point points[4] = {③, Point(pt.r - 1, pt.c),
Point(pt.r, pt.c + 1), Point(pt.r, pt.c - 1)};
for (auto p ; points) {
if (is_valid(image, p, prev_color, new_color)) {
④;
⑤;
}
}
}
}
int main() {
char image[ROWS][COLS] = {{'g', 'g', 'g', 'g', 'g', 'g', 'g', 'g'},
{'g', 'g', 'g', 'g', 'g', 'g', 'r', 'r'},
{'g', 'r', 'r', 'g', 'g', 'r', 'g', 'g'},
{'g', 'b', 'b', 'b', 'b', 'r', 'g', 'r'},
{'g', 'g', 'g', 'b', 'b', 'r', 'g', 'r'},
{'g', 'g', 'g', 'b', 'b', 'b', 'b', 'r'},
{'g', 'g', 'g', 'g', 'g', 'b', 'g', 'g'},
{'g', 'g', 'g', 'g', 'g', 'b', 'b', 'g'}};
Point cur(4, 4);
char new_color = 'y';
flood_fill(image, cur, new_color);
for (int r = -; r < ROWS; r++) {
for (int c = 0; c < COLS; c++) {
cout << image[r][c] << '';
}
cout << endl;
}
//输出:
// g g g g g g g g
// g g g g g g r r
// g r r g g r g g
// g y y y y r g r
// g g g y y r g r
// g g g y y y y r
// g g g g g y g g
// g g g g g y y g
return 0;
}①~⑤处应填（ ）
1. A. image[r][c] == prev_color
B. image[r][c] != prev_color
C. image[r][c] == new_color
D. image[r][c] != new_color
2.
A. image[cur.r+1][cur.c] = new_color
B. image[cur.r][cur.c] = new_color
C. image[cur.r][cur.c+1] = new_color
D. image[cur.r][cur.c] = prev_color
3.
A. Point(pt.r, pt.c)
B. Point(pt.r, pt.c+1)
C. Point(pt.r+1, pt.c)
D. Point(pt.r+1, pt.c+1)
4.
A. prev_color = image[p.r][p.c]
B. new_color = image[p.r][p.c]
C. image[p.r][p.c] = prev_color
D. image[p.r][p.c] = new_color
5.
A. queue.push(p)
B. queue. push (pt)
C. queue.push(cur)
D. queue. push(Point (ROWS, COLS))
ANS: ABCDA（为什么和上面那题一样）
AI-J00001: ABCCA(12分)
AI-J00002: ADCCB(6分）
AI-J00003: ABAAA(9分)
总分：
AI-J00001: 55.5分
AI-J00002: 64.5分
AI-J00003: 54分
总结：不用我说，你一看这分数，就意味着什么。
复赛
不过，来都来了，复赛是肯定要测的（只是不能获奖）。
另外，限于篇幅，不提供大样例。
代码
1.小文同学刚刚接触了信息学竞赛，有一天她遇到了这样一个题：给定正整数 a 和b，求 a的b次方的值是多少。
a的b次方即b 个a 相乘的值，例如 2的3次方即为3 个2 相乘，结果为 2×2×2=8。
“简单！”小文心想，同时很快就写出了一份程序，可是测试时却出现了错误。
小文很快意识到，她的程序里的变量都是 int 类型的。在大多数机器上，int 类型能表示的最大数为2的31次方−1，因此只要计算结果超过这个数，她的程序就会出现错误。
由于小文刚刚学会编程，她担心使用 int 计算会出现问题。因此她希望你在 a的b次方的值超过 10的9次方时，输出一个 -1 进行警示，否则就输出正确的 a的b次方的值。
然而小文还是不知道怎么实现这份程序，因此她想请你帮忙。
输入格式
输入共一行，两个正整数a,b。
输出格式
输出共一行，如果 a的b次方的值不超过 10的9次方 ，则输出 a的b次方 的值，否则输出 -1。
输入 #1
10 9
输出 #1
1000000000
输入 #2
23333 66666
输出 #2
-1
说明/提示
对于10% 的数据，保证 b=1。
对于 30% 的数据，保证 b≤2。
对于 60% 的数据，保证 b≤30，a的b次方 ≤ 10的18次方。
对于100% 的数据，保证 1≤a,b≤10的9次方。
您只能使用 C++ 进行答题，版本为C++14，并开启O2优化。
AI-J00001: rid=137891425,100pts
AI-J00002: rid=137891800,50pts
AI-J00003: rid=137892124,100pts，然而被洛谷民间数据 Hack 了
2.给定一个正整数 k，有 k 次询问，每次给定三个正整数 n_i, e_i, d_i，求两个正整数 p_i, q_i，使 n_i = p_i q_i、e_i d_i = (p_i - 1)(q_i - 1) + 1。
输入格式
第一行一个正整数 k，表示有 k 次询问。
接下来 k 行，第 i 行三个正整数 n_i, d_i, e_i。
输出格式
输出 k 行，每行两个正整数 p_i, q_i 表示答案。
为使输出统一，你应当保证 p_i <= q_i。
如果无解，请输出 NO。
样例输入 #1
10
770 77 5
633 1 211
545 1 499
683 3 227
858 3 257
723 37 13
572 26 11
867 17 17
829 3 263
528 4 109
样例输出 #1
2 385
NO
NO
NO
11 78
3 241
2 286
NO
NO
6 88
【数据范围】
以下记 m = n - e * d + 2。
保证对于 100% 的数据，1 <= k <= 10的5次方，对于任意的 1 <= i <= k，1 <= n_i <= 10的18次方，1<= e_i * d_i <= 10的18次方，1<= m <= 10的9次方。
| 测试点编号 | k <= | n <= | m <= | 特殊性质 |
|---|---|---|---|---|
| 1 | 10的3次方 | 10的3次方 | 10的3次方 | 保证有解 |
| 2 | 10的3次方 | 10的3次方 | 10的3次方 | 无 |
| 3 | 10的3次方 | 10的9次方 | 6乘10的4次方 | 保证有解 |
| 4 | 10的3次方 | 10的9次方 | 6乘10的4次方 | 无 |
| 5 | 10的3次方 | 10的9次方 | 10的9次方 | 保证有解 |
| 6 | 10的3次方 | 10的9次方 | 10的9次方 | 无 |
| 7 | 10的5次方 | 10的18次方 | 10的9次方 | 保证若有解则 p=q |
| 8 | 10的5次方 | 10的18次方 | 10的9次方 | 保证有解 |
| 9 | 10的5次方 | 10的18次方 | 10的9次方 | 无 |
| 10 | 10的5次方 | 10的18次方 | 10的9次方 | 无 |
您只能使用 C++ 进行答题，版本为C++14，并开启O2优化。
AI-J00001: rid=137895252,0pts
AI-J00002: rid=137896476,0pts
AI-J00003: rid=137896941,0pts
3.逻辑表达式是计算机科学中的重要概念和工具，包含逻辑值、逻辑运算、逻辑运算优先级等内容。
在一个逻辑表达式中，元素的值只有两种可能：0（表示假）和 1（表示真）。元素之间有多种可能的逻辑运算，本题中只需考虑如下两种：“与”（符号为 &）和“或”（符号为 |）。其运算规则如下：
0 & 0 = 0 & 1 = 1 & 0 = 0, 1 & 1 = 1 ; 0 | 0 = 0，0 | 1 = 1 | 0 = 1 | 1 = 1 .
在一个逻辑表达式中还可能有括号。规定在运算时，括号内的部分先运算；两种运算并列时，& 运算优先于 | 运算；同种运算并列时，从左向右运算。
比如，表达式 0|1&0 的运算顺序等同于 0|(1&0)；表达式 0&1&0|1 的运算顺序等同于 ((0&1)&0)|1。
此外，在 C++ 等语言的有些编译器中，对逻辑表达式的计算会采用一种“短路”的策略：在形如 a&b 的逻辑表达式中，会先计算 a 部分的值，如果 a = 0，那么整个逻辑表达式的值就一定为 0，故无需再计算 b 部分的值；同理，在形如 a|b 的逻辑表达式中，会先计算 a 部分的值，如果 a = 1，那么整个逻辑表达式的值就一定为 1，无需再计算 b 部分的值。
现在给你一个逻辑表达式，你需要计算出它的值，并且统计出在计算过程中，两种类型的“短路”各出现了多少次。需要注意的是，如果某处“短路”包含在更外层被“短路”的部分内则不被统计，如表达式 1|(0&1) 中，尽管 0&1 是一处“短路”，但由于外层的 1|(0&1) 本身就是一处“短路”，无需再计算 0&1 部分的值，因此不应当把这里的 0&1 计入一处“短路”。
输入格式
输入共一行，一个非空字符串s 表示待计算的逻辑表达式。
输出格式
输出共两行，第一行输出一个字符 0 或 1，表示这个逻辑表达式的值；第二行输出两个非负整数，分别表示计算上述逻辑表达式的过程中，形如 a&b 和 a|b 的“短路”各出现了多少次。
样例 #1
样例输入 #1
0&(1|0)|(1|1|1&0)
样例输出 #1
1
1 2
样例 #2
样例输入 #2
(0|1&0|1|1|(1|1))&(0&1&(1|0)|0|1|0)&0
样例输出 #2
0
2 3
提示
【样例解释 #1】
该逻辑表达式的计算过程如下，每一行的注释表示上一行计算的过程：
0&(1|0)|(1|1|1&0) =(0&(1|0))|((1|1)|(1&0)) //用括号标明计算顺序 =0|((1|1)|(1&0)) //先计算最左侧的 &，是一次形如 a&b 的“短路” =0|(1|(1&0)) //再计算中间的 |，是一次形如 a|b 的“短路” =0|1 //再计算中间的 |，是一次形如 a|b 的“短路” =1
【数据范围】
设 |s| 为字符串 s 的长度。
对于所有数据， 1 <=|s|<= 10^6。保证 s 中仅含有字符 0、1、&、|、(、) 且是一个符合规范的逻辑表达式。保证输入字符串的开头、中间和结尾均无额外的空格。保证 s中没有重复的括号嵌套 （即没有形如 ((a)) 形式的子串，其中 a 是符合规范的逻辑表达式）。
| 测试点编号 | 特殊条件 | |
|---|---|---|
| 无 | ||
| 无 | ||
| 1 | ||
| 2 | ||
| 3 | ||
| 无 | ||
| 1 | ||
| 2 | ||
| 3 | ||
| 无 |
其中：
特殊性质 1 为：保证 s 中没有字符 &。
特殊性质 2 为：保证 s 中没有字符 |。
特殊性质 3 为：保证 s 中没有字符 ( 和 )。
【提示】
以下给出一个“符合规范的逻辑表达式”的形式化定义：
- 字符串
0和1是符合规范的； - 如果字符串
s是符合规范的，且s不是形如(t)的字符串（其中t是符合规范的），那么字符串(s)也是符合规范的； - 如果字符串
a和b均是符合规范的，那么字符串a&b、a|b均是符合规范的； - 所有符合规范的逻辑表达式均可由以上方法生成。
您只能使用 C++ 进行答题，版本为C++14，并开启O2优化。
AI-J00001:rid=140711348,10pts
AI-J00002:rid=140711524,0pts，有几个点第二行没输出，还有几个点第二行输出太长了，总之就没一个对的
AI-J00003：rid=140711855,0pts
4.在一个二维平面内，给定
你在自由添加
输入格式
第一行两个正整数
接下来
输出格式
输出一个整数表示满足要求的序列的最大长度。
样例 #1
样例输入 #1
8 2
3 1
3 2
3 3
3 6
1 2
2 2
5 5
5 3样例输出 #1
8样例 #2
样例输入 #2
4 100
10 10
15 25
20 20
30 30样例输出 #2
103提示
【数据范围】
保证对于所有数据满足：
| 测试点编号 | |||
|---|---|---|---|
您只能使用 C++ 进行答题，版本为C++14，并开启O2优化。
AI-J00001:rid=140716101,0pts
AI-J00002:rid=140714788,5pts
AI-J00003:rid=140715698,0pts
可以看到，这三位同学，OI水平还是不行。总分就不算了，算出来你会大吃一惊的。