1. 以下关于存储器的说法中，错误的是（ {{ select(1) }}

• RAM中的信息在断电后会丢失
• CPU可以直接从硬盘中读取指令并执行
• 内存的访问速度通常比外存快
• ROM是一种只读存储器

---

2. 对于变量 $a = 7$，$b = 4$，表达式 $(a \sim b) \& ((\sim a) \mid b)$ 的结果是（）。 {{ select(2) }}

• 3
• 4
• 7
• 0

---

3. 一个8位有符号整数采用二进制补码表示，其可以表示的最小十进制数是（）。 {{ select(3) }}

• -127
• -128
• -255
• -256

---

4. 在NOI Linux终端中，要创建一个名为“test”的新目录，应该使用（）命令。 {{ select(4) }}

• new test
• create test
• mkdir test
• md test

---

5. $x$ 是正整数且在int范围内，则表达式 $(x \& (x-1)) == 0$ 可以用来判断一个无符号整数 $x$（）。 {{ select(5) }}

• 是偶数
• 是2的幂次
• 是0
• 是奇数

---

6. 在平均情况下，（ ）算法的时间复杂度最低。 {{ select(6) }}

• 冒泡排序
• 插入排序
• 快速排序
• 选择排序

---

7. 以下代码的空间复杂度是（）。

int sum = 0;
for (int i = 0; i < n; i++) {
    int temp = i * 2;
    sum += temp;
}

{{ select(7) }}

• $O(1)$
• $O(n)$
• $O(n^2)$
• $O(\log n)$

---

8. 一个项目团队有12名成员，团队内部任意两人都有过合作经历。这样的合作关系对应（）。 {{ select(8) }}

• 连通图
• 完全图
• 二分图
• 稀疏图

---

9. 一个栈的入栈序列为1,2,3,4,5,6。出栈序列中，3是第二个出栈的元素。出栈序列（）是不可能的。 {{ select(9) }}

• 1,3,2,4,5,6
• 2,3,4,6,1,5
• 4,3,2,1,5,6
• 2,3,4,1,5,6

---

10. 5个男生和3个女生站成一排，要求女生不相邻，且第一个和最后一个位置必须是男生，不同的排法有（）种。 {{ select(10) }}

• 2880
• 4320
• 720
• 1440

---

11. 已知二叉树的中序遍历序列为DBEAC，后序遍历序列为DEBCA，则前序遍历序列为（）。 {{ select(11) }}

• ABCDE
• ABDEC
• ABEDC
• ABECD

---

12. 用数组存储完全二叉树，按从上到下、从左到右的顺序编号（从1开始），则节点 $i$ 的左子节点是（）。 {{ select(12) }}

• $2i$
• $2i+1$
• $i/2$
• $(i+1)/2$

---

13. 以下关于CPU（中央处理器）的描述中，正确的是（）。 {{ select(13) }}

• CPU主要由存储器和控制器组成
• CPU的性能仅由主频决定
• 多核CPU是指一个CPU中有多个运算器
• CPU是计算机的“大脑”，负责所有的运算和控制

---

14. 学校有 $n$ 门课程，部分课程有先修关系（必须先修A才能修B）。现要判断课程安排是否合理，有没有循环依赖。这对应图论中的（）问题。 {{ select(14) }}

• 最短路径
• 拓扑排序
• 最小生成树
• 负环

---

15. 某哈夫曼树有8个叶节点，该树总共有（）个节点。 {{ select(15) }}

• 8
• 15
• 16
• 17

---

阅读程序（1）：

#include <iostream>
using namespace std;

int process(int n) {
    if (n == 0) return 0;
    return n % 2 + process(n / 2) * 10;
}

int main() {
    int num;
    cin >> num;
    int result = process(num);
    cout << result << endl;
    return 0;
}

16. 输入10时，输出为1010。 {{ select(16) }}

• 正确
• 错误

---

17. 输入1024时，输出为10000000000。 {{ select(17) }}

• 正确
• 错误

---

