2026年9月 GESP C++ 真题答案 + 解析
一 ~ 八级全套

考运算符优先级。4 + -2 * 3 中,一元负号和 * 都优先于 +:先算 -2 * 3 = -6,再 4 + (-6) = -2。选 A。

2 * -2 % 3 中 * 与 % 同级、从左到右。先 2 * -2 = -4,再 -4 % 3。C++ 取模结果符号随被除数,得 -1。选项 A (2 * -2) % 3 括号没改变原顺序,值仍为 -1;B 先 -2%3=-2 再 ×2=-4;C 2*-(2%3)=-4;D 2%-2*3=0。选 A。

整数除法会截断取整。a%b = 8%10 = 8;a*1/b = 8/10 = 0(全是整数,先算 8/10 截断为 0);a*1.0/b = 8.0/10 = 0.8(有浮点参与)。输出 8 0 0.8,选 C。

++b *= 2 + 1 即 ++b *= 3。先前置自增,b 变 9;再复合赋值 b = 9 * 3 = 27。选 D。

for(i=-10; i<0; i++) 循环体走 10 次(i 从 -10 到 -1),cnt=10;但循环结束时 i 已自增到 0。i * cnt = 0 * 10 = 0。易错点:输出用的是退出循环后的 i,不是最后一轮的 i。选 C。

i=1 时 1%3!=0 成立走 else:打印 1- 后 break 跳出。再执行循环外 printf("%dEND*", i),此时 i=1,输出 1END*。合起来 1-1END*,选 D。

本题选错误的说法。输入 1:循环打印 1#,tot 累加到 1,退出后打印 1-END,实际是 1#1-END。选项 D 说输出 1#0-END,与实际不符,故 D 为错误说法。选 D。

while 循环体第一句就是 k += 2; continue;,continue 直接跳回条件判断,后面的 if/break 和 cout 永远执行不到(死代码)。k 依次 2→4→6→8 退出,最后 if(k>=8) 成立只输出 FINISH。选 A。

循环让兔数从 0 试到 tou,找到解就 break;若走完没 break,退出时 tu_tou = tou + 1。原代码用 if(tu_tou == tou) 判无解是错的。应改成 tu_tou == tou + 1(才是"循环没提前跳出"的标志)。选 D。

3 位数取最高位应用 n / 100;n % 100 取的是后两位。n=123 时 123 % 100 = 23,不是 1。命题错误。

for 循环体只有那条 if(i%3!=0) continue;,而 cout<<i 在循环外面。步长为 3,i 恒是 3 的倍数,continue 从不触发。循环结束时 i=21(第一个 ≥20 的值),输出 21 而非 20。命题错误。

z=12.0 → z=z/4=3.0 → z-- 后 z=2.0 → cout<<z++ 是后置自增,先输出当前值 2 再自增。所以输出 2,命题正确。

for(idx=1; idx<=7; idx+=2) 取 1,3,5,7:idx=1 累加 ans=1;idx=3 累加 ans=4;idx=5 continue 跳过;idx=7 时 7*7=49>30 触发 break。最终 ans=4,不是 3。命题错误。

3 == 3.0 比较相等成立,C++ 里布尔真输出为整数 1(不是 true 字样,也不是 1.0)。选 A。

bool(x) 只要 x 非零就是 1。bool(5)=1、bool(-5)=1(负数也非零)、bool(5.0)=1,相加 1+1+1=3。选 D。

for(i=0..9) if(i) tot+=1:if(i) 把 i=0 当作假跳过,i=1..9 共 9 次为真,tot=9。选 C。

if(i%3) 为真表示 i 不是 3 的倍数。i=0..9 中非 3 倍数为 1,2,4,5,7,8,累加 1+2+4+5+7+8=27。选 D。

not(i%3!=0) 等价于 i%3==0。i 从 -5 到 4 中 i%3==0 的有 -3、0、3 共 3 个(C++ 里 -3%3=0),tot=3。选 B。

本题选错误的说法。D 称把 sqrt(n)+1 里的 1 改成任意 ≥1 的整数"结果不会错、只是变慢"——这是错的:若改得过大使 limit > n,循环会遍历到 i == n,而 n % n == 0 会把素数误判成"非素数"。所以 D 错误,选 D。

外层 i=1,2,3,内层 j 从 1 到 i,累加 i*j。i=1:1;i=2:2+4=6(累计7);i=3:3+6+9=18(累计25)。选 D。

