2026年CSP-J初赛模考（6月）

欢迎大家订阅我的专栏：算法题解：C++与Python实现！
本专栏旨在帮助大家从基础到进阶，逐步提升编程能力，助力信息学竞赛备战！

专栏特色
1.经典算法练习：根据信息学竞赛大纲，精心挑选经典算法题目，提供清晰的代码实现与详细指导，帮助您夯实算法基础。
2.系统化学习路径：按照算法类别和难度分级，从基础到进阶，循序渐进，帮助您全面提升编程能力与算法思维。

适合人群：

准备参加蓝桥杯、GESP、CSP-J、CSP-S等信息学竞赛的学生
希望系统学习C++/Python编程的初学者
想要提升算法与编程能力的编程爱好者

单选题

第1题

想要正确表示 \(-1×10^{18}\)，可以使用的数据类型是（）

A. unsigned int

B. static int

C. long long

D. usigned long long

第2题

在C++中，执行int x=10; cout<<(x&(-x));后，输出的结果是？（）

A.2

B.-2

C.10

D.-10

第3题

函数 f(n,k) 的定义如下，则f(3,2)的返回值是多少？（）

long long f(long long n，long long k){
	if(k == 0 && n > 0) return 0;
	if(n == k && n >= 0) return 1;
	if (k > n) return 0;
	return f(n - 1, k 一1) + k * f(n-1, k);
}

A.4

B.3

C.2

D.1

第4题

假设有一组字符{ a, b, c, d, e, f }，它们对应的频率分别为{8%，14%，17%，20%，23%，18%}，用它们构造的哈夫曼树的带权路径长度是多少？

A.3.46

B.2.99

C.2.04

D.2.57

第5题

若有向图中存在环，则其拓扑排序的结果是（）。

A.存在且不唯一

B.不存在

C.存在且唯一

D.不确定

第6题

有8人排成一排照相，要求A、B两人不相邻，C、D、E三人互不相邻，则不同的排法有（）。

A.11520

B.88640

C.5640

D.2880

第7题

能正确表示（×）的取值范围在([0，100])和([-10，-5])内的表达式是：

A. ((x<=-10)||(x>=-5)&&(x<=0)||(x>=100))

B. ((x>=-10)&&(x<=-5)||(x>=0)&&(x<=100))

C. ((x>=-10)&&(x<=-5)&&(x>=0)&&(x<=100))

D. ((x<=-10)||(x>=-5)&&(x<=0)||(x>=100))

第8题

有以下算法，其时间复杂度为：

void fun(int n){
	int i = 0;
	while (i * i * i <= n)
		i++;
}

A. \(O(n)\)

B. \(O(logn)\)

C. \(O(n^{\frac{1}{3}})\)

D. \(O(n^3)\)

第9题

给定一个长度为 n 的字符串，请问它所有可能的非空子串个数是多少？

A. \(n^2\)

B. \(\displaystyle\frac{n(n+1)}{2}\)

C. \(2^n-1\)

D. \(n!\)

第10题

执行完下面代码后，a、b和c的值分别是（）

void byValue(int x) { x = 100; }
void byRef(int& x) { x = 200; }
void byPointer(int* x) { *x = 300; }
int main() {
	int a = 1, b = 2, c = 3;
	byValue(a);
	byRef(b);
	byPointer(&c);
	return 0;
}

A. 100 200 300

B. 1 2 3

C. 1 200 300

D. 1 2 300

第11题

在一座规划整齐的城市中，街道呈现为 8×8 的方格阵列。坐标系统的左上角为 (1,1)，右下角为 (8,8)。

一名快递员接到了一个订单，需要将包裹从坐标 (2,1) 的取货点送往坐标 (6,5) 的送货点。为了提了提高效率，快递员每次只能向右走一格，或者向下走一格。

请问，快递员从取货点到送货点一共有多少种不同的路径？（）

A. 35

B. 56

C. 70

D. 126

第12题

计算 \(2026_{16}-2025_{10}+2024_8\) 的十六进制计算结果（）

A. 2025

B. 1B51

C. 1C51

D. 1D51

第13题

使用冒泡排序对一个长度为n的序列进行排序，则其中元素的交换次数最多为（）次。

A. \(\displaystyle\frac{n*(n-1)}{2}\)

B. \(n-1\)

C. \(n*(n-1)\)

D. \(\displaystyle\frac{n-1}{2}\)

第14题

一棵包含2026个结点的完全二叉树，其叶子结点的数量是多少？（）

A. 1014

B. 1013

C. 1012

D. 1011

第15题

若元素 1, 2, 3, 4, 5 依次进入一个初始为空的栈，在进栈过程中允许进行出栈操作，则下列序列中不可能是出栈序列的是（）

A. 2,3, 5, 4, 1

B. 3, 2, 4, 1, 5

C. 4, 3, 1, 2, 5

