客观题逐题精讲

小杨家响应国家“以旧换新”政策，将自家的汽油车置换为新能源汽车，正在准备自编车牌。自编车牌包括5位数字或英文字母，要求第5位必须是数字，前4位中可以有最多1位英文字母。英文字母必须是大写，而且不能是O或I（因为容易与数字0或1混淆）。请问自编车牌共有多少种可能性？（）。

1. A100,000
2. B1,060,000
3. C1,360,000
4. D1,460,000

新年到，四家人在一起聚会。其中两家有三口人，另外两家有两口人。现在要安排大家在一张十人圆桌坐下，要求一家人必须相邻就座。由于有“主座”的习俗，每个座位都被认为是不同的。请问共有多少种就座方案？（）。

1. A8640
2. B6912
3. C144
4. D60

下面关于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. Avoid Bubble(int a[10][], int m);
2. Bvoid Bubble(int a[][], int n, int m);
3. Cvoid Bubble(int (*a)[20], int n);
4. Dvoid Bubble(int * a[20], int n);

已知两个点 A、B 在平面直角坐标系下的坐标分别为 ( 𝑥 𝑎 , 𝑦 𝑎 ) (xa,ya)和 ( 𝑥 𝑏 , 𝑦 𝑏 ) (xb,yb)，并分别定义变量 double xa，ya，xb，yb；存储坐标。假设直线 AB 的斜率存在，下列哪个表达式可以用来表达它？（）。

1. A(xa - xb) / (ya - yb)
2. B(xa - xb) / (yb - ya)
3. C(ya - yb) / (xa - xb)
4. D(ya - yb) / (xb - xa)

二项式 ( 𝑥 + 𝑦 ) 6 (x+y) 6 的展开式中 𝑥 3 𝑦 3 x 3 y 3 项的系数是（）。

1. A6
2. B15
3. C20
4. D120

以下关于动态规划的说法中，错误的是（）。

1. A动态规划方法有递推和递归两种实现形式。
2. B递归实现动态规划方法的时间复杂度总是不低于递推实现。
3. C动态规划方法将原问题分解为一个或多个相似的子问题。
4. D动态规划方法通常能够列出递推公式。

在下面的程序中，使用整数表示一种组合。整数二进制表示的某一位为1，表示该位对应的数被选中，反之为0表示未选中。例如，从0 - 5这6个数中选出3个，则0b111000代表选中3，4，5三个数，0b011001代表选中0，3，4三个数。zuhe_next函数按组合对应的整数由大到小的顺序，求出组合c的下一个组合。横线处可以填入的是（）。

int intlow2(int c) {
    return ___; // 在此处填入选项
}
int zuhe_next_incur(int c, int n, int l) {
    if (n == 1) return c;
    if ((c & (1 << 1)) == 0) {
        int d = intlow2(c);
        c = (c & ~d);
        c = (c | (d >> 1));
    } else {
        c = (c & ~(1 << 1));
        c = zuhe_next_incur(c, n - 1, l + 1);
        int d = intlow2(c);
        c = (c | (d >> 1));
    }
    return c;
}

// 从n个数中选m个，当前组合为c
int zuhe_next(int c, int n, int m) {
    return zuhe_next_incur(c, n, 0);
}

1. A((c - 1)^c)
2. B((c - 1)^c) + 1)
3. C((c - 1)^c) >> 1)
4. D((((c - 1)^c) + 1) >> 1)

下面程序的输出为（）。

#include <iostream>
using namespace std;
int main() {
    int N = 15, cnt = 0;
    for (int x = 0; x + x + x <= N; x++)
        for (int y = x; x + y + y <= N; y++)
            for (int z = y; x + y + z <= N; z++)
                cnt++;
        cout << cnt << endl;
        return 0;
}

1. A174
2. B447
3. C816
4. D4096

下面最长公共子序列程序中，横线处应该填入的是（）。

#define MAX(A, B) ((A) > (B)) ? (A) : (B))
#define MIN(A, B) ((A) < (B)) ? (A) : (B))
int dp[MAX_L + 1][MAX_L + 1];
int LCS(char str1[], char str2[]) {
    int len1 = strlen(str1);
    int len2 = strlen(str2);
    for (int i = 0; i < len1; i++)
        for (int j = 0; j < len2; j++)
            if (str1[i] == str2[j])
                dp[i + 1][j + 1] = dp[i][j] + 1;
        else
            // 在此处填入选项
        return dp[len1][len2];
    }
}

1. Adp[i + 1][j + 1] = dp[i][j + 1] + dp[i + 1][j]
2. Bdp[i + 1][j + 1] = MIN(dp[i][j + 1], dp[i + 1][j])
3. Cdp[i + 1][j + 1] = MAX(dp[i][j + 1], dp[i + 1][j])
4. Ddp[i + 1][j + 1] = MAX(dp[i][j + 1], dp[i + 1][j]) + 1

下列Dijkstra算法中，横线处应该填入的是（）。