j=0 时 j%3==0 恒 continue。i=1:j=0 跳过;i=2:j=1 count=1、2*1>=2 break;i=3:j=1 count=2、3*1>=2 break。退出后 i=4、j=1、count=2,输出 4 1 2。选 C。

要选身高差最小者,并列时取"较矮的第一个"。条件 diff < min_diff || (diff == min_diff && h < best_height):严格更近就更新,或同样近但更矮才更新。选 A。

在 diff == min_diff(并列最近)分支里,只有当 h < best_height(更矮)时才替换。选 A。

'2' 是字符,参与运算时取 ASCII 码 50。2 * -'2' / 4 = 2*(-50)/4 = -100/4 = -25,不是 -1。命题错误。

a == +5 是比较(结果被丢弃),不是赋值,a 仍为 5。输出 5 而非 10。易错:== 不是 =。命题错误。

not 5 得 false=0,not 0 得 true=1。not not 5 输出 1,不是 5。命题错误。

代码 for(i=0; i<N+1; i++) tot+=i 只对 N≥0 求 0..N 之和。题目说"N 是整数"含负数:当 N<0 时循环一次不执行,输出 0,并非真正的求和。命题错误。

int(sqrt(N)) == abs(M) 只看平方根取整后是否等于 |M|,没验证 N == M*M。如 N=10、M=3,int(sqrt(10))=3==3 会误报"10 是 3 的平方"。应改为判断 M*M == N。命题错误。

考 for 三段的位置。for(int i=0; i=0; i<=5) 中间是循环条件 i=0(赋值表达式,值为 0 即假),所以循环一次都不执行;末段 i<=5 只是个比较、无副作用。x 保持 1,输出 1。选 A。

x = x & (x - 1) 每次消去 x 最低位的 1(Brian Kernighan 算法),循环次数 = x 二进制中 1 的个数。2026 = 11111101010₂ 共有 8 个 1,故 count=8。选 B。

位运算优先级 ~ > & > ^ > |。~11 = -12;3 & 7 = 3;15 ^ (-12) = -5;最后 3 | (-5) = -5。选 D。

异或有"自反"性:x ^ key ^ key == x。前面已用 ^ key 加密,要解密还原必须再异或一次同一个 key。选 C(msg[i] = msg[i] ^ key)。

判断进制要用字符比较:字符串里最大字符 max 若 <= '1' 则可能是二进制,<= '7' 八进制,<= '9' 十进制,<= 'F' 十六进制。注意要和字符 '1' 比而不是整数 1。选 A。

位掩码权限操作:加权限用 | (置位),清某位保留其他用 & (~权限)。加读 |READ、加写 |WRITE、清读 &(~READ)、加删除 |DELETE。选 A。

优先级 ! > << > & > ^ > |。!a=1;b<<c = 2<<11 = 4096;1 & 4096 = 0;0 ^ 7 = 7;7 | 5 = 7。选 C。

本题选错误说法。s.erase(2) 会从下标 2 一直删到末尾,不是只删一个字符(只删一个要用 s.erase(2, 1))。故 D 错误。

int b['A'] 里 'A' 是字符,其 ASCII 值 65 是合法的整型数组大小,合法。A 的 3.0 是 double 属窄化;C 无大小又无初值不完整;D 数组大小须整型,10.0 非法。选 B。

每只老鼠对"哪缸有毒"贡献一个三进制位:两轮都不喝 / 第一轮喝 / 第二轮喝,共 3 种可区分状态。k 只老鼠能区分 3^k 种情况,3^6=729 < 1000 ≤ 3^7=2187,故最少 7 只。选 B。

"进位循环加到最低位"是反码加法的规则。补码加法直接把最高位的进位丢弃即可。命题错误。

求补码的扫描规则应是:从右向左遇到第一个 1 之后,左边各位全部取反、右边(含这个 1)保持不变。命题把左右说反了,错误。

for(int num : a) 里的 num 是元素的副本,对 num 赋值不会改动原数组。要真正修改需用引用 for(int& num : a)。命题错误。

(a & 1) == 1 只说明 a 是奇数,负奇数也满足(如 -3 & 1 == 1)。不一定是"正"奇数。命题错误。

"GESP" 连同结尾 '\0' 需要 5 个字节,而 char str[4] 只有 4 个,放不下(数组下标 str[4] 本身也已越界)。命题错误。