D. 1, 2, 3, 4, 5

阅读程序题

#include<bits/stdc++.h>
using namespace std;
int a[3010], n;
int main() {
	cin >> n;
	a[1] = 1;
	for (int k = 2; k <= n; k++) {
		bool ok = 0;
		for (int i = 1; i < k; i++) {
			if (a[i] == a[k-1]-k) ok = 1;
		}
		if (a[k-1] - k > 0 && ok == 0) {
			a[k] = a[k-1] - k;
		}
		else {
			a[k] = a[k-1] + k;
		}
	}
	sort(a+1, a+n+1);
	for (int i=1; i<=n; i++)
		cout << a[i] << " ";
	return 0;
}

第16题

当输入 n 的值为 1 时，程序将不会执行 8~17 行的内容（）

第17题

第9行中将循环条件改为"i <=k" 不会影响程序输出结果（）

第18题

输出的数组中有可能出现负数（）

第19题

以下关于该程序的叙述，错误的是：

A. 第12行的 ok == 0 判断是为了确保减法得到的值之前没有出现过

B. 在sort之前，数组 a 中不可能包含重复元素

C. 该程序的时间复杂度为 \(O(n^2)\)

D. 若将 a[k-1]-k>0 改为 a[k-1]-k>=0，可能会导致数组中产生值等于0的元素

第20题

输入5时会输出（）

A. 1 3 6 7 9

B. 1 3 6 2 7

C. 1 2 3 4 5

D. 1 2 3 6 7

第21题

删除第19行之后，输入15结果会输出（）

A. 1 3 6 2 7 13 20 12 21 10 22 11 23 9 24

B. 1 3 6 2 7 13 20 12 21 11 22 10 24 9 23

C. 1 3 6 2 7 13 20 12 21 11 22 10 23 9 24

D. 1 3 6 2 7 13 20 12 22 11 21 10 23 9 24

已知输入数据不会超过5000

#include<iostream>
#include<algorithm>
using namespace std;
long long a[1000005], box[5010];
int main()
{
	int n;
	cin >> n;
	for (int i = 1; i <= n; i++)
	{
		cin >> a[i];
		box[a[i]]++;
	}
	long long len, ans = 0;
	for (int a = 1; a <= 5000; a++)
	{
		long long minn = 1e9;
		for (int b = a; b <= 5000; b++)
		{
			minn = min(minn, box[b]);
			len = minn * (b - a + 1);
			ans = max(ans, len);
		}
	}
	cout << ans;
	return 0;
}

第22题

输入均为正整数的情况下，本题输出结果可能为0（）。

第23题

已知输入均为正整数，输出结果不可能超过 n。

第24题

输入的a数组中的元素超过5000时会导致编译错误（）

第25题

输入的a数组为{3，3，4，4，5，5，6，7，8，9，9，9，9，9，9，9，9}时，输出结果为

A. 6

B. 7

C. 8

D. 9

第26题

将第17行minn的定义及赋值的位置更改至第14行，会导致（）。

A. 输出答案变小

B. 输出答案变大

C. 输出答案不变

D. 输出答案为一个恒定的值

第27题

输入的a数组中元素的值为{1，2，3，......，，98，99，100}，输出结果为（）

A. 1

B. 50

C. 51

D. 100

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
const int N = 1e4 + 5;
int n, m, p[N], t[N], f[N][N], ans = 0;
int main() {
	cin >> m >> n;
	for (int i=1; i<=n; i++)
		cin >> p[i] >> t[i];
	for (int i=1; i<=n; i++)
		for (int j=0; j<=m; j++) {
			f[i][j] = f[i-1][j];
			if (j >= t[i]) {
				f[i][j] = max(f[i][j], f[i][j-t[i]] + p[i]);
			}
		}
	for (int i=0; i<=m; i++) {
		ans = max(ans, f[n][i]);
	}
	cout << ans;
	return 0;
}

第28题

输出的ans的值一定和f[n][m]相等（）。

第29题

将第15行的 max(f[i][j], f[i][j-t[i]] + p[i]) 改为max(f[i-1][j]，f[i][j-t[i]] + p[i])不会对程序输出产生影响（）。

第30题

该程序的时间复杂度为 \(O(n^2)\)

第31题

删除第14行和第16行的 if 判断会导致程序（）。

A. 程序发生运行时错误

B. 程序发生编译错误

C. 输出结果变大

D. 输出结果变小

第32题

输入的 n=4，m=300，p={100, 250, 120, 35}， t={60, 120, 100, 20}，则输出结果为（）。

A. 360

B. 550

C. 605

D. 635

第33题

输入的 n=m=100，t={1, 2, 3, ..., 98, 99, 100}，p={100, 99, 98, ..., 3, 2, 1}，则输出结果为（）。

A. 1

B. 100

C. 10000

D. 1000000

