客观题逐题精讲

为丰富食堂菜谱，炒菜部进行头脑风暴。肉类有鸡肉、牛肉、羊肉、猪肉4种，切法有肉排、肉块、肉末3种，配菜有圆白菜、油菜、豆腐3种，辣度有麻辣、微辣、不辣3种。不考虑口感的情况下，选1种肉、1种切法、1种配菜、1种辣度产生一道菜（例如：麻辣牛肉片炒豆腐），这样能产生多少道菜？（）。

1. A13
2. B42
3. C63
4. D108

已知袋中有2个相同的红球、3个相同的绿球、5个相同的黄球。每次取出一个不放回，全部取出。可能产生多少种序列？（）。

1. A6
2. B1440
3. C2520
4. D3628800

以下二维数组的初始化，哪个是符合语法的？（）。

1. Aint a[][] = {{1, 2}, {3, 4}};
2. Bint a[][2] = {}；
3. Cint a[2][2] = {{1, 2, 3}, {4, 5, 6}};
4. Dint a[2][] = {{1, 2, 3}, {4, 5, 6}};

下面有关C++拷贝构造函数的说法，错误的是（）。

1. A必须实现拷贝构造函数，否则一定会出现编译错误。
2. B对象作为函数参数、以值传递方式传入函数时，会自动调用拷贝构造函数。
3. C对象作为函数返回值、以值传递方式从函数返回时，会自动调用拷贝构造函数。
4. D使用一个对象初始化另一个对象时，会自动调用拷贝构造函数。

使用邻接表表达一个无向简单图，图中包含 v 个顶点、e 条边，则该表中边节点的个数为（）。

1. A𝑣 × ( 𝑣 − 1 ) v×(v−1)
2. B𝑣 × 𝑣 v×v
3. C2 × 𝑒 2×e
4. De

关于生成树的说法，错误的是（）。

1. A一个无向连通图可以有多个生成树。
2. B一个无向图，只要连通，就一定有生成树。
3. Cn 个顶点的无向完全图，有 𝑛 𝑛 − 2 n n−2 棵生成树。
4. Dn 个顶点的无向图，生成树包含 n-1 条边。

已知三个 double 类型的变量 a、b 和 theta 分别表示一个三角形的两条边长及二者的夹角（弧度），则下列哪个表达式可以计算这个三角形的周长？（）。

1. Aa * b * sin(theta) / 2
2. Ba + b + (a + b) * sin(theta) / 2
3. Ca * b * cos(theta) / 2
4. Da + b + sqrt(a * a + b * b - 2 * a * b * cos(theta))

在有 n 个元素的二叉排序树中进行查找，其最好、最差时间复杂度分别为（）。

1. A𝑂 ( 1 ) O(1)、 𝑂 ( 𝑛 ) O(n)
2. B𝑂 ( 1 ) O(1)、 𝑂 ( log ⁡ 𝑛 ) O(logn)
3. C𝑂 ( log ⁡ 𝑛 ) O(logn)、 𝑂 ( log ⁡ 𝑛 ) O(logn)
4. D𝑂 ( log ⁡ 𝑛 ) O(logn)、 𝑂 ( 𝑛 ) O(n)

如下图所示，半径为 r 、圆心角为 t （弧度）的扇形，下面哪个表达式能够求出顶部阴影部分的面积？（）。

1. Ar * r * sin(t) / 2
2. Br * r * t / 2
3. Cr * r * (t - sin(t))
4. Dr * r * (t - sin(t)) / 2

下面程序的时间复杂度为（）。

int fib(int n) {
    if (n <= 1)
        return 1;
    return fib(n - 1) + fib(n - 2);
}

1. A𝑂 ( 2 𝑛 ) O(2 n )
2. B𝑂 ( 𝜙 𝑛 ) O(ϕ n ), 其中 𝜙 = 5 + 1 2 ϕ= 2 5 ​ +1 ​
3. C𝑂 ( 𝑛 ) O(n)
4. D𝑂 ( 1 ) O(1)

下面程序的时间复杂度为（）。

int choose(int n, int m) {
    if (m == 0 || m == n)
        return 1;
    return choose(n - 1, m - 1) + choose(n - 1, m);
}

1. A𝑂 ( 2 𝑛 ) O(2 n )
2. B𝑂 ( 2 𝑚 × ( 𝑛 − 𝑚 ) ) O(2 m ×(n−m))
3. C𝑂 ( 𝐶 ( 𝑛 , 𝑚 ) ) O(C(n,m))
4. D𝑂 ( 𝑚 × ( 𝑛 − 𝑚 ) ) O(m×(n−m))