str[i]==0 是和整数 0、1 比较(对应 ASCII 的空字符等),不是字符 '0'/'1'(ASCII 48/49)。应写 str[i]=='0' || str[i]=='1'。命题错误。

a='a'=97 > 0 成立,|| 发生短路求值,右边 b++ 根本不执行,b 保持 'b'=98。输出 98,命题正确。

枚举可以配合剪枝/范围约束,在保证不漏解的前提下缩小搜索空间,并非必须遍历所有可能。命题正确。

const int *p 是"指向常量的指针":不能通过 *p 改所指的值,但指针本身可以改指向,所以 p = &b 合法。选 B。(要"指针不可改"得写 int * const p。)

int(*p)[4] 是"指向含 4 个 int 的一维数组"的指针,p+1 跳到第 1 行。*(*(p+1)+2) 即 goods[1][2] = 14。选 B。

二维数组作形参必须给出除第一维外的所有维长。3 行 5 列应写 int arr[][5](等价于 int(*arr)[5])。选 C。

update(int &score) 按引用修改的是 main 里的局部 score:80+5=85。::score 是全局变量,仍为 60。输出 85 60。选 A。

reset(Device d) 传值,改的是副本,原 d.state 不变(仍 2);start(Device &d) 传引用,d.state 变 3。输出 7 3。选 D。传值/传引用是本题核心。

p = books + 1 指向 books[1](Math,150),p->pages += 10 改的就是 books[1],变 160。输出 Math 160。选 C。

这是斐波那契式递推(每步方法数 = 前两步之和)。ways:b 依次为 2→3(i=3)→5(i=4)→8(i=5)→13(i=6),ways(6)=13。选 C。

排序前 (90,'A') 在 (90,'C') 之前,排序后变成 C 在 A 之前——相同 score 的相对顺序被打乱,说明该排序不稳定。选 C。

插入排序:把 key 插入前面有序段。只要前一个元素比 key 大就右移,条件是 a[j] > key。选 B。

双重循环,内层 j 从 i+1 到 n,总比较次数约 n(n-1)/2,时间复杂度 O(n²)。选 D。

fin >> a >> b 以空白分隔,a="Blue"、b="Sky"。输出 b<<"-"<<a 得 Sky-Blue。选 B。

throw age 抛出的是 int(-1)。catch(const char*) 类型不匹配跳过,被 catch(int value) 捕获,输出 C 加 value,即 C-1。选 C。异常按类型精确匹配。

优化冒泡:每轮开始把标志置 false,一旦发生交换就置 true;若一整轮没交换(!changed)说明已有序,提前 break。故两横线依次填 false、true。选 A。

函数只需在调用前有声明(原型),定义可以放到后面或别的文件。"必须先定义"说法错误。

change(int x) 是传值,函数内改 x 不影响 main 的 x,输出仍是 10 而非 20。要改需传引用 int& x。命题错误。

稳定的插入排序,移动条件应是严格 a[j] > key。若用 a[j] >= key,相等元素也会被越过,反而破坏稳定性。命题恰好说反,错误。

外层跑 n 次,内层 j 每次翻倍(j*=2)只跑约 log₂n 次,总复杂度是 O(n·log n),不是命题所给的值。命题错误。

throw "Error" 抛的是 const char*,而 catch(int e) 只接 int,类型不匹配接不住。异常未被捕获会导致程序异常终止,不会输出 Caught。命题错误。

已知尾指针 tail 时,尾插只需 tail->next = s; tail = s; 两步,与链表长度无关,时间复杂度 O(1)。选 A。(若没有 tail 就得从头遍历,才是 O(n)。)

双向链表删中间结点要"接上前后":p->prev->next = p->next; 再 p->next->prev = p->prev;,最后 delete p。选 C。

快慢指针找中点:slow 每次走 1 步,fast 每次走 2 步,即 fast = fast->next->next。循环条件已保证 fast 和 fast->next 非空。选 B。

辗转相除:gcd(105,45) → 105%45=15 → gcd(45,15) → 45%15=0 → 返回 15。选 C。

判质数只需试到 √n,即 i*i <= n;并且 i*i 可能超 int,要用 (long long)i*i <= n 防溢出。C 用 i*i < n 会漏掉 i*i==n 的完全平方情形。选 D。