完善程序题

（求先序遍历）给出一棵二叉树的中序与后序排列，求出它的先序排列。保证树上的节点均为大写字母，其中sz为中序遍历的字符串，sh为后序遍历的字符串，试补全程序。

#include<bits/stdc++.h>
using namespace std;
string sz, sh;

void dfs(string sz, string sh) {
	int n = sz.size();
	if (n == 0) return ;
	char root = __1__;
	__2__;
	int p = sz.find(root);
	string lz = sz.substr(0, p);
	string lh = __3__;
	dfs(lz, lh);
	string rz = __4__;
	string rh = sh.substr(p, __5__);
	dfs(rz, rh);
}

int main() {
	cin >> sz >> sh;
	dfs(sz, sh);
}

第34题

1处应该填写（）。

A. sz.front()

B. sz.back()

C. sh.front()

D. sh.back()

第35题

2处应该填写（）。

A. dfs(sz+root, sh);

B. cout << root;

C. dfs(root+sz, sh)

D. sz += root;

第36题

3处应该填写（）。

A. sz.substr(1, p);

B. sh.substr(0, p-1);

C. sh.substr(1, p);

D. sh.substr(0, p);

第37题

4处应该填写（）。

A. sz.substr(p)

B. sz.substr(1, p)

C. sz.substr(p+1)

D. sz.substr(0, p)

第38题

5处应该填写（）。

A. lz.size()

B. rz.size()

C. lh.size()

D. rh.size()

肯德尔等级相关系数的计算

在数据分析中，我们常常需要衡量两个排名序列之间的相关性。

对于两个长度为 \(n\) 的排名序列 \(X\) 和 \(Y\)，假设没有相等元素的情况，我们可以任选两对数据 \((X_i, Y_i)\) 和 \((X_j, Y_j)\)：

如果 \(X_i\lt X_j\) 且 \(Y_i\lt Y_j\)，称为一致对；
如果 \(X_i\lt X_j\) 且 \(Y_i\gt Y_j\)，称为逆序对；
设总对数 \(n_0\)，一致对数量为 \(n_c\)，逆序对数量为 \(n_d\)，则肯德尔 \(\tau_a\) 的计算公式为：

\(\tau_a = \displaystyle\frac{n_c-n_d}{n_0}\)

\(\tau_a\) 的取值范围是 [-1, 1]，值越接近 1 表示两个排名越正相关，越接近 -1 表示越负相关，接近 0 表示几乎不相关。

算法思路如下：

将两个序列的对应元素组成点对 \((X_i,Y_i)\)。
将所有点对按照其中一项的值升序排序。
排序后，问题转化为统计另一项的值元素所构成的序列中的逆序对的数量 \(n_d\)。
得到 \(n_d\) 后，再计算出一致对数 \(n_c\)，最终代入 \(\tau_a\) 公式即可。

下面的程序实现了上述算法，其中 add 和 sum函数分别实现了箱数组的单点增加和前缀和查询功能（具体实现已省略）来辅助计算序列的逆序对个数。

请根据题意，补全程序中的空缺部分。

#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
int n;
struct Node {
	int x, y;
}a[MAXN];
bool cmp(Node u, Node v) {
	return __1__;
}

void add(int x, int v);  // 在箱数组下标为x的位置+v
int sum(int x);  // 计算箱数组 [1, x] 的和

double kendall_tau() {
	sort(a+1, a+n+1, cmp);
	__2__;
	for (int i=1; i<=n; i++) {
		nd += __3__;
		add(a[i].y, __4__);
	}
	int n0 = __5__;
	int nc = n0 - nd;
	return (double)(nc - nd) / n0;
}

int main() {
	cin >> n;
	for (int i=1; i<=n; ++i) cin >> a[i].x;
	for (int i=1; i<=n; ++i) cin >> a[i].y;
	cout << kendall_tau() << '\n';
	return 0;
}

第39题

1处应该填写（）。

A. u.x < v.x

B. u.y < v.y

C. u.x < v.y

D. u.y < v.x

第40题

2处应该填写（）。

A. int nd = 0

B. int nd = 1

C. int nd = n*(n-1)/2

D. int nd = n*(n+1)/2

第41题

3处应该填写（）。

A. sum(a[i].y)

B. i - sum(a[i].y)

C. i - sum(a[i].y) + 1

D. i - sum(a[i].y) - 1

第42题

4处应该填写（）。

A. 0

B. 1

C. i

D. a[i].x

第43题

5处应该填写（）。

A. n*n/2

B. (n+1)*(n-1)/2

C. n*(n-1)/2

D. n*(n+1)/2

posted @ 2026-06-20 14:49 团爸讲算法阅读(47) 评论(1) 收藏举报

刷新页面返回顶部

2026年CSP-J初赛模考（6月）

单选题

阅读程序题

完善程序题

公告