typedef struct Edge {
    int in, out; // 从下标in顶点到下标out顶点的边
    int len; // 边长度
    struct Edge * next;
} Edge;
// v: 顶点个数, graph: 出边邻接表, start: 起点下标, dis: 输出每个顶点的最短距离
void dijkstra(int v, Edge * graph[], int start, int * dis) {
    const int MAX_DIS = 0x7fffff;
    for (int i = 0; i < v; i++)
        dis[i] = MAX_DIS;
    dis[start] = 0;
    int * visited = new int[v];
    for (int i = 0; i < v; i++)
        visited[i] = 0;
    visited[start] = 1;
    for (int t = 0; ; t++) {
        int min = MAX_DIS, minv = -1;
        for (int i = 0; i < v; i++) {
            if (visited[i] == 0 && min > dis[i]) {
                min = dis[i];
                minv = i;
            }
        }
        if (minv < 0)
            break;
        visited[minv] = 1;
        for (Edge * e = graph[minv]; e != NULL; e = e->next) {
            ___ // 在此处填入选项
        }
    }
    delete[] visited;
}

1. A1 if (dis[e->out] > e->len) 2 dis[e->out] = e->len;
2. B1 if (dis[e->out] > min + e->len) 2 dis[e->out] = min + e->len;
3. C1 if (dis[e->in] > e->len) 2 dis[e->in] = e->len;
4. D1 if (dis[e->in] > min + e->len) 2 dis[e->in] = min + e->len;

假设图 graph 中顶点数 v、边数 e，上题程序的时间复杂度为（）。

1. A𝑂 ( 𝑒 ) O(e)
2. B𝑂 ( 𝑣 2 ) O(v 2 )
3. C𝑂 ( 𝑣 log ⁡ 𝑣 + 𝑒 ) O(vlogv+e)
4. D𝑂 ( ( 𝑣 + 𝑒 ) log ⁡ 𝑣 ) O((v+e)logv)

下面的快速排序程序中，两处横线处分别应填入的是（）。

void quick_sort(int a[], int n) {
    if (n <= 1)
        return;
    int pivot = 0, l = 0, r = n - 1;
    while (____) { // 在此处填入选项
        while (r > pivot && a[r] >= a[pivot])
            r--;
        if (r > pivot) {
            int temp = a[pivot];
            a[pivot] = a[r];
            a[r] = temp;
            pivot = r;
        }
        while (l < pivot && a[l] <= a[pivot])
            l++;
        if (l < pivot) {
            int temp = a[pivot];
            a[pivot] = a[l];
            a[l] = temp;
            pivot = l;
        }
    }
    quick_sort(a, pivot);
    quick_sort(____); // 在此处填入选项
}

1. A1 | l < r 2 | a + pivot + 1, n - pivot - 1
2. B1 | l < r 2 | a + pivot + 1, n - pivot
3. C1 | l <= r 2 | a + pivot + 1, n - pivot - 1
4. D1 | l <= r 2 | a + pivot + 1, n - pivot

上题程序的时间复杂度为（）。

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

表达式 '3' + '5' 的结果为 '8'，类型为 char。

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

在C++语言中，可以在函数内定义结构体，但该结构体类型只能在该函数内使用。

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

对n个元素的数组进行排序，快速排序和归并排序的平均时间复杂度都为 𝑂 ( 𝑛 log ⁡ 𝑛 ) O(nlogn)。但快速排序存在退化情况，使得时间复杂度升高至 𝑂 ( 𝑛 2 ) O(n 2 )；归并排序需要额外的空间开销。

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

二维数组的最后一维在内存中一定是连续的，但第一维在内存中可能不连续。

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

使用 math.h 或 cmath 头文件中的函数，表达式 log ⁡ ( 1000 ) log(1000)的结果类型为 double、值约为 3。

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

你有三种硬币，分别面值2元、5元和7元，每种硬币都有足够多。买一本书需要27元，则有8种硬币组合（组合与顺序无关，“1个2元+1个5元+1个2元”与“1个5元+2个2元”认为是同样的组合）可以正好付清，且不需要对方找钱。

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

使用哈希函数 𝑓 ( 𝑥 ) = 𝑥 % 𝑝 f(x)=x%p建立键值为 int 类型的哈希表，只要 p 取小于等于哈希表大小的素数，可保证不发生碰撞。

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

杨辉三角中的第n行、第m项，即为将二项式 ( 𝑎 + 𝑏 ) 𝑛 (a+b) n 展开后 𝑎 𝑛 − 𝑚 𝑏 𝑚 a n−m b m 项的系数。

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

判断图是否连通，可以通过广度优先搜索实现。

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

要求解一元二次方程 𝑥 2 + 𝑎 𝑥 + 𝑏 = 0 x 2 +ax+b=0，需要先判断表达式 𝑎 2 − 𝑏 × 4 ≥ 0 a 2 −b×4≥0是否为真。

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