线性筛保证每个合数只被最小质因子筛一次:当 i % p == 0 时 p 就是 i 的最小质因子,再往后的更大质数会重复筛,故此时 break。选 B。

递归求和:f(4)=4+f(3)=4+3+f(2)=4+3+2+f(1)=4+3+2+1=10。选 D。

找"第一个严格大于 x"的位置(upper_bound):当 a[mid] <= x 时答案在右边,l=mid+1;否则 r=mid。故横线填 a[mid] <= x。选 C。

二分答案求"最小可行载重":check(mid) 成立说明 mid 够用,尝试更小 r=mid;不够则 l=mid+1。选 B。

归并排序要稳定,当两侧元素相等时应优先取左半(下标小的在前),即条件 a[i] <= a[j] 时取左。选 D。

快排划分以 a[right] 为枢轴,把"不大于枢轴"的元素换到左侧:当 a[j] <= pivot 时 i++ 并交换。选 A。

活动选择的经典贪心:按结束时间从早到晚排序,依次选与已选不冲突的活动,才能排最多场。"开始最早/时间最短"都会得到次优解。选 D。

Kadane 算法。对 {-2,3,-1,5,-6,2}:current/best 依次为 3、2、7、1、3,best 最大为 7(即子段 3,-1,5)。选 C。

高精度加法每位:sum = 进位 + a[i] + b[i],本位存 sum%10,新进位是 sum/10。故横线填 carry = sum / 10。选 C。

在已知结点 p 后插入 s:先 s->next = p->next; 再 p->next = s;,只改两个指针,时间 O(1)。顺序也正确(先接后断)。命题正确。

代码先 delete p 再访问 p->next,这是释放后使用(悬空指针),行为未定义。正确做法是先 head = p->next; 再 delete p;。命题错误。

欧几里得算法对 a < b 同样成立:第一轮 r = a%b = a(因 a<b),随后 a=b, b=a 相当于自动交换,后续正常。命题正确。

埃氏筛从 i*i 开始标记:因为 i*2, i*3, …, i*(i-1) 这些较小的倍数,已经被它们更小的质因子(2,3,…)筛过了,无需重复。命题正确。

for(i=1; i<=n; i*=2) 中 i 每次翻倍,循环约执行 log₂n 次,时间复杂度是 O(log n),与命题所给不符。命题错误。

二分查找"最后一个 ≤ x":命中 a[mid] <= x 时记录 ans=mid 并继续向右找更大的;找不到则保持初值 -1。逻辑正确。命题正确。

快排若固定取第一个元素为枢轴,遇到已升序的输入,每次划分都极不平衡(一侧为空),退化为 O(n²),并非理想的 O(n log n)。命题所述复杂度错误。

"每次取最大面值"的贪心不能对任意币值集合求最少硬币数。反例:币值 {1,3,4} 凑 6,贪心得 4+1+1=3 枚,最优是 3+3=2 枚。命题错误。

高精度减法里借位方向写反了:借位时设 borrow=1,下一位却用 a[i]-b[i]+borrow(相当于多加 1)。借出的 1 应从高位减去,正确应是 a[i]-b[i]-borrow(或令 borrow=-1)。命题错误。

speak() 是 virtual,Animal *p = new Cat() 调用 p->speak() 时按实际对象(Cat)动态绑定,输出 Cat。选 B。这就是多态。

在派生类构造函数的初始化列表里调用基类带参构造函数,直接写 Machine(s)。选 A。(super 是 Java 语法,C++ 没有。)

构造从基类到派生:B D;因基类析构为 virtual,delete p 正确地先派生后基类析构:~D ~B。合起来 B D ~D ~B。选 C。

入栈/入队 2,4,6。栈(后进先出)pop 掉 6,top=4;队列(先进先出)pop 掉 2,front=4。输出 4 4。选 B。

"空一格"法的循环队列,队满条件是 (rear + 1) % MAXN == front(再入一个就会追上 front)。选 C。而 rear==front 表示队空。

访问顺序是"左 → 根 → 右",即中序遍历。选 B。

先序 ABDEC F 的首字符 A 是根;中序 DBEA CF 中 A 左边 DBE 为左子树、右边 CF 为右子树。递归还原后,后序(左右根)为 D E B F C A。选 A。

树高 = 左右子树高的较大者 + 1(算上当前层):max(leftH, rightH) + 1。选 D。

用栈做 DFS 要"左子树优先",由于栈后进先出,应先压右、后压左,这样左孩子先出栈。C 还加了非空判断更稳妥。选 C。