18. 对于任意正整数n，process(n)的输出总是一个由0和1组成的数。 {{ select(18) }}

• 正确
• 错误

---

19. （2分）若输入2025，则函数process被递归调用（）次（包括第一次调用）。 {{ select(19) }}

• 10
• 11
• 12
• 13

---

20. （2分）函数process的时间复杂度是（）。 {{ select(20) }}

• $O(1)$
• $O(n)$
• $O(\log n)$
• $O(2^n)$

---

21. 程序能正常处理的最大输入值为（）。 {{ select(21) }}

• 1023
• 1024
• 1000000000
• $2^{31}-1$

---

阅读程序（2）：

#include <iostream>
#include <cmath>
#define MAX 100
using namespace std;
int digits[MAX+9];

void solve(int a, int b, int precision) {
    if (b == 0) {
        cout << "Error::Division_by_zero!" << endl;
        return;
    }
    if (precision > MAX) precision = MAX;
    if (precision < 0) precision = 0;

    bool negative = (a < 0 && b > 0) || (a > 0 && b < 0);
    a = abs(a);
    b = abs(b);
    digits[0] = a / b;
    int remainder = a % b;

    for (int i = 1; i <= precision + 1; i++) {
        remainder *= 10;
        digits[i] = remainder / b;
        remainder %= b;
    }

    if (digits[precision + 1] >= 5) {
        digits[precision]++;
        for (int i = precision; i >= 1; i--) {
            if (digits[i] >= 10) {
                digits[i] -= 10;
                digits[i - 1]++;
            } else {
                break;
            }
        }
    }

    if (negative) cout << " - ";
    cout << digits[0] << '.';
    for (int i = 1; i <= precision; i++) {
        cout << digits[i];
    }
    cout << endl;
}

int main() {
    int a, b, prec;
    cin >> a >> b >> prec;
    solve(a, b, prec);
    return 0;
}
// 所有输入数据的绝对值均小于1000

22. 程序输出结果保留指定的小数位数，同时实现四舍五入，小数位的数量等于输入变量prec的值。 {{ select(22) }}

• 正确
• 错误

---

23. 若输入2025 25 0，程序会输出81。 {{ select(23) }}

• 正确
• 错误

---

24. 若将程序中的solve(a,b,prec);替换成cout<<fixed<<setprecision(prec)<<(1.0*a/b)<<endl;，其他部分不变，则当prec的输入值在[0,15]区间时，输出结果是一样的。 {{ select(24) }}

• 正确
• 错误

---

25. 如果输入2026 26 4，则输出的结果是（）。 {{ select(25) }}

• 77.923
• 77.9230
• 77.9231
• 77.9232

---

26. 如果输入的数据为2026 0 -6，下列说法中正确的是（）。 {{ select(26) }}

• 程序会因为执行除以0的操作而出错，不能正常输出数据
• 程序不会报错，但不会输出具体数值，而是输出自定义的出错提示语
• 程序不会报错，可以正常输出结果，输出结果为2026.
• 程序不会报错，可以正常输出结果，输出结果为2026

---

阅读程序（3）：

#include <iostream>
#include <vector>
using namespace std;

