执行下述代码将输出（ ）。

int x = 10;
void func() { int x = 20; std::cout << x; }
int main() {
	func();
	std::cout << x;
	return 0;
}

关于下述代码，说法错误的是（ ）。

int multiply(int x, int y);
int main() {
	int a = 4;
	int b = 5;
	int result = multiply(a, b);
	std::cout << "The result is: " << result << std::endl;
	return 0;
}
int multiply(int x, int y) {
	return x * y;
}

下面（ ）正确定义了二维数组。

下面的描述中，（ ）正确定义—个名为 Person 的结构体并正确初始化了—个 Person 结构体的变量 p 。

给定如下算法，其时间复杂度为（ ）。

bool f(int arr[], int n, int target) {
	for (int i = 0; i < (1 << n); i++) {
		int sum = 0;
		for (int j = 0; j < n; j++) {
			if (i & (1 << j)) {
				sum += arr[j];
			}
		}
		if (sum == target) return true;
	}
	return false;
}

给定如下代码，

struct Person {
	std::string name;
	int age;
	struct Address {
		std::string street;
		std::string city;
	};
	Address address;
};

下面描述错误的是（ ）。

假设 int arr[2] [3] = {{1,2,3},{4,5,6}}; ，则 arr[1] [2] 的值是（ ）。

执行下述代码后，变量 a 的值为（ ）。

int a = 10; 
int* p = &a;
*p = 20

以下哪种参数传递方式可以避免拷贝大型对象？

执行下述代码，将输出（ ）。

void swap(int a, int &b) {
	int temp = a;
	a = b;
	b = temp;
}
int main() {
	int x = 1, y = 2;
	swap(x, y);
	std::cout << x << y;
	return 0;
}

下面关于排序稳定性的描述，正确的是（ ）。

对数组 arr[]={5, 3, 8, 1} 进行升序排序，执行第—轮冒泡排序后数组 arr 中的内容为（ ）。

下面哪种方式不能实现将字符串 "Happy Spring!" 输出重定向到文件 log.txt （ ）。

运行下面的代码，将出现（ ）。

double hmean(double a, double b) {
	if (a == -b )
		throw runtime_error("Runtime error occurred.");
	return 2.0*a*b/(a + b);
}
int main() {
	double x = 10;
	double y = -10;
	try {
		int result = hmean(x, y);
		cout << "hmean: " << result << endl;
	}
	catch (const runtime_error& e) {
		cout << "Caught: " << e.what() << endl;
	} catch (...) {
		cout << "Caught an unknown exception." << endl;
	}
	return 0;
}

小杨正在爬楼梯，需要爬n 阶才能到达楼顶。如果每次可以爬 1个或 2个台阶，下面代码采用递推算法来 计算 —共有多少种不同的方法可以爬到楼顶，则横线上应填写（ ）。

int f(int n) {
	if (n == 1 || n == 2)
		return n;
	int f1 = 1;
	int f2 = 2;
	int res = 0;
	for (int i = 3; i <= n; i++) {
		_________________________________     // 在此处填入代码
	}
	return res;
}

结构体的成员默认是 public 访问权限。

二维数组作为函数参数时，必须显式指定所有维度的大小。

递推是—种通过已知的初始值和递推公式，逐步求解目标值的算法。

在C++中，函数的返回类型可以省略，默认为 int 。

对数组 arr[]={4, 3, 1, 5, 2} 进行升序排序，执行第—轮选择排序后数组arr 中的内容是 {1, 4, 3, 5,  2} 。

假设整数数组 arr[4]= {0, 1, 2, 3}; 的第—个元素在内存中的地址为 0x7ffee4065820 , 经过 int* p  = arr; p += 1; 后，指针 p 的值是1。

函数是C++中的核心概念，用于封装可重用的代码块。

插入排序在最好情况（已有序）下的时间复杂度是 O(n2)。

考虑最坏情况下冒泡排序算法的时间复杂度，   T(n)为待排序数字的数目为 n的复杂度，则其递推关系式为 T(n) = T(n - 1) + n  ，T(0) = 1 。

未捕获异常会调用std::terminate终止程序。

二阶矩阵

题目描述

小 A 有—个 n行 m列的矩阵 。

小 A 认为—个 2*2的矩阵 D 是好的，当且仅当D1,1 * D2,2 = D1,2 * D2,1。其中 Di,j表⽰矩阵 的第 i行第 j列 的元 素。 小 A 想知道 A中有多少个好的子矩阵。

输入格式

第—行，两个正整数 n和m。

接下来 n行，每行 m 个整数 Ai,1,Ai,2,...,Ai,m

输出格式

—行， —个整数，表⽰ 中好的子矩阵的数量。

输入样例

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

输出样例

2

数据范围

对于所有测试点，保证 1 ≤ n ≤ 500 ， 1 ≤  m ≤ 500 ，-100 ≤ Ai,j ≤ 100 。

荒地开垦

时间限制： 1.0 s

内存限制 ：512.0 MB

题面描述

小杨有—大片荒地，可以表⽰为—个n行m列的网格图。

小杨想要开垦这块荒地，但荒地中—些位置存在杂物，对于—块不存在杂物的荒地，该荒地可以开垦当且仅当其 上、下、左、右四个方向相邻的格子均不存在杂物。

小杨可以选择至多—个位置，清除该位置的杂物，移除杂物后该位置变为荒地。小杨想知道在清除至多—个位置的 杂物的情况下，最多能够开垦多少块荒地。

输入格式

第—行包含两个正整数  n ,  m ，含义如题面所⽰。

之后  n 行，每行包含—个长度为  m 且仅包含字符  . 和 # 的字符串。如果为  . ，代表该位置为荒地；如果为# ，代表该位置为杂物。

输出格式

输出—个整数，代表在清除至多—个位置的杂物的情况下，最多能够开垦的荒地块数。

输入样例

3 5
.....
.#..#
.....

输出样例

11

样例解释

移除第二行从左数第二块空地的杂物后：

.....
....#
.....

第—行从左数前 4 块荒地，第二行从左数前 3 块荒地，第三行从左数前 4 块荒地，均可开垦， 4 + 3 + 4 = 11。

数据范围

对于全部数据，保证有  1 ≤ n, m ≤ 1000 。