二叉搜索树查找:x < root->val 去左子树,否则去右子树,即 searchBST(root->right, x)。选 B。

格雷码反射生成:把旧序列逆序并在前面加 1(即 "1" + ans[i]),再给原来的前一半加 0。选 C。

爬楼梯:到第 i 级 = 从 i-1 级迈一步 + 从 i-2 级迈两步,dp[i] = dp[i-1] + dp[i-2](斐波那契)。选 B。

"打家劫舍"(不选相邻):dp[i] = max(dp[i-1], dp[i-2] + a[i])——要么不选 i,要么选 i 并加上 i-2 的最优。选 C。

一维 0/1 背包内层容量从大到小枚举,是为了让 dp[w-weight[i]] 用的是"还没放第 i 件"时的旧值,从而保证每件物品最多选一次。若从小到大就变成完全背包(可重复选)。选 A。

一旦类里自定义了任何构造函数(这里的 Student(int)),编译器就不再自动生成无参构造函数。Student s; 会编译失败。命题错误。

派生类不能直接访问基类的 private 成员 value(private 对派生类也不可见,需 protected 或公有接口)。命题错误。

队列先进先出:push 10,20,30 后 pop 弹出的是最先进的 10,此时 front 是 20,不是 30。命题错误。

完全二叉树用数组从下标 1 存:结点 tree[i] 的左孩子在 tree[2i]、右孩子在 tree[2i+1]。命题正确。

二叉搜索树的中序遍历(左-根-右)一定得到非递减(有序)序列,这是 BST 的基本性质。命题正确。

这段用队列做的是 BFS。在无权图中,BFS 第一次到达某结点所经过的边数,就是从起点到它的最短边数。命题正确。

哈夫曼编码是贪心构造:频率越高的字符越靠近树根,其编码长度不会比频率更低的字符更长。命题正确。

格雷码的性质是相邻两个编码只差一位,并非"任意两个"都只差一位。命题以偏概全,错误。

一维 dp 内层容量从小到大(w 从 weight[i] 到 W),会让同一件物品被重复累加,正是完全背包。命题正确。

朴素递归斐波那契存在大量重复子问题,时间复杂度约 O(2ⁿ);但递归深度只有 n,空间复杂度是 O(n)。二者并不相同。命题错误。

a&b = 5&3 = 1(101 & 011 = 001);a|b = 5|3 = 7(101 | 011 = 111)。1 + 7 = 8。注意 + 优先级高于位运算,但这里已用括号。选 C。

log(1) 返回 0.0,类型是 double,正确。A 错:pow 返回 double;B 错:三角函数参数是弧度不是度;C 错:sqrt 返回 double。选 D。

二叉排序树查找:平均情况树较平衡为 O(log n);最坏情况(数据有序,树退化成链)为 O(n)。选 A。

无权图中 BFS 逐层扩展,dist[v]=dist[u]+1 得到的正是从起点到 v 的最少边数(最短路)。选 A。

泛洪填充要避免递归过深,应改用非递归:用队列做 BFS,或用显式栈模拟 DFS。选 D。其余选项与泛洪填充无关。

开放定址法冲突后,会在表内按探测序列寻找下一个可用位置,正确。A 错(冲突无法完全避免);B 错(链地址法最坏 O(n));D 错(查找速度与装填因子有关)。选 C。

inc(int &x) 按引用传参,x++ 改的就是 main 里的 a:3→4。输出 4。选 B。

最长公共子序列:当两序列当前字符相等时,dp[i][j] = dp[i-1][j-1] + 1(在去掉这对相同字符的最优解上加 1)。选 A。若不相等才取 max(dp[i-1][j], dp[i][j-1])。

一维 0/1 背包,只有一件物品(w=3,v=5)。c 从 8 递减到 3,每个 dp[c]=max(dp[c], dp[c-3]+5),由于放得下一件,dp[8]=5。选 D。

要保持相等元素相对顺序(稳定性),冒泡、插入、归并都稳定,而快速排序因交换跨距大是不稳定的,最不适宜。选 D。

内层 j 以步长 i 递增,执行约 n/i 次。总次数 n/1 + n/2 + … + n/n = n·(1+1/2+…+1/n) ≈ n·ln n(调和级数),复杂度 O(n log n)。选 B。