int bSearch(vector<int>& a, int target) {
    int left = 0, right = a.size() - 1;

    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (a[mid] == target) {
            return mid;
        } else if (a[mid] > target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return -1;
}

int main() {
    int n, x;
    cin >> n >> x;

    vector<int> a(n);
    for (int i = 0; i < n; i++) cin >> a[i];
    int ans = bSearch(a, x);
    cout << (ans != -1 ? ans : -1) << endl;
    return 0;
}

27. 如果输入6 3 10 9 8 6 5 4，程序会输出-1。 {{ select(27) }}

• 正确
• 错误

---

28. 该程序使用二分法，在单调不升数组中查找某个数在整个数组中排在第几个位置。 {{ select(28) }}

• 正确
• 错误

---

29. 要保证正常查找功能，输入必须从大到小排列，并且数值要连续。 {{ select(29) }}

• 正确
• 错误

---

30. 如果输入10 4 20 17 15 11 10 9 8 6 5 3，程序会输出（）。 {{ select(30) }}

• 11
• 10
• 8
• -1

---

31. 如果输入单调不升数组，被查找的数值出现过多次，则程序输出是（）。 {{ select(31) }}

• 匹配的最小的下标
• 匹配的最大的下标
• 随机
• 无法确定

---

32. 如果输入4 4 4 4 4 4，程序会输出（）。 {{ select(32) }}

• 0
• 1
• 2
• 3

---

完善程序（1）：

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int solve(vector<int>& nums, int k) {
    int n = ①;
    vector<vector<int>> dp(②);

    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= k; j++) {
            if (j == 1) {
                dp[i][j] = max(③);
            } else {
                dp[i][j] = max(dp[i-1][j], ④);
            }
        }
    }
    return ⑤;
}

int main() {
    int n, k;
    cin >> n >> k;
    vector<int> nums(n);
    for (int i = 0; i < n; i++) cin >> nums[i];
    cout << solve(nums, k) << endl;
    return 0;
}

33. ①处应填（）。 {{ select(33) }}

• nums.size()-1
• nums.size()
• nums.length()-1
• nums.length()

---

34. ②处应填（）。 {{ select(34) }}

• n, vector(k, 0)
• n, vector(k+1, 0)
• n+1, vector(k, 0)
• n+1, vector(k+1, 0)

---

35. ③处应填（）。 {{ select(35) }}

• dp[i-1][j], nums[i-1]
• dp[i][j], nums[i-1]
• dp[i-1][j-1] + nums[i-1]
• dp[i][j] + nums[i-1]

---

36. ④处应填（）。 {{ select(36) }}

• dp[i-1][j], nums[i-1]
• dp[i][j], nums[i-1]
• dp[i-2][j-1] + nums[i-1]
• dp[i][j] + nums[i-1]

---

37. ⑤处应填（）。 {{ select(37) }}

• dp[n-1][k-1]
• dp[n][k-1]
• dp[n-1][k]
• dp[n][k]

---

完善程序（2）：

#include <iostream>
#include <algorithm>
using namespace std;
const int N = 100005;

struct Interval { int s, e; } ivl[N];
bool cmp(Interval a, Interval b) {
    return a.s < b.s || (①);
}

int main() {
    int L, n;
    cin >> L >> n;

    for (int i = 0; i < n; i++) {
        cin >> ivl[i].s >> ivl[i].e;
    }
    ②

    int curr = 0;
    int cnt = 0;
    int i = 0;

    while (curr < L) {
        int mx_reach = curr;
        while (③) {
            if (ivl[i].e > mx_reach) {
                mx_reach = ivl[i].e;
            }
            i++;
        }

        if (④) {
            cout << -1 << endl;
            return 0;
        }
        cnt++;
        ⑤
    }

    cout << cnt << endl;
    return 0;
}

38. ①处应填（）。 {{ select(38) }}

• a.s == b.s && a.e < b.e
• a.s == b.s && a.e <= b.e
• a.s == b.s && a.e != b.e
• a.s == b.s && a.e >= b.e

---

39. ②处应填（）。 {{ select(39) }}

• sort(ivl, ivl + n);
• sort(ivl, ivl + n, cmp);
• sort(ivl + 1, ivl + 1 + n);
• sort(ivl + 1, ivl + 1 + n, cmp);

---

40. ③处应填（）。 {{ select(40) }}

• i < n && ivl[i].s > curr
• i < n && ivl[i].s >= curr
• i < n && ivl[i].s <= curr
• i < n && ivl[i].s < curr

---

41. ④处应填（）。 {{ select(41) }}

• i < n
• i > n
• mx_reach < curr
• mx_reach == curr

---

42. ⑤处应填（）。 {{ select(42) }}

• curr = mx_reach;
• curr += mx_reach;
• curr = intervals[i].e;
• curr += intervals[i].e - intervals[i].s + 1;

---