下面程序的时间复杂度为（）。

int primes[MAXP], num = 0;
bool isPrime[MAXN] = {false};
void sieve() {
    for (int n = 2; n <= MAXN; n++) {
        if (!isPrime[n])
            primes[num++] = n;
        for (int i = 0; i < num && n * primes[i] <= MAXN; i++) {
            isPrime[n * primes[i]] = true;
            if (n % primes[i] == 0)
                break;
        }
    }
}

1. A𝑂 ( 𝑛 ) O(n)
2. B𝑂 ( 𝑛 × log ⁡ 𝑛 ) O(n×logn)
3. C𝑂 ( 𝑛 × log ⁡ log ⁡ 𝑛 ) O(n×loglogn)
4. D𝑂 ( 𝑛 2 ) O(n 2 )

下面程序的输出为（）。

#include <iostream>
using namespace std;

int a[10][10];
int main() {
    int m = 5, n = 4;
    for (int x = 0; x <= m; x++)
        a[x][0] = 1;
    for (int y = 1; y <= n; y++)
        a[0][y] = 1;
    for (int x = 1; x <= m; x++)
        for (int y = 1; y <= n; y++)
            a[x][y] = a[x - 1][y] + a[x][y - 1];
    cout << a[m][n] << endl;
    return 0;
}

1. A4
2. B5
3. C126
4. D3024

下面程序的输出为（）。

#include <iostream>
using namespace std;

int main() {
    int cnt = 0;
    for (int x = 0; x <= 10; x++)
        for (int y = 0; y <= 10; y++)
            for (int z = 0; z <= 10; z++)
                if (x + y + z == 15)
                    cnt++;
        cout << cnt << endl;
        return 0;
}

1. A90
2. B91
3. C96
4. D100

下面的程序使用邻接矩阵表达的带权无向图，则从顶点0到顶点3的最短距离为（）。

int weight[4][4] = {
    { 0, 1, 7, 100 },
    { 1, 0, 5, 15 },
    { 7, 5, 0, 6 },
    { 100, 15, 6, 0 }
};

1. A100
2. B16
3. C12
4. D13

已知 int 类型的变量 a 和 b，则执行语句 a, b = b, a; 后，变量 a 和 b 的值会互换。

1. 正确正确
2. 错误错误

一个袋子中有3个完全相同的红色小球、2个完全相同的蓝色小球。每次从中取出1个，再放回袋子，这样进行3次后，可能的颜色顺序有7种。

1. 正确正确
2. 错误错误

孙子定理是求解一次同余方程组的方法，最早见于中国南北朝时期（公元5世纪）的数学著作《孙子算经》。又称中国余数定理，是中国数学史上的一项伟大成就。

1. 正确正确
2. 错误错误

N个顶点的无向完全图有 𝑁 × ( 𝑁 − 1 ) N×(N−1)条边。

1. 正确正确
2. 错误错误

为解决哈希函数冲突，在哈希表项内设置链表存储该项内的所有冲突元素，则该哈希表内查找元素的最差时间复杂度为 𝑂 ( 1 ) O(1)。

1. 正确正确
2. 错误错误

求一个包含 v 个顶点、 e 条边的带权连通无向图的最小生成树，Prim算法的时间复杂度为O(v × e)。

1. 正确正确
2. 错误错误

已知 int 类型的变量 a、b 和 c 中分别存储着一个三角形的三条边长，则这个三角形的面积可以通过表达式 ( 𝑎 + 𝑏 + 𝑐 ) × ( 𝑏 + 𝑐 − 𝑎 ) × ( 𝑎 + 𝑐 − 𝑏 ) × ( 𝑎 + 𝑏 − 𝑐 ) (a+b+c)×(b+c−a)×(a+c−b)×(a+b−c) ​ / 4 求得。

1. 正确正确
2. 错误错误

可以使用深度优先搜索算法判断图的连通性。

1. 正确正确
2. 错误错误

在N个元素的二叉排序树中查找一个元素，平均情况的时间复杂度是 𝑂 ( log ⁡ 𝑁 ) O(logN)。

1. 正确正确
2. 错误错误

给定 double 类型的变量 x，且其值大于等于 1，我们可以通过二分法求出 log ⁡ 𝑥 logx的近似值。

1. 正确正确
2. 错误错误