p = a + 1 指向 a[1]。*(p + 3) 即 a[4] = 9。选 C。

exp(0) = e⁰ = 1.0,cmath 函数返回 double。命题正确。

开放定址法里若删除元素后直接置空,会切断探测链,导致本应通过该位置继续探测才能找到的元素查不到。正确做法是打"已删除"标记。命题错误。

哈夫曼树中频率更高的叶子深度不会更大,但不一定"总是更小"——可能与其他叶子处于同一深度。"总是更小"过于绝对,错误。

有向图中每条边贡献一个出度和一个入度,故所有顶点入度之和 = 出度之和 = 边数。命题正确。

广度优先搜索(BFS)通常借助队列,深度优先搜索(DFS)通常借助栈或递归。命题正确。

快速排序平均 O(n log n),但最坏(如枢轴选择不当遇有序数据)会退化到 O(n²),并非也是 O(n log n)。命题错误。

一维数组优化 0/1 背包时,内层容量必须从大到小枚举,以保证每件物品只被选一次。命题正确。

用邻接表时,遍历某顶点的所有邻边耗时正比于该顶点的度数(邻边条数),而不是图中顶点总数。命题错误。

层序从 1 编号的完全二叉树中,结点 i 的父结点编号为 ⌊i/2⌋(左右孩子分别是 2i、2i+1)。命题正确。

arr 与 &arr[0] 虽然都表示首元素地址,但并非总是等价:在 sizeof(arr) 中 arr 代表整个数组(得数组总字节数),类型也不同(数组 vs int*)。命题错误。

先序 ABDEC FG 根为 A;中序 DBEA FCG 中 A 左边 DBE 为左子树、右边 FCG 为右子树。递归还原(左子树根 B、右子树根 C)后,后序(左-右-根)为 D E B F G C A。选 A。

快速幂把指数按二进制拆分,每步平方并按位选乘,乘法次数从朴素的 O(n) 降到 O(log n)。A 错(负指数需特殊处理)、C 错(不限模数)、D 错(空间通常 O(1))。选 B。

Prim 基于顶点扩展,适合稠密图;Kruskal 基于边排序 + 并查集,适合稀疏图。B 错(边权有相同值时 MST 可能不唯一)、C 错(Kruskal 用边集不需邻接矩阵)、D 错(MST 针对无向图)。选 A。

堆优化 Dijkstra 的优先队列里,每个元素存"顶点编号 + 该顶点当前最短距离",每次取出距离最小的顶点松弛。选 A。

Floyd 三重循环最外层 k 表示"允许作为中间点的顶点编号上限":只用编号 ≤ k 的顶点做中转来更新任意 i→j 的最短路。选 A。(所以 k 必须在最外层。)

差分数组的每次区间加是 O(1),m 次共 O(m);最后一次前缀和还原是 O(n)。整体 O(n + m)。选 D。

定义 B b:构造先基类后派生 → A B;析构逆序,先派生后基类 → ~B ~A。输出 AB~B~A。选 D。

从 4 本不同书选 3 本分给甲乙丙(每人至多 1 本),即有序选取 P(4,3) = 4×3×2 = 24 种。命题正确。

(a+b)ⁿ 展开式的二项式系数,奇数项之和 = 偶数项之和 = 2ⁿ⁻¹(令 x=-1 代入,交错和为 0 即得)。对任意正整数 n 成立。命题正确。

MST 中有权值相同的边,不一定导致 MST 不唯一——那些等权边可能是构成 MST 的必选边。是否唯一取决于是否存在可替换的等权边。命题绝对化,错误。

不使用堆优化的朴素 Dijkstra,每轮线性扫描找最小距离顶点,整体时间复杂度是 O(n²)(n 为结点数),与是否用邻接表无关。命题正确。

堆排序在调整堆时会进行跨距交换,会打乱相等元素的相对次序,是不稳定排序。命题错误。

算术基本定理:每个大于 1 的整数都能唯一分解为若干质因数之积(不计因子顺序)。命题正确。

循环队列常用"牺牲一个存储单元"的办法:队空为 front==rear,队满为 (rear+1)%N==front,从而区分两种状态。命题正确。

C++ 私有继承下,基类的 public 和 protected 成员在派生类中都变为 private,并非仍为 public。命题错误。

滚动数组是把二维 dp 压成一维(或几行)以节省空间,状态转移次数不变,因此只降空间不降时间复杂度。命题正确。