GESP C++ 五级 · 14 天闯关
CCF GESP 编程能力等级认证 · 五级
📖 学习进度 0/14
❓ 题目完成度 0/26
🎯 首答正确率 —

GESP C++ 五级 · 14 天闯关

线性结构 · 链表栈队列与数论筛法

7 天理论 + 7 天编程题:前 7 天把本级别考点的 近 11 期真题 165 道全部刷完(含 41 道需要看原卷配图的题), 后 7 天按知识点分天练编程题(洛谷题面 + 美力程题解),共 28 道; 末尾附 1 套模拟自测卷。

7
理论天
7
编程天
165
真题题位
28
编程题
41
含图题
1
模拟自测卷
编程题挑战 →
14 天路径

理论天含:① 今日考情(真题分布 + 配套教材)→ ② 知识地图(思维导图)→ ③ 核心精讲 → ④ 真题演练(本考点全部真题,10 题/卡)→ ⑤ 今日打卡。 编程天按知识点分组(如「图案输出 · 嵌套循环画图」一天),题面取洛谷、题解取美力程。 单选答案已与官方答案表逐题核对。进度保存在本机浏览器。

五级 · 理论 DAY 01

数论基础与素数筛法

📌 考点 素数判定 / 埃拉托斯特尼筛 / 线性筛(欧拉筛)✍️ 客观题 39⏱ 建议用时 50 分钟🎯 难度 ★★★★☆
①今日考情 · 真题分布与备考建议

本考点在 GESP C++ 5级近 14 期真题中共 39 道客观题(单选 39 / 判断 0,其中 7 道需看原卷配图)。本页把这一考点的真题全部收进来了,一道没漏,按每 10 题一张卡分组,可分次完成。

本期分布

期次题数
2023-092
2023-122
2024-035
2024-063
2024-094
2024-123
2025-033
2025-064
2025-096
2026-033
2026-094

配套教材

GESP 大通关 5 级(全书 76 页):本天对应 5.1 初等数论与辗转相除。教材按同一套大纲顺序编排,可对照阅读。

备考建议(出题人视角)

五级的第一道门槛就是数论,也是真题里占比最高的一块(约四分之一)。命题人考来考去就四件事:**素数怎么判、筛怎么打、gcd 怎么求、分解式怎么写**。这四件事都有固定模板,背下来就能直接得分。最大的坑是**筛的边界**:埃氏筛内层从 `i*i` 开始、线性筛 `i % p == 0` 就 break,这两处的「为什么」比「怎么写」更常考。

②知识地图 · 本考点思维导图
数论基础与素数筛法
  • 素数判定
    • 试除法:2 到 √n 逐个试
      • 只要 i*i <= n 就够,O(√n)
    • 注意 0、1 不是素数;2 是唯一偶素数
  • 埃拉托斯特尼筛(埃氏筛)
    • 从 2 开始,把每个素数的倍数划掉
    • 内层起点写 i*i 而不是 i*2
      • 因为 i*2 早已被更小的质因子筛过
    • 复杂度 O(n log log n)
  • 线性筛(欧拉筛)
    • 每个合数只被它的**最小质因子**筛一次
    • 关键:if (i % p == 0) break;
    • 复杂度 O(n),同时也顺便求出每个数的最小质因子
  • 辗转相除法(欧几里得算法)
    • gcd(a,b) = gcd(b, a % b),b=0 时答案是 a
    • lcm(a,b) = a / gcd(a,b) * b (先除后乘防溢出)
  • 唯一分解定理
    • 任何大于 1 的整数都能唯一写成质数幂的乘积
    • 360 = 2³ × 3² × 5
    • 分解只需试到 √n,剩下的 n>1 本身就是质因子
  • 同余与模运算
    • (a+b) % m = ((a%m) + (b%m)) % m
    • 减法要 +m 再 %m,防止出现负数
    • 乘法同理,但除法**不成立**
③核心精讲

1. 素数判定:试除法

bool isPrime(int n) {
    if (n < 2) return false;              // 0、1 不是素数
    for (int i = 2; (long long)i * i <= n; i++)   // 只试到 √n
        if (n % i == 0) return false;
    return true;
}

为什么只试到 √n?因为因数成对出现:若 n = a × b 且 a ≤ b,则必有 a ≤ √n。 找到了小的那个,大的那个自然就存在。

易错:i * i <= n 里 i 若接近 int 上限会溢出,写成 (long long)i * i <= n 最稳。

2. 埃氏筛:把倍数划掉

vector<bool> isPrime(n + 1, true);
isPrime[0] = isPrime[1] = false;
for (int i = 2; i <= n; i++)
    if (isPrime[i])
        for (long long j = (long long)i * i; j <= n; j += i)   // 从 i*i 开始
            isPrime[j] = false;

内层为什么从 i*i 开始(这是五级最爱考的一句话): 比 i*i 小的 i 的倍数都有更小的质因子,比如 6 = 2 × 3,在筛 2 的时候就已经被划掉了。 从 i*i 开始可以省掉大量重复标记。

复杂度:每个素数 i 要划 n/i 次,总和 n × (1/2 + 1/3 + 1/5 + …) ≈ n log log n。

3. 线性筛(欧拉筛):每个合数只筛一次

vector<int> primes;
vector<bool> comp(n + 1, false);
for (int i = 2; i <= n; i++) {
    if (!comp[i]) primes.push_back(i);
    for (int p : primes) {
        if ((long long)i * p > n) break;
        comp[i * p] = true;
        if (i % p == 0) break;      // ← 关键:p 已是 i 的最小质因子
    }
}

i % p == 0 就停下来的含义:此时 p 已经是 i 的最小质因子, 再往后用更大的质数去筛 i × p',那个合数的最小质因子仍然是 p,应该留给别人筛, 否则同一个合数会被筛多次就不再是 O(n) 了。

筛法复杂度特点
埃氏筛O(n log log n)好写、常数小,小范围实际更快
线性筛O(n)每个合数只筛一次,还能顺便求最小质因子

注意:理论复杂度线性筛更优,但在 n ≤ 10⁷ 的实际范围内埃氏筛因常数小而往往更快。 这个「理论与实际的差别」本身就是一道判断题。

4. 辗转相除法

int gcd(int a, int b) {
    return b == 0 ? a : gcd(b, a % b);
}
long long lcm(long long a, long long b) {
    return a / gcd(a, b) * b;        // 先除后乘,防溢出
}

手推:gcd(48, 18) → gcd(18, 12) → gcd(12, 6) → gcd(6, 0) = 6。

5. 唯一分解定理

任何大于 1 的整数都能唯一写成质数幂的乘积(忽略顺序):

360 = 2³ × 3² × 5

分解代码只试到 √n,循环结束后若 n > 1,剩下的这个 n 本身就是一个质因子:

for (int i = 2; (long long)i * i <= n; i++)
    while (n % i == 0) { cout << i << " "; n /= i; }
if (n > 1) cout << n;        // 别忘了这一步

6. 同余与取模

(a + b) % m = ((a % m) + (b % m)) % m
(a - b) % m = ((a % m) - (b % m) + m) % m      // +m 防负数
(a * b) % m = ((a % m) * (b % m)) % m

除法不满足这个性质,(a / b) % m ≠ ((a%m) / (b%m)) % m,需要逆元,五级不考。

✍️ 真题演练 · 共 39 题,点选项即时判分
15级GESP 真题📌 数论基础与素数筛法第 1–10 题 · 20 分
1.2025-06 第8题
唯一分解定理描述了关于正整数的什么性质?
2.2024-06 第5题
下面是根据欧几里得算法编写的函数,它计算的是与的( )。
int gcd(int a, int b) {
    while (b != 0) {
        int temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}
📄 题干原图(本题公式在 PDF 里不是文字,以原卷为准)
题干原图
3.2025-09 第9题
唯一分解定理描述的是( )。
4.2026-09 第6题
下面代码实现线性筛法。为了保证每个合数只被其最小质因子筛去一次,横线处应填写( )。
vector<int> linearSieve(int n) {
    vector<bool> composite(n + 1, false);
    vector<int> primes;
    for (int i = 2; i <= n; i++) {
        if (!composite[i])
            primes.push_back(i);
        for (int p : primes) {
            if ((long long)i * p > n)
                break;
            composite[i * p] = true;
            if (__________________)
                break;
        }
    }
    return primes;
}
5.2025-09 第5题
以下代码计算两个正整数的最大公约数(GCD),横线上应填写( )。
int gcd0(int a, int b) {
    if (a < b) {
        swap(a, b);
    }
    while(b != 0) {
        int temp = a % b;
        a = b;
        b = temp;
    }
    return ______;
}
6.2024-03 第1题
唯一分解定理描述的内容是( )?
7.2025-09 第8题
关于 埃氏筛 和 线性筛 的比较,下列说法错误的是( )。
8.2026-03 第6题
埃氏筛中将内层循环从 j = i*i 开始而不是 j = 2*i 的主要原因是( )。
vector<int> eratosthenes_sieve(int n) {
    vector<bool> is_composite(n + 1, false);
    vector<int>  primes;
    for (int i = 2; i <= n; i++) {
        if (is_composite[i]) continue;
        primes.push_back(i);
        for (long long j = (long long)i * i; j <= n; j += i)
            is_composite[j] = true;
    }
    return primes;
}
9.2024-03 第9题
下面的代码片段用于判断一个正整数是否为素数。请对以下代码进行修改,使其能正确实现相应功能。( )
bool isPrime(int num) {
    if (num < 2) {
        return false;
    }
    for (int i = 2; i * i < num; ++i) {
        if (num % i == 0) {
            return false;
        }
    }
    return true;
}
10.2024-12 第6题
唯⼀分解定理表明,每个⼤于1的⾃然数可以唯⼀地写成若⼲个质数的乘积。下⾯函数将⾃然数的所有质因 数找出来,横线上能填写的最佳代码是()。
#include <vector>
vector<int> get_prime_factors(int n) {
    vector<int> factors;
    if (n <= 1) {
        cout << "输入的数必须是大于1的正整数" << endl;
        return;
    }
    while (n % 2 == 0) {
        factors.push_back(2);
        n /= 2;
    }
    ________________________________    {    // 在此处填入代码
        while (n % i == 0) {
            factors.push_back(i);
            n /= i;
        }
    }
    if (n > 2) {
        factors.push_back(n);
    }
    return factors;
}
参考答案(第 1–10 题)
  • 1.B 唯一分解定理描述了关于正整数的什么性质?…
  • 2.C 下面是根据欧几里得算法编写的函数,它计算的是与的( )。…
  • 3.B 唯一分解定理描述的是( )。…
  • 4.B 下面代码实现线性筛法。为了保证每个合数只被其最小质因子筛去一次,横线…
  • 5.B 以下代码计算两个正整数的最大公约数(GCD),横线上应填写( )。…
  • 6.B 唯一分解定理描述的内容是( )?…
  • 7.B 关于 埃氏筛 和 线性筛 的比较,下列说法错误的是( )。…
  • 8.C 埃氏筛中将内层循环从 j = i*i 开始而不是 j = 2*i 的…
  • 9.B 下面的代码片段用于判断一个正整数是否为素数。请对以下代码进行修改,使…
  • 10.D 唯⼀分解定理表明,每个⼤于1的⾃然数可以唯⼀地写成若⼲个质数的乘积。…
25级GESP 真题📌 数论基础与素数筛法第 11–20 题 · 20 分
11.2025-06 第5题
下列C++代码判断一个正整数是否是质数,说法正确的是( )。
bool is_prime(int n) {
    if (n <= 1)
        return false;
    if (n == 2 || n == 3 || n == 5)
        return true;
    if (n % 2 == 0 || n % 3 == 0 || n % 5 == 0)
        return false;
    int i = 7;
    int step = 4;
    int finish_number = sqrt(n) + 1;
    while (i <= finish_number) {
        if (n % i == 0)
            return false;
        i += step;
        step = 6 - step;
    }
    return true;
}
for (int i = 2; i < finish_number; i++) {
    if (n % i == 0)
        return false;
}
return true;
12.2026-09 第5题
下面函数用于判断正整数 n 是否为质数。横线处的最佳写法是( )。
bool isPrime(int n) {
    if (n < 2)
        return false;
    for (int i = 2; __________________; i++) {
        if (n % i == 0)
            return false;
    }
    return true;
}
13.2024-09 第7题
下面函数可以将n 的所有质因数找出来,其时间复杂度是( )。
#include <iostream>
#include <vector>
vector<int> get_prime_factors(int n) {
    vector<int> factors;
    while (n % 2 == 0) {
        factors.push_back(2);
        n /= 2;
    }
    for (int i = 3; i * i <= n; i += 2) {
        while (n % i == 0) {
            factors.push_back(i);
            n /= i;
        }
    }
    if (n > 2) {
        factors.push_back(n);
    }
    return factors;
}
📄 原卷原题(四个选项都是公式/代码图,按原卷呈现)
原卷题目
📄 原卷原题(四个选项都是公式/代码图,按原卷呈现)
原卷题目
14.2024-12 第5题
两块长方形土地的长宽分别为 和 米,要将它们分成正方形的小块,使得正方形的尺寸尽可能大。小杨 采用如下的辗转相除函数gcd(24, 36) 来求正方形分块的边长,则函数gcd 调用顺序为( )。
int gcd(int a, int b) {
    int big = a > b ? a : b;
    int small = a < b ? a : b;
    if (big % small == 0) {
        return small;
    }
    return gcd(small, big % small);
}
15.2024-12 第8题
下述代码实现素数表的线性筛法,筛选出所有小于等于的素数。下面说法正确的是( )。
vector<int> sieve_linear(int n) {
    vector<bool> is_prime(n +1, true);
    vector<int> primes;
    for (int i = 2; i <= n/2; i++) {
        if (is_prime[i])
            primes.push_back(i);
        for (int j = 0; j < primes.size() && i * primes[j] <= n; j++) {
            is_prime[ i * primes[j] ] = 0;
            if (i % primes[j] == 0)
                break;
        }
    }
    for (int i = n/2 +1; i <= n; i++) {
        if (is_prime[i])
            primes.push_back(i);
    }
    return primes;
}
16.2025-03 第4题
用以下辗转相除法(欧几里得算法)求gcd(84, 60)的步骤中,第二步计算的数是( )。
int gcd(int a, int b) {
    int big = a > b ? a : b;
    int small = a < b ? a : b;
    if (big % small == 0) {
        return small;
    }
    return gcd(small, big % small);
}
17.2026-03 第4题
对如下代码实现的欧几里得算法(辗转相除法),执行 gcd(48, 18) 得到的调用序列为( )。
int gcd(int a, int b) {
    return b == 0 ? a : gcd(b, a % b);
}
gcd(48,18) -> gcd(18,12) -> gcd(12,6) -> gcd(6,0)
gcd(48,18) -> gcd(30,18) -> gcd(12,18)
gcd(48,18) -> gcd(18,30) -> gcd(30,6)
gcd(48,18) -> gcd(12,18) -> gcd(6,12)
📄 题干原图(本题公式在 PDF 里不是文字,以原卷为准)
题干原图
18.2026-09 第4题
函数 gcd(int a, int b) 定义如下,则 gcd(105, 45) 的结果是( )。
int gcd(int a, int b) {
    return b == 0 ? a : gcd(b, a % b);
}
19.2026-09 第7题
根据唯一分解定理,整数 的正确质因数分解是( )。
📄 原卷原题(四个选项都是公式/代码图,按原卷呈现)
原卷题目
20.2023-12 第6题
有关下面C++代码说法正确的是( )。
📷 原卷配图(表格 / 流程图 / 代码截图,文字层无法还原)
原卷配图
参考答案(第 11–20 题)
  • 11.C 下列C++代码判断一个正整数是否是质数,说法正确的是( )。…
  • 12.D 下面函数用于判断正整数 n 是否为质数。横线处的最佳写法是( )。…
  • 13.C 下面函数可以将n 的所有质因数找出来,其时间复杂度是( )。…
  • 14.C 两块长方形土地的长宽分别为 和 米,要将它们分成正方形的小块,使得正…
  • 15.A 下述代码实现素数表的线性筛法,筛选出所有小于等于的素数。下面说法正确…
  • 16.B 用以下辗转相除法(欧几里得算法)求gcd(84, 60)的步骤中,第…
  • 17.A 对如下代码实现的欧几里得算法(辗转相除法),执行 gcd(48, 1…
  • 18.C 函数 gcd(int a, int b) 定义如下,则 gcd(10…
  • 19.A 根据唯一分解定理,整数 的正确质因数分解是( )。…
  • 20.A 有关下面C++代码说法正确的是( )。…
35级GESP 真题📌 数论基础与素数筛法第 21–30 题 · 20 分
21.2025-09 第4题
函数isPerfectNumber 判断一个正整数是否为完全数(该数是否即等于它的真因子之和),则横线上应填 写( )。一个正整数n 的真因子包括所有小于n 的正因子,如28的真因子为1, 2, 4, 7, 14。
bool isPerfectNumber(int n) {
    if(n <= 1) return false;
    int sum = 1;
    for(int i = 2; ______; i++) {
        if(n % i == 0) {
            sum += i;
            if(i != n/i) sum += n/i;
        }
    }
    return sum == n;
}
22.2024-09 第5题
下述代码实现素数表的埃拉托斯特尼筛法,筛选出所有小于等于n 的素数,则横线上应填的最佳代码是( )。
void sieve_Eratosthenes(int n) {
    vector<bool> is_prime(n + 1, true);
    vector<int> primes;
    for (int i = 2; i * i <= n; i++) {
        if (is_prime[i]) {
            primes.push_back(i);
            ________________________________ {    // 在此处填入代码
                is_prime[j] = false;
            }
        }
    }
    for (int i = sqrt(n) + 1; i <= n; i++) {
        if (is_prime[i]) {
            primes.push_back(i);
        }
    }
    return primes;
}
23.2025-03 第5题
根据唯一分解定理,下面整数的唯一分解是正确的( )。
24.2025-06 第7题
下面的代码用于判断整数是否是质数,错误的说法是( )。
bool is_prime(int n) {
    if (n <= 1) return false;
    int finish_number = static_cast<int>(sqrt(n)) + 1;
    for (int i = 2; i < finish_number; ++i) {
        if (n % i == 0)
            return false;
    }
    return true;
}
25.2025-09 第6题
函数sieve 实现埃拉托斯特尼筛法(埃氏筛),横线处应填入( )。
vector<bool> sieve(int n) {
    vector<bool> is_prime(n+1, true);
    is_prime[0] = is_prime[1] = false;
    for(int i = 2; i <= n; i++) {
        if(is_prime[i]) {
            for(int j = ______; j <= n; j += i) {
                is_prime[j] = false;
            }
        }
    }
    return is_prime;
}
26.2024-03 第5题
辗转相除法也被称为( )
27.2024-06 第7题
下述代码实现素数表的线性筛法,筛选出所有小于等于的素数,则横线上应填的代码是( )。
vector<int> linear_sieve(int n) {
    vector<bool> is_prime(n + 1, true);
    vector<int> primes;
    is_prime[0] = is_prime[1] = 0; //0和1两个数特殊处理
    for (int i = 2; i <= n; ++i) {
        if (is_prime[i]) {
            primes.push_back(i);
        }
        ________________________________ {    // 在此处填入代码
            is_prime[i * primes[j]] = 0;
            if (i % primes[j] == 0)
                break;
        }
    }
    return primes;
}
📷 原卷配图(表格 / 流程图 / 代码截图,文字层无法还原)
原卷配图
28.2024-09 第4题
有如下函数fun ,则fun(20, 12) 的返回值为( )。
int fun(int a, int b) {
    if (a % b == 0)
        return b;
    else
        return fun(b, a % b);
}
29.2024-09 第6题
下述代码实现素数表的线性筛法,筛选出所有小于等于n 的素数,则横线上应填的代码是( )。
vector<int> sieve_linear(int n) {
    vector<bool> is_prime(n + 1, true);
    vector<int> primes;
    for (int i = 2; i <= n / 2; i++) {
        if (is_prime[i])
            primes.push_back(i);
        ________________________________ {    // 在此处填入代码
            is_prime[i * primes[j]] = 0;
            if (i % primes[j] == 0)
                break;
        }
    }
    for (int i = n / 2 + 1; i <= n; i++) {
        if (is_prime[i])
            primes.push_back(i);
    }
    return primes;
}
30.2025-03 第6题
下述代码实现素数表的线性筛法,筛选出所有小于等于的素数,横线上应填的最佳代码是( )。
vector<int> sieve_linear(int n) {
    vector<bool> is_prime(n +1, true);
    vector<int> primes;
    if (n < 2) return primes;
    is_prime[0] = is_prime[1] = false;
    for (int i = 2; i <= n/2; i++) {
        if (is_prime[i])
            primes.push_back(i);
        for (int j = 0; ________________________________ ; j++) {   // 在此处填入代码
            is_prime[ i * primes[j] ] = false;
            if (i % primes[j] == 0)
                break;
        }
    }
    for (int i = n/2 +1; i <= n; i++) {
        if (is_prime[i])
            primes.push_back(i);
    }
    return primes;
}
参考答案(第 21–30 题)
  • 21.B 函数isPerfectNumber 判断一个正整数是否为完全数(该数…
  • 22.C 下述代码实现素数表的埃拉托斯特尼筛法,筛选出所有小于等于n 的素数,…
  • 23.D 根据唯一分解定理,下面整数的唯一分解是正确的( )。…
  • 24.D 下面的代码用于判断整数是否是质数,错误的说法是( )。…
  • 25.D 函数sieve 实现埃拉托斯特尼筛法(埃氏筛),横线处应填入( )。…
  • 26.C 辗转相除法也被称为( )…
  • 27.A 下述代码实现素数表的线性筛法,筛选出所有小于等于的素数,则横线上应填…
  • 28.C 有如下函数fun ,则fun(20, 12) 的返回值为( )。…
  • 29.A 下述代码实现素数表的线性筛法,筛选出所有小于等于n 的素数,则横线上…
  • 30.C 下述代码实现素数表的线性筛法,筛选出所有小于等于的素数,横线上应填的…
45级GESP 真题📌 数论基础与素数筛法第 31–39 题 · 18 分
31.2025-09 第7题
函数linearSieve实现线性筛法(欧拉筛),横线处应填入()。
vector<int> linearSieve(int n) {
    vector<bool> is_prime(n+1, true);
    vector<int> primes;
    for(int i = 2; i <= n; i++) {
        if(is_prime[i]) primes.push_back(i);
        for(int p : primes) {
            if(p * i > n) break;
            is_prime[p * i] = false;
            if(________) break;
        }
    }
    return primes;
}
32.2026-03 第5题
下面代码实现了欧拉(线性)筛,横线处应填写( )。 第 2 页 / 共 14 页
vector<int> euler_sieve(int n) {
    vector<bool> is_composite(n + 1, false); 
    vector<int>  primes;                     
    for (int i = 2; i <= n; i++) {
        if (!is_composite[i])
            primes.push_back(i);
        for (int j = 0; __________________________ && (long long)i * primes[j] <= n; j++) {
            is_composite[i * primes[j]] = true;
            if (i % primes[j] == 0)
                break;
        }
    }
    return primes;
}
j <= n
j < sqrt(n)
j < primes.size()
j < i
33.2024-06 第6题
欧几里得算法还可以写成如下形式: 下面有关说法,错误的是( )。
int gcd(int a, int b) {
    return b == 0 ? a : gcd(b, a % b);
}
34.2025-06 第6题
下列C++代码用两种方式求解两个正整数的最大公约数,说法错误的是( )。
int gcd0(int big, int small) {
    if (big < small) {
        swap(big, small);
    }
    if (big % small == 0) {
        return small;
    }
    return gcd0(small, big % small);
}
int gcd1(int big, int small) {
    if (big < small) {
        swap(big, small);
    }
    for (int i = small; i >= 1; --i) {
        if (big % i == 0 && small % i == 0)
            return i;
    }
    return 1;
}
35.2024-03 第10题
在埃拉托斯特尼筛法中,要筛选出不大于 n 的所有素数,最外层循环应该遍历什么范围( )?
vector<int> sieveOfEratosthenes(int n) {
    std::vector<bool> isPrime(n + 1, true);
    std::vector<int> primes;
    _______________________ {
        if (isPrime[i]) {
            primes.push_back(i);
            for (int j = i * i; j <= n; j += i) {
                isPrime[j] = false;
            }
        }
    }
    for (int i = sqrt(n) + 1; i <= n; ++i) {
        if (isPrime[i]) {
            primes.push_back(i);
        }
    }
    return primes;
}
36.2023-09 第2题
如果a 和b 均为int 类型的变量,且b 的值不为0 ,那么下列能正确判断“ a 是b 的3倍”的表达式是( )。
37.2023-09 第11题
下面代码中的isPrimeA() 和isPrimeB() 都用于判断参数N 是否素数,有关其时间复杂度的正确说法是 ( )。
📷 原卷配图(表格 / 流程图 / 代码截图,文字层无法还原)
原卷配图
38.2023-12 第8题
下面C++代码中的 isPrimeA() 和 isPrimeB() 都用于判断参数N是否素数,有关其时间复杂度的正确说 法是( )。
isPrimeB( )
isPrimeB( )
📷 原卷配图(表格 / 流程图 / 代码截图,文字层无法还原)
原卷配图
39.2024-03 第11题
素数的线性筛法时间复杂度为( )。
📄 原卷原题(四个选项都是公式/代码图,按原卷呈现)
原卷题目
📄 原卷原题(四个选项都是公式/代码图,按原卷呈现)
原卷题目
参考答案(第 31–39 题)
  • 31.A 函数linearSieve实现线性筛法(欧拉筛),横线处应填入()。…
  • 32.C 下面代码实现了欧拉(线性)筛,横线处应填写( )。 第 2 页 / …
  • 33.D 欧几里得算法还可以写成如下形式: 下面有关说法,错误的是( )。…
  • 34.D 下列C++代码用两种方式求解两个正整数的最大公约数,说法错误的是( …
  • 35.C 在埃拉托斯特尼筛法中,要筛选出不大于 n 的所有素数,最外层循环应该…
  • 36.D 如果a 和b 均为int 类型的变量,且b 的值不为0 ,那么下列能…
  • 37.B 下面代码中的isPrimeA() 和isPrimeB() 都用于判断…
  • 38.B 下面C++代码中的 isPrimeA() 和 isPrimeB() …
  • 39.A 素数的线性筛法时间复杂度为( )。…
④今日打卡 · 点一下就能勾选
☑ 已勾选 0 / 7 项点一下条目即可勾选
五级 · 理论 DAY 02

递归与分治

📌 考点 递归三要素 / 递归调用栈 / 斐波那契与递推✍️ 客观题 16⏱ 建议用时 45 分钟🎯 难度 ★★★★☆
①今日考情 · 真题分布与备考建议

本考点在 GESP C++ 5级近 14 期真题中共 16 道客观题(单选 16 / 判断 0,其中 5 道需看原卷配图)。本页把这一考点的真题全部收进来了,一道没漏,按每 10 题一张卡分组,可分次完成。

本期分布

期次题数
2023-094
2023-122
2024-031
2024-062
2024-091
2024-121
2025-031
2025-061
2025-091
2026-031
2026-091

配套教材

GESP 大通关 5 级(全书 76 页):本天对应 5.2 素数表的埃氏筛与线性筛。教材按同一套大纲顺序编排,可对照阅读。

备考建议(出题人视角)

五级的递归不只考「看懂」,还考「算出来」:给一个递归函数,求 f(5) 的值。这类题必须**手画调用树**,一层层往回代。分治则集中在快排和归并上——它们的划分过程本身就是阅读程序题的常客。记住一条铁律:**没有出口的递归一定栈溢出**,这条几乎每年都出现。

②知识地图 · 本考点思维导图
递归与分治
  • 递归三要素
    • ① 递归关系:f(n) 用 f(n-1) 或 f(n/2) 表示
    • ② 出口条件:n 到什么值就直接返回
    • ③ 收敛性:每次调用都要更靠近出口
  • 递归的执行过程
    • 调用时压栈,返回时出栈
    • 栈深度 = 递归层数
    • 层数过多 → 栈溢出(stack overflow)
  • 经典递归模型
    • 阶乘 f(n) = n × f(n-1),f(1)=1
    • 斐波那契 f(n) = f(n-1) + f(n-2)
    • 求和 f(n) = n + f(n-1)
    • 汉诺塔 h(n) = 2h(n-1) + 1,h(1)=1 → 2ⁿ−1
  • 递归的复杂度
    • 单分支递归(阶乘)O(n)
    • 双分支朴素递归(斐波那契)O(2ⁿ) ← 大量重复
    • 记忆化后降为 O(n)
  • 分治
    • 三步:分解 → 解决 → 合并
    • 归并排序:对半切 → 各自排 → 合并
    • 快速排序:选基准 → 划分 → 各自排
③核心精讲

1. 递归三要素

任何递归函数都必须同时具备:

  1. 递归关系:f(n) 怎么用更小的 f(n-1)、f(n/2) 表示;
  2. 出口条件:n 到什么值就直接给答案,不再递归;
  3. 收敛性:每次调用必须更靠近出口,否则无限递归。
int f(int n) {
    if (n == 1) return 1;        // ← 出口
    return n + f(n - 1);         // ← 递归关系
}
// f(4) = 4 + f(3) = 4 + 3 + f(2) = 4 + 3 + 2 + f(1) = 4+3+2+1 = 10

2. 手推调用树(阅读程序必用)

求 f(4),别在脑子里转,画出来:

f(4)
└─ 4 + f(3)
        └─ 3 + f(2)
                └─ 2 + f(1)
                        └─ 1  ← 出口

从下往上代:f(1)=1 → f(2)=2+1=3 → f(3)=3+3=6 → f(4)=4+6=10。

考试技巧:递归题先写一张「n → 返回值」的表,从出口那端开始填, 千万不要从上往下猜。

3. 汉诺塔:递归的经典模型

void hanoi(int n, char a, char b, char c) {   // a → c,b 作中转
    if (n == 0) return;
    hanoi(n - 1, a, c, b);        // 先把上面 n-1 个挪到 b
    cout << a << "->" << c << "\n";   // 最大的那个挪到 c
    hanoi(n - 1, b, a, c);        // 再把 n-1 个从 b 挪到 c
}

移动次数 h(n) = 2h(n-1) + 1,h(1)=1,解出 h(n) = 2ⁿ − 1。 n = 10 时要 1023 次,n = 64 时是 18446744073709551615 次。

4. 递归的复杂度:为什么斐波那契递归慢

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

fib(5) 会把 fib(3) 算两次、fib(2) 算三次。调用次数近似 2ⁿ, 所以朴素递归求斐波那契是 O(2ⁿ)。

加一个记忆化数组:

long long memo[100];
long long fib(int n) {
    if (n <= 2) return 1;
    if (memo[n]) return memo[n];          // 算过就直接拿
    return memo[n] = fib(n - 1) + fib(n - 2);
}

每个 n 只算一次 → O(n)。这一对比是六级动态规划的引子。

5. 分治:三步走

分解(divide)→ 解决(conquer)→ 合并(combine)

归并排序就是标准分治:

void mergeSort(int l, int r) {
    if (l >= r) return;                  // 出口:只剩一个元素
    int mid = (l + r) / 2;
    mergeSort(l, mid);                   // 左边排好
    mergeSort(mid + 1, r);               // 右边排好
    merge(l, mid, r);                    // 合并两个有序段
}

快速排序也是分治,但「分解」靠的是选基准划分:

void quickSort(int l, int r) {
    if (l >= r) return;
    int p = partition(l, r);             // 基准归位,左边都 ≤ 它、右边都 ≥ 它
    quickSort(l, p - 1);
    quickSort(p + 1, r);
}
算法平均最坏空间稳定
归并排序O(n log n)O(n log n)O(n)稳定
快速排序O(n log n)O(n²)O(log n)不稳定

快排最坏的情况:每次选的基准都是当前区间的最大或最小值,划分彻底失衡, 递归深度变成 n,时间退化成 O(n²)。

✍️ 真题演练 · 共 16 题,点选项即时判分
55级GESP 真题📌 递归与分治第 1–10 题 · 20 分
1.2023-09 第6题
印度古老的汉诺塔传说:创世时有三根金刚柱,其中一柱从下往上按照大小顺序摞着64片黄金圆盘,当圆盘 逐一从一柱借助另外一柱全部移动到另外一柱时,宇宙毁灭。移动规则:在小圆盘上不能放大圆盘,在三根柱子之 间一次只能移动一个圆盘。下面的C++代码以递归方式实现汉诺塔,横线处应填入代码是( )。
📷 原卷配图(表格 / 流程图 / 代码截图,文字层无法还原)
原卷配图
2.2026-03 第9题
关于递归函数调用,下列说法错误的是( )。
3.2025-06 第9题
下面的C++代码,用于求一系列数据中的最大值。有关其算法说法错误的是( )。
int find_max_recursive(const vector<int>& nums, int left, int right) {
    if (left == right)
        return nums[left];
    int mid = left + (right - left) / 2;
    int left_max = find_max_recursive(nums, left, mid);
    int right_max = find_max_recursive(nums, mid + 1, right);
    return max(left_max, right_max);
}
int find_max(const vector<int>& nums) {
    if (nums.empty()) {
        throw invalid_argument("输入数组不能为空");
    }
    return find_max_recursive(nums, 0, nums.size() - 1);
}
4.2024-03 第14题
递归函数在调用自身时,必须满足( ),以避免无限递归?
5.2024-12 第4题
对下面两个函数,说法错误的是( )。
int fibA(int n) {
    if (n <= 1) return n;
    int f1 = 0, f2 = 1;
    for (int i = 2; i <= n; ++i) {
        int temp = f2;
        f2 = f1 + f2;
        f1 = temp;
    }
    return f2;
}
int fibB(int n) {
    if (n <= 1) return n;
    return fibB(n - 1) + fibB(n - 2);
}
6.2024-06 第1题
下面C++代码用于求斐波那契数列,该数列第1、2项为1,以后各项均是前两项之和。函数fibo()属于( )。
int fibo(int n) {
    if (n <= 0)
        return 0;
    if (n == 1 || n == 2)
        return 1;
    int a = 1,b = 1, next;
    for (int i = 3; i <= n; i++) {
        next = a + b;
        a = b;
        b = next;
    }
    return next;
}
7.2023-12 第1题
下面C++代码用于求斐波那契数列,该数列第1、2项为1,以后各项均是前两项之和。下面有关说法错误的 是( )。
📷 原卷配图(表格 / 流程图 / 代码截图,文字层无法还原)
原卷配图
8.2026-09 第8题
函数 f(int n) 定义如下,则 f(4) 的结果是( )。
int f(int n) {
    if (n == 1)
        return 1;
    return n + f(n - 1);
}
9.2023-12 第9题
下面C++代码用于有序list 的二分查找,有关说法错误的是( )。
📷 原卷配图(表格 / 流程图 / 代码截图,文字层无法还原)
原卷配图
10.2023-09 第4题
有关下面C++代码说法错误的是( )。
📷 原卷配图(表格 / 流程图 / 代码截图,文字层无法还原)
原卷配图
参考答案(第 1–10 题)
  • 1.B 印度古老的汉诺塔传说:创世时有三根金刚柱,其中一柱从下往上按照大小顺…
  • 2.D 关于递归函数调用,下列说法错误的是( )。…
  • 3.C 下面的C++代码,用于求一系列数据中的最大值。有关其算法说法错误的是…
  • 4.A 递归函数在调用自身时,必须满足( ),以避免无限递归?…
  • 5.D 对下面两个函数,说法错误的是( )。…
  • 6.C 下面C++代码用于求斐波那契数列,该数列第1、2项为1,以后各项均是…
  • 7.C 下面C++代码用于求斐波那契数列,该数列第1、2项为1,以后各项均是…
  • 8.D 函数 f(int n) 定义如下,则 f(4) 的结果是( )。…
  • 9.D 下面C++代码用于有序list 的二分查找,有关说法错误的是( )。…
  • 10.C 有关下面C++代码说法错误的是( )。…
65级GESP 真题📌 递归与分治第 11–16 题 · 12 分
11.2024-06 第2题
下面C++代码用于将输入金额换成最少币种组合方案,其实现算法是( )。
#include <iostream>
using namespace std;
#define N_COINS 7
int coins[N_COINS] = {100, 50, 20, 10, 5, 2, 1}; //货币面值,单位相同
int coins_used[N_COINS];
void find_coins(int money) {
    for (int i = 0; i < N_COINS; i++) {
        coins_used[i] = money / coins[i];
        money = money % coins[i];
    }
    return;
}
int main() {
    int money;
    cin >> money;   //输入要换算的金额
    find_coins(money);
    for (int i = 0; i < N_COINS; i++)
        cout << coins_used[i] << endl;
    return 0;
}
12.2024-09 第3题
对下面两个函数,说法错误的是( )。
int sumA(int n) {
    int res = 0;
    for (int i = 1; i <= n; i++) {
        res += i;
    }
    return res;
}
int sumB(int n) {
    if (n == 1)
        return 1;
    int res = n + sumB(n - 1);
    return res;
}
13.2025-03 第8题
对下面两个函数,说法错误的是( )。
int factorialA(int n) {
    if (n <= 1) return 1;
    return n * factorialA(n-1);
}
int factorialB(int n) {
    if (n <= 1) return 1;
    int res = 1;
    for(int i=2; i<=n; i++)
res *= i;
}
14.2023-09 第5题
下面C++代码以递归方式实现字符串反序,横线处应填上代码是( )。
📷 原卷配图(表格 / 流程图 / 代码截图,文字层无法还原)
原卷配图
15.2023-09 第13题
在上题的归并排序算法中,mergeSort(listData, start, middle); 和mergeSort(listData, middle + 1, end); 涉及到的算法为( )。
📄 题干原图(本题公式在 PDF 里不是文字,以原卷为准)
题干原图
16.2025-09 第14题
给定一个整数数组nums ,下面代码找到一个具有最大和的连续子数组,并返回该最大和。则下面说法错 误的是( )。
int crossSum(vector<int>& nums, int left, int mid, int right) {
    int leftSum = INT_MIN, rightSum = INT_MIN;
    int sum = 0;
    for (int i = mid; i >= left; i--) {
        sum += nums[i];
        leftSum = max(leftSum, sum);
    }
    sum = 0;
    for (int i = mid + 1; i <= right; i++) {
        sum += nums[i];
        rightSum = max(rightSum, sum);
    }
    return leftSum + rightSum;
}
int helper(vector<int>& nums, int left, int right) {
    if (left == right)
        return nums[left];
    int mid = left + (right - left) / 2;
    int leftMax = helper(nums, left, mid);
    int rightMax = helper(nums, mid + 1, right);
    int crossMax = crossSum(nums, left, mid, right);
    return max({leftMax, rightMax, crossMax});
}
int maxSubArray(vector<int>& nums) {
    return helper(nums, 0, nums.size() - 1);
}
📄 题干原图(本题公式在 PDF 里不是文字,以原卷为准)
题干原图
参考答案(第 11–16 题)
  • 11.B 下面C++代码用于将输入金额换成最少币种组合方案,其实现算法是( )…
  • 12.C 对下面两个函数,说法错误的是( )。…
  • 13.D 对下面两个函数,说法错误的是( )。…
  • 14.A 下面C++代码以递归方式实现字符串反序,横线处应填上代码是( )。…
  • 15.B 在上题的归并排序算法中,mergeSort(listData, st…
  • 16.B 给定一个整数数组nums ,下面代码找到一个具有最大和的连续子数组,…
④今日打卡 · 点一下就能勾选
☑ 已勾选 0 / 7 项点一下条目即可勾选
五级 · 理论 DAY 03

排序算法与稳定性

📌 考点 冒泡排序 / 选择排序 / 插入排序✍️ 客观题 29⏱ 建议用时 45 分钟🎯 难度 ★★★★☆
①今日考情 · 真题分布与备考建议

本考点在 GESP C++ 5级近 14 期真题中共 29 道客观题(单选 29 / 判断 0,其中 7 道需看原卷配图)。本页把这一考点的真题全部收进来了,一道没漏,按每 10 题一张卡分组,可分次完成。

本期分布

期次题数
2023-092
2023-123
2024-033
2024-063
2024-093
2024-123
2025-033
2025-062
2025-092
2026-032
2026-093

配套教材

GESP 大通关 5 级(全书 76 页):本天对应 5.3 唯一分解定理与高精度。教材按同一套大纲顺序编排,可对照阅读。

备考建议(出题人视角)

五级把排序从「会用 sort」升级成「知道每个排序内部怎么跑」。真题最常见的两种问法:**给出中间某一轮的结果,问是哪个排序**、**问某个排序的稳定性或最坏复杂度**。把冒泡、选择、插入、快排、归并、堆排六个的「一轮之后数组长什么样」都亲手推一遍,这类题就再也不会错。

②知识地图 · 本考点思维导图
排序算法与稳定性
  • 基础三兄弟 O(n²)
    • 冒泡排序
      • 相邻两两比较,大的往后浮
      • 稳定;每轮至少定一个最大值
    • 选择排序
      • 每轮找最小值放到前面
      • 不稳定(交换会打乱相等元素)
    • 插入排序
    • 把当前元素插到前面已排好的位置
    • 稳定;近乎有序时很快
  • 高级排序 O(n log n)
    • 快速排序
      • 选基准 partition,平均 O(n log n)、最坏 O(n²)
      • 不稳定;空间 O(log n)
    • 归并排序
      • 对半切 + 合并两个有序段
      • 稳定;空间 O(n)
    • 堆排序
    • 建大根堆,反复取堆顶
    • 不稳定;空间 O(1)
  • 稳定性判定口诀
    • 「快选堆」不稳定,其余都稳定
  • 复杂度速记
    • 最好/最坏/平均三者一致的:选择、归并、堆
    • 最坏会退化的:冒泡(已排好则 O(n))、快排(O(n²))
③核心精讲

1. 六个排序一轮之后长什么样

以数组 [5, 3, 8, 1, 9, 2] 为例,第一轮之后:

排序第一轮结果说明
冒泡[3, 5, 1, 8, 2, 9]9 浮到最右
选择[1, 3, 8, 5, 9, 2]最小值 1 换到最左
插入[3, 5, 8, 1, 9, 2]前两个有序;8 不用动
快排(基准 5)[2, 3, 1, 5, 9, 8]5 归位,左边都 ≤5、右边都 ≥5
归并[3, 5, 1, 8, 2, 9]两两合并成有序段

阅读程序题经常给「某一轮的中间状态」,让你反推是哪个算法。 关键特征:每轮末尾确定一个最大值 → 冒泡;每轮开头确定一个最小值 → 选择; 前面一段始终有序 → 插入。

2. 稳定性:相等元素会不会被换顺序

排序稳定反例 / 原因
冒泡✅只在 > 时交换,相等不动
插入✅相等元素不越过彼此
归并✅合并时相等优先取左边
选择❌[2a, 2b, 1] 交换 1 和 2a 后,2a 跑到 2b 后面
快速排序❌partition 时相等元素被交换到别处
堆排序❌建堆与取顶的过程会打乱相等元素

口诀:快、选、堆不稳定,其余稳定。

3. 快速排序的 partition

int partition(int a[], int low, int high) {
    int pivot = a[low];                 // 以首元素为基准
    int i = low, j = high;
    while (i < j) {
        while (i < j && a[j] >= pivot) j--;   // 从右往左找比基准小的
        while (i < j && a[i] <= pivot) i++;   // 从左往右找比基准大的
        if (i < j) swap(a[i], a[j]);
    }
    swap(a[i], a[low]);                 // 基准归位
    return i;                           // 返回基准最终位置
}

两个 while 的顺序不能交换(先右后左)。如果先左后右, 在某些输入下 i 会停在比基准大的位置,最后 swap(a[i], a[low]) 会把一个更大的数换到最前面, 划分就错了。这个细节是五级阅读程序的高频陷阱。

4. 归并的 merge

void merge(int l, int mid, int r) {
    int i = l, j = mid + 1, k = 0;
    while (i <= mid && j <= r) {
        if (a[i] <= a[j]) tmp[k++] = a[i++];      // ≤ 保证稳定
        else              tmp[k++] = a[j++];
    }
    while (i <= mid) tmp[k++] = a[i++];
    while (j <= r)   tmp[k++] = a[j++];
    for (int t = 0; t < k; t++) a[l + t] = tmp[t];
}

a[i] <= a[j] 里的 <= 是稳定性的关键:相等时优先取左边。

5. 复杂度速记表

排序最好平均最坏空间稳定
冒泡O(n)O(n²)O(n²)O(1)✅
选择O(n²)O(n²)O(n²)O(1)❌
插入O(n)O(n²)O(n²)O(1)✅
快排O(n log n)O(n log n)O(n²)O(log n)❌
归并O(n log n)O(n log n)O(n log n)O(n)✅
堆排O(n log n)O(n log n)O(n log n)O(1)❌
✍️ 真题演练 · 共 29 题,点选项即时判分
75级GESP 真题📌 排序算法与稳定性第 1–10 题 · 20 分
1.2023-12 第15题
下面的排序算法都要处理多趟数据,哪种排序算法不能保证在下一趟处理时从待处理数据中选出最大或最 小的数据?( )
📷 原卷配图(表格 / 流程图 / 代码截图,文字层无法还原)
原卷配图
2.2026-03 第14题
下面关于排序算法的描述中,不正确的是( )。
3.2024-12 第14题
关于分治算法,以下说法中不正确的是( )。
4.2025-03 第9题
下算法中,( )是不稳定的排序。
5.2023-09 第12题
下面代码用于归并排序,其中merge() 函数被调用次数为( )。
📷 原卷配图(表格 / 流程图 / 代码截图,文字层无法还原)
原卷配图
6.2023-12 第7题
下面的C++代码实现对list的快速排序,有关说法,错误的是( )。
📷 原卷配图(表格 / 流程图 / 代码截图,文字层无法还原)
原卷配图
7.2024-03 第13题
在快速排序中,选择的主元素(pivot)会影响算法的( )。
8.2024-06 第10题
关于分治算法,以下哪个说法正确?
9.2024-06 第13题
设和是两个长度为的有序数组,现将和合并成一个有序数组,归并排序算法在最坏情况下至少要做 ( )次比较。
📄 原卷原题(四个选项都是公式/代码图,按原卷呈现)
原卷题目
10.2024-09 第9题
假设快速排序算法的输入是一个长度为的已排序数组,且该快速排序算法在分治过程总是选择第一个元素 作为基准元素。下面选项( )描述的是在这种情况下的快速排序行为。
📄 题干原图(本题公式在 PDF 里不是文字,以原卷为准)
题干原图
参考答案(第 1–10 题)
  • 1.B 下面的排序算法都要处理多趟数据,哪种排序算法不能保证在下一趟处理时从…
  • 2.B 下面关于排序算法的描述中,不正确的是( )。…
  • 3.D 关于分治算法,以下说法中不正确的是( )。…
  • 4.A 下算法中,( )是不稳定的排序。…
  • 5.C 下面代码用于归并排序,其中merge() 函数被调用次数为( )。…
  • 6.C 下面的C++代码实现对list的快速排序,有关说法,错误的是( )。…
  • 7.B 在快速排序中,选择的主元素(pivot)会影响算法的( )。…
  • 8.A 关于分治算法,以下哪个说法正确?…
  • 9.C 设和是两个长度为的有序数组,现将和合并成一个有序数组,归并排序算法在…
  • 10.C 假设快速排序算法的输入是一个长度为的已排序数组,且该快速排序算法在分…
85级GESP 真题📌 排序算法与稳定性第 11–20 题 · 20 分
11.2024-09 第12题
关于分治算法,以下哪个说法正确?
12.2024-12 第10题
下面关于归并排序,描述正确的是( )。
13.2023-09 第14题
归并排序算法的基本思想是( )。
14.2024-03 第12题
归并排序的基本思想是( )。
15.2026-09 第12题
下面快速排序的划分函数以 a[right] 为枢轴,并把不大于枢轴的元素移动到左侧。横线处应填写 ( )。
int partition(int a[], int left, int right) {
    int pivot = a[right];
    int i = left - 1;
    for (int j = left; j < right; j++) {
        if (__________________) {
            i++;
            swap(a[i], a[j]);
        }
    }
    swap(a[i + 1], a[right]);
    return i + 1;
}
16.2023-12 第2题
下面C++代码以递归方式实现合并排序,并假设merge (int T[], int R[], int s, int m, int t) 函 数将有序(同样排序规则)的T[s..m]和T[m+1..t]归并到R[s..t]中。横线处应填上代码是( )。
📷 原卷配图(表格 / 流程图 / 代码截图,文字层无法还原)
原卷配图
17.2024-06 第9题
为了正确实现快速排序,下面横线上的代码应为( )。
void qsort(vector<int>& arr, int left, int right) {
    int i, j, mid;
    int pivot;
    i = left;
    j = right;
    mid = (left + right) / 2; // 计算中间元素的索引
    pivot = arr[mid]; // 选择中间元素作为基准值
    do {
        while (arr[i] < pivot) i++;
        while (arr[j] > pivot) j--;
        if (i <= j) {
            swap(arr[i], arr[j]); // 交换两个元素
            i++; j--;
        }
    } ________________________________; // 在此处填入代码
    if (left < j) qsort(arr, left, j);   // 对左子数组进行快速排序
    if (i < right) qsort(arr, i, right); // 对右子数组进行快速排序
}
18.2024-09 第10题
考虑以下C++代码实现的归并排序算法: 对长度为n 的数组arr ,挑用函数merge_sort(a, 0, n-1) ,在排序过程中merge 函数的递归调用次数大约是 ( )。
void merge(int arr[], int left, int mid, int right) {
    int n1 = mid - left + 1;
    int n2 = right - mid;
    int L[n1], R[n2];
    for (int i = 0; i < n1; i++)
        L[i] = arr[left + i];
    for (int j = 0; j < n2; j++)
        R[j] = arr[mid + 1 + j];
    int i = 0, j = 0, k = left;
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            i++;
        }
        else {
            arr[k] = R[j];
            j++;
        }
        k++;
    }
    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }
    while (j < n2) {
        arr[k] = R[j];
        j++;
        k++;
    }
}
void merge_sort(int arr[], int left, int right) {
    if (left < right) {
        int mid = left + (right - left) / 2;
        merge_sort(arr, left, mid);
        merge_sort(arr, mid + 1, right);
        merge(arr, left, mid, right);
    }
}
📄 原卷原题(四个选项都是公式/代码图,按原卷呈现)
原卷题目
📄 原卷原题(四个选项都是公式/代码图,按原卷呈现)
原卷题目
19.2025-03 第10题
考虑以下C++代码实现的快速排序算法,将数据从小到大排序,则横线上应填的最佳代码是( )。
int partition(vector<int>& arr, int low, int high) {
    int pivot = arr[high]; // 基准值
    int i = low - 1;
    for (int j = low; j < high; j++) {
        ________________________________       // 在此处填入代码
    }
    swap(arr[i + 1], arr[high]);
    return i + 1;
}
// 快速排序
void quickSort(vector<int>& arr, int low, int high) {
    if (low < high) {
        int pi = partition(arr, low, high);
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}
if (arr[j] > pivot) {
    i++;
    swap(arr[i], arr[j]);
}
if (arr[j] < pivot) {
    i++;
    swap(arr[i], arr[j]);
}
if (arr[j] < pivot) {
    swap(arr[i], arr[j]);
    i++;
}
if (arr[j] == pivot) {
    i++;
    swap(arr[i], arr[j]);
}
20.2025-09 第12题
下述C++代码实现了归并排序算法,则横线上应填写( )。
void merge(vector<int> &nums, int left, int mid, int right) {
    // 左子数组区间为 [left, mid], 右子数组区间为 [mid+1, right]
    vector<int> tmp(right - left + 1);
    int i = left, j = mid + 1, k = 0;
    while (i <= mid && j <= right) {
        if (nums[i] <= nums[j])
            tmp[k++] = nums[i++];
        else
            tmp[k++] = nums[j++];
    }
    while (i <= mid) {
        tmp[k++] = nums[i++];
    }
    while (________) {    // 在此处填入代码
        tmp[k++] = nums[j++];
    }
    for (k = 0; k < tmp.size(); k++) {
        nums[left + k] = tmp[k];
    }
}
void mergeSort(vector<int> &nums, int left, int right) {
    if (left >= right)
        return;
    int mid = (left + right) / 2;
    mergeSort(nums, left, mid);
    mergeSort(nums, mid + 1, right);
    merge(nums, left, mid, right);
}
参考答案(第 11–20 题)
  • 11.A 关于分治算法,以下哪个说法正确?…
  • 12.B 下面关于归并排序,描述正确的是( )。…
  • 13.A 归并排序算法的基本思想是( )。…
  • 14.B 归并排序的基本思想是( )。…
  • 15.A 下面快速排序的划分函数以 a[right] 为枢轴,并把不大于枢轴的…
  • 16.C 下面C++代码以递归方式实现合并排序,并假设merge (int T…
  • 17.D 为了正确实现快速排序,下面横线上的代码应为( )。…
  • 18.B 考虑以下C++代码实现的归并排序算法: 对长度为n 的数组arr ,…
  • 19.B 考虑以下C++代码实现的快速排序算法,将数据从小到大排序,则横线上应…
  • 20.D 下述C++代码实现了归并排序算法,则横线上应填写( )。…
95级GESP 真题📌 排序算法与稳定性第 21–29 题 · 18 分
21.2026-09 第13题
小杨要在一个教室安排尽可能多场活动,每场活动具有开始时间 start 和结束时间 end 。采用贪心算法 时,正确的选择策略是( )。
struct Activity {
    int start;
    int end;
};
22.2024-03 第2题
贪心算法的核心思想是( )?
23.2025-03 第13题
贪心算法的核心特征是( )。
24.2024-12 第9题
考虑以下C++代码实现的快速排序算法: 以下关于快速排序的说法,正确的是( )。
int partition(vector<int>& arr, int left, int right) {
    int pivot = arr[right]; // 基准值
    int i = left - 1;
    for (int j = left; j < right; j++) {
        if (arr[j] < pivot) {
            i++;
            swap(arr[i], arr[j]);
        }
    }
    swap(arr[i + 1], arr[right]);
    return i + 1;
}
// 快速排序
void quickSort(vector<int>& arr, int left, int right) {
    if (left < right) {
        int pi = partition(arr, left, right);
        quickSort(arr, left, pi - 1);
        quickSort(arr, pi + 1, right);
    }
}
25.2025-06 第14题
关于下述C++代码的快速排序算法,说法错误的是( )。
int randomPartition(std::vector<int>& arr, int low, int high) {
    int random = low + rand() % (high - low + 1);
    std::swap(arr[random], arr[high]);
    int pivot = arr[high];
    int i = low - 1;
    for (int j = low; j < high; j++) {
        if (arr[j] <= pivot) {
            i++;
            std::swap(arr[i], arr[j]);
        }
    }
    std::swap(arr[i + 1], arr[high]);
    return i + 1;
}
void quickSort(std::vector<int>& arr, int low, int high) {
    if (low < high) {
        int pi = randomPartition(arr, low, high);
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}
26.2025-09 第11题
下述C++代码实现了快速排序算法,下面说法错误的是( )。
int partition(vector<int>& arr, int low, int high) {
    int i = low, j = high;
    int pivot = arr[low];                 // 以首元素为基准
    while (i < j) {
        while (i < j && arr[j] >= pivot) j--;   //从右往左查找
        while (i < j && arr[i] <= pivot) i++;   //从左往右查找
        if (i < j) swap(arr[i], arr[j]);
    }
    swap(arr[i], arr[low]);               
    return i;                             
}
void quickSort(vector<int>& arr, int low, int high) {
    if (low >= high) return;
    int p = partition(arr, low, high);
    quickSort(arr, low, p - 1);
    quickSort(arr, p + 1, high);
}
27.2026-03 第13题
有 位同学的成绩已经从小到大排好序,现在对它执行下面这段以第一个元素为 pivot 的快速排序,请 问此次排序的时间复杂度是( )。
void quicksort(vector<int>& a, int l, int r) {
    if (l >= r) return;
    int pivot = a[l];        
    int i = l, j = r;
    while (i < j) {
        while (i < j && a[j] >= pivot) j--;
        while (i < j && a[i] <= pivot) i++;
        if (i < j) swap(a[i], a[j]);
    }
    swap(a[l], a[i]);
    quicksort(a, l, i - 1);
    quicksort(a, i + 1, r);
}
📄 原卷原题(四个选项都是公式/代码图,按原卷呈现)
原卷题目
28.2025-06 第13题
13.硬币找零问题中要求找给客户最少的硬币。coins 存储可用硬币规格,单位为角,假设规格都小于10 角,且一定有1角规格。amount 为要找零的金额,约定必须为1角的整数倍。输出为每种规格及其数量,按规格从大 到小输出,如果某种规格不必要,则输出为0。下面是其实现代码,相关说法正确的是( )。
const int MAX_COINS = 10;
int result[MAX_COINS] = {0};  // 假设最多10种面额
int find_coins(const vector<int>& coins, int amount) {
    sort(coins.begin(), coins.end(), greater<int>());
    int n = coins.size();
    for (int i = 0; i < n; ++i) {
        int coin = coins[i];
        int num = amount / coin;
        result[i] = num;
        amount -= num * coin;
        if (amount == 0) break;
    }
    cout << "找零方案如下:" << endl;
    for (int i = 0; i < n; ++i) {
        cout << sorted_coins[i] << "角需要" << result[i] << "枚" << endl;
    }
    return 0;
}
29.2026-09 第11题
下面是归并排序中合并两个有序区间(升序排序)的部分代码。若希望排序保持稳定,横线处应填写 ( )。
while (i <= mid && j <= right) {
    if (__________________) {
        temp.push_back(a[i++]);
    } else {
        temp.push_back(a[j++]);
    }
}
参考答案(第 21–29 题)
  • 21.D 小杨要在一个教室安排尽可能多场活动,每场活动具有开始时间 start…
  • 22.A 贪心算法的核心思想是( )?…
  • 23.A 贪心算法的核心特征是( )。…
  • 24.A 考虑以下C++代码实现的快速排序算法: 以下关于快速排序的说法,正确…
  • 25.D 关于下述C++代码的快速排序算法,说法错误的是( )。…
  • 26.D 下述C++代码实现了快速排序算法,下面说法错误的是( )。…
  • 27.C 有 位同学的成绩已经从小到大排好序,现在对它执行下面这段以第一个元素…
  • 28.A 13.硬币找零问题中要求找给客户最少的硬币。coins 存储可用硬币…
  • 29.D 下面是归并排序中合并两个有序区间(升序排序)的部分代码。若希望排序保…
④今日打卡 · 点一下就能勾选
☑ 已勾选 0 / 7 项点一下条目即可勾选
五级 · 理论 DAY 04

链表:单链表与双向链表

📌 考点 结点结构 / 头指针与头结点 / 表头/表尾插入删除✍️ 客观题 27⏱ 建议用时 45 分钟🎯 难度 ★★★★☆
①今日考情 · 真题分布与备考建议

本考点在 GESP C++ 5级近 14 期真题中共 27 道客观题(单选 27 / 判断 0,其中 5 道需看原卷配图)。本页把这一考点的真题全部收进来了,一道没漏,按每 10 题一张卡分组,可分次完成。

本期分布

期次题数
2023-091
2023-122
2024-032
2024-062
2024-092
2024-122
2025-034
2025-063
2025-093
2026-033
2026-093

配套教材

GESP 大通关 5 级(全书 76 页):本天对应 5.4 单链表、双链表与循环链表。教材按同一套大纲顺序编排,可对照阅读。

备考建议(出题人视角)

链表是五级最有「数据结构味」的一块,也是真题里图文并茂的部分。所有题都围绕一件事:**改指针的顺序**。记住两条:单链表只能单向走(找前驱要 O(n))、已知结点指针时插入删除是 O(1)。带哨兵(dummy)结点的写法能统一处理头结点,是真题里的高频模板。

②知识地图 · 本考点思维导图
链表:单链表与双向链表
  • 结点的结构
    • 数据域 val
    • 指针域 next(指向下一个结点)
  • 单链表
    • 只能从头往尾走,没有前驱指针
    • 头指针 head 指向第一个结点
    • 表尾结点的 next == nullptr
    • 按值查找 O(n)、按下标访问 O(n)
    • 已知前驱 p,插入/删除 O(1)
  • 双向链表
    • 两个指针 prev 与 next
    • 可以往前也可以往后
    • 删除 p 要改**两个**邻居的指针
    • 已知 p 时删除 O(1)(单链表需要前驱,是 O(n))
  • 循环链表
    • 表尾的 next 指回表头
    • 遍历时要用 do-while 或计数终止
  • 哨兵(哑)结点 dummy
    • 放在真正的头结点之前
    • 好处:删除头结点不用特判
    • 返回时返回 dummy.next
  • 常见操作
    • 头插法:新结点插在 head 前(逆序建表)
    • 尾插法:接在 tail 后(顺序建表)
    • 反转:三个指针 prev / cur / next
    • 合并两个有序链表:类似归并的 merge
③核心精讲

1. 结点与头指针

struct Node {
    int val;
    Node *next;
    Node(int x) : val(x), next(nullptr) {}
};
Node *head = nullptr;          // 空链表

head 本身不是结点,它只是指向第一个结点的指针。 空链表写成 head == nullptr,不是 head->next == nullptr。

2. 插入:先连后断

在第 p 个结点之后插入 s:

s->next = p->next;      // ① 先让 s 接上后半段
p->next = s;            // ② 再让 p 指向 s

顺序不能反。如果先写 p->next = s,p->next 原来的值就丢了, 后半段整条链表断掉。

3. 删除:跳过再释放

删除 p 之后的结点:

Node *del = p->next;            // ① 记住要删的
p->next = del->next;            // ② 让前驱跳过它
delete del;                     // ③ 释放内存

删除头结点要特判:

if (head != nullptr) {
    Node *del = head;
    head = head->next;
    delete del;
}

用哨兵结点可以省掉这个特判:

Node dummy(0);            // 栈上的哨兵
dummy.next = head;
Node *cur = &dummy;
while (cur->next) {
    if (cur->next->val == val) {
        Node *del = cur->next;
        cur->next = del->next;
        delete del;
    } else {
        cur = cur->next;
    }
}
head = dummy.next;        // 真正的头可能变了

4. 双向链表:删除要改两个邻居

// 删除 p(p 既不是头也不是尾)
p->prev->next = p->next;
p->next->prev = p->prev;
delete p;

单向链表删除 p 必须先找到 p 的前驱(O(n)),双向链表因为存了 prev, 已知 p 就能 O(1) 删掉——这是五级最爱对比的一点。

5. 反转链表:三指针

Node* reverse(Node *head) {
    Node *prev = nullptr, *cur = head;
    while (cur) {
        Node *nxt = cur->next;   // ① 先存下一站
        cur->next = prev;        // ② 掉头
        prev = cur;              // ③ prev 前进
        cur = nxt;               // ④ cur 前进
    }
    return prev;                 // 新的头
}

以 1→2→3 为例:

轮次curnxt反转后prev
初始1—1→∅∅
第1轮121→∅1
第2轮232→12
第3轮3∅3→2→13

6. 复杂度对照

操作数组单链表双向链表
随机访问第 k 个O(1)O(k)O(k)
已知位置插入O(n)(要挪元素)O(1)O(1)
已知结点删除O(n)O(n)(找前驱)O(1)
内存连续,可能有碎片浪费不连续,每结点多一个指针不连续,每结点多两个指针
✍️ 真题演练 · 共 27 题,点选项即时判分
105级GESP 真题📌 链表:单链表与双向链表第 1–10 题 · 20 分
1.2024-09 第2题
通过( )操作,能完成在双向循环链表结点p 之后插入结点s 的功能(其中next 域为结点的直接后继,
prev 域为结点的直接前驱)。
2.2025-06 第3题
基于上题代码正确的前提下,填入相应代码完善append() ,用于在双向链表尾部增加新节点,横线上应填 写( )。
void append(int data) {
    Node* newNode = new Node{data, nullptr, nullptr};
    if (is_empty()) {
        head = tail = newNode;
    } else {
        _______________________
    }
    ++size;
}
tail->next = newNode;
newNode->prev = tail;
tail = newNode;
tail = newNode;
newNode->prev = tail;
tail->next = newNode;
tail->next = newNode;
newNode->prev = tail;
tail = newNode;
3.2026-03 第1题
关于单链表、双链表和循环链表,下列说法正确的是( )。
4.2026-09 第2题
在不带哨兵结点的双向链表中,结点 p 既不是头结点也不是尾结点。删除 p 的正确代码是( )。
struct Node {
    int value;
    Node *prev;
    Node *next;
};
p->prev = p->next;
p->next = p->prev;
delete p;
p->prev->next = p;
p->next->prev = p;
delete p;
p->prev->next = p->next;
p->next->prev = p->prev;
delete p;
p->next = p->prev;
p->prev->next = nullptr;
delete p;
5.2024-03 第15题
假设给定链表为: ,若调用 searchValue(head, 5) ,函数返回值为( )。
int searchValue(ListNode* head, int target) {
    while (head != nullptr) {
        if (head->val == target) {
            return 1;
        }
        head = head->next;
    }
    return 0;
}
6.2024-12 第3题
为了方便链表的增删操作,一些算法生成一个虚拟头节点,方便统一删除头节点和其他节点。下面代码实现 了删除链表中值为val 的节点,横线上应填的最佳代码是( )。
struct LinkedNode {
    int val;
    LinkedNode* next;
    LinkedNode(int val):val(val), next(nullptr){}
};
void removeElements(LinkedNode* head, int val) {
    if (head == nullptr) {
        return;
    }
    LinkedNode* cur;
    LinkedNode* dummyHead = new LinkedNode(0); //虚拟头节点
    ________________________________     // 在此处填入代码
    while(cur ->next != nullptr) {
        if(cur->next->val == val) {
            LinkedNode* tmp = cur->next;
            cur->next = cur->next->next;
            delete tmp;
            tmp = nullptr;
        }
        else {
            cur = cur ->next;
        }
    }
    head = dummyHead->next;
    delete dummyHead;
    dummyHead = nullptr;
}
7.2023-12 第5题
下面的C++代码用于将字符串保存到带头节点的双向链表中,并对重复的串计数,然后将最新访问的串的节 点放在链头便于查找。横线处应填入代码是( )。
📷 原卷配图(表格 / 流程图 / 代码截图,文字层无法还原)
原卷配图
8.2025-03 第2题
双向链表中每个结点有两个指针域prev 和next ,分别指向该结点的前驱及后继结点。设p 指向链表中的 一个结点,它的前驱结点和后继结点均非空。要删除结点p ,则下述语句中错误的是( )。
p->next->prev = p->next;
p->prev->next = p->prev;
delete p;
p->prev->next = p->next;
p->next->prev = p->prev;
delete p;
p->next->prev = p->prev;
p->next->prev->next = p->next;
delete p;
p->prev->next = p->next;
p->prev->next->prev = p->prev;
delete p;
9.2025-03 第3题
假设双向循环链表包含头尾哨兵结点(不存储实际内容),分别为head 和tail ,链表中每个结点有两个指 针域prev 和next ,分别指向该结点的前驱及后继结点。下面代码实现了一个空的双向循环链表,横线上应填的最 佳代码是( )。
// 链表结点
template <typename T>
struct ListNode {
    T data;
    ListNode* prev;
    ListNode* next;
    // 构造函数
    explicit ListNode(const T& val = T())
        : data(val), prev(nullptr), next(nullptr) {}
};
struct LinkedList {
    ListNode<T>* head;
    ListNode<T>* tail;
};
void InitLinkedList(LinkedList* list) {
    list->head = new ListNode<T>;
    list->tail = new ListNode<T>;
    ________________________________    // 在此处填入代码
};
list->head->prev = list->head;
list->tail->prev = list->head;
list->head->next = list->tail;
list->tail->prev = list->head;
list->head->next = list->tail;
list->tail->next = list->head;
list->head->next = list->tail;
list->tail->next = nullptr;
10.2025-06 第2题
下面C++代码实现双向链表。函数is_empty() 判断链表是否为空,如链表为空返回true ,否则返回
false 。横线处不能填写(  )。
// 节点结构体
struct Node {
    int data;
    Node* prev;
    Node* next;
};
// 双向链表结构体
struct DoubleLink {
    Node* head;
    Node* tail;
    int size;
    DoubleLink() {
        head = nullptr;
        tail = nullptr;
        size = 0;
    }
    ~DoubleLink() {
        Node* curr = head;
        while (curr) {
            Node* next = curr->next;
            delete curr;
            curr = next;
        }
    }
    // 判断链表是否为空
    bool is_empty() const {
        _______________________
    }
};
参考答案(第 1–10 题)
  • 1.D 通过( )操作,能完成在双向循环链表结点p 之后插入结点s 的功能(…
  • 2.D 基于上题代码正确的前提下,填入相应代码完善append() ,用于在…
  • 3.D 关于单链表、双链表和循环链表,下列说法正确的是( )。…
  • 4.C 在不带哨兵结点的双向链表中,结点 p 既不是头结点也不是尾结点。删除…
  • 5.A 假设给定链表为: ,若调用 searchValue(head, 5)…
  • 6.A 为了方便链表的增删操作,一些算法生成一个虚拟头节点,方便统一删除头节…
  • 7.B 下面的C++代码用于将字符串保存到带头节点的双向链表中,并对重复的串…
  • 8.A 双向链表中每个结点有两个指针域prev 和next ,分别指向该结点…
  • 9.B 假设双向循环链表包含头尾哨兵结点(不存储实际内容),分别为head …
  • 10.C 下面C++代码实现双向链表。函数is_empty() 判断链表是否为…
115级GESP 真题📌 链表:单链表与双向链表第 11–20 题 · 20 分
11.2026-03 第2题
双向循环链表中要在结点 p 之前插入新结点 s (均非空),以下指针操作正确的是( )。
s -> next = p;
p -> prev = s;
p -> next = s;
s -> prev = p;
s -> prev = p; 
s -> next = p -> next; 
p -> next -> prev = s; 
p -> next = s;
s -> next = p; 
s -> prev = p->prev; 
p -> prev -> next = s; 
p -> prev = s;
s -> next = p; 
s -> prev = nullptr; 
p -> prev = s;
12.2024-06 第3题
小杨采用如下双链表结构保存他喜欢的歌曲列表: 小杨想在头指针为head 的双链表中查找他喜欢的某首歌曲,采用如下查询函数,该操作的时间复杂度为( )。
struct dl_node {
    string song;
    dl_node* next;
    dl_node* prev;
};
dl_node* search(dl_node* head, string my_song) {
    dl_node* temp = head;
    while (temp != nullptr) {
        if (temp->song == my_song)
            return temp;
        temp = temp->next;
    }
    return nullptr;
}
📄 原卷原题(四个选项都是公式/代码图,按原卷呈现)
原卷题目
13.2026-09 第1题
小杨用单链表保存任务序列,并同时维护头指针 head 和尾指针 tail 。在链表非空且已知 tail 的情况 下,在表尾插入新结点的时间复杂度是( )。
struct Node {
    int value;
    Node *next;
};
Node *head;
Node *tail;
📄 原卷原题(四个选项都是公式/代码图,按原卷呈现)
原卷题目
14.2023-09 第15题
有关下面代码的说法正确的是( )。
📷 原卷配图(表格 / 流程图 / 代码截图,文字层无法还原)
原卷配图
15.2023-12 第12题
有关下面C++代码的说法正确的是( )。
📷 原卷配图(表格 / 流程图 / 代码截图,文字层无法还原)
原卷配图
16.2024-12 第2题
在循环单链表中,节点的 next 指针指向下一个节点,最后一个节点的 next 指针指向( )。
17.2025-09 第2题
函数removeElements 删除单链表中所有结点值等于 val 的结点,并返回新的头结点,其中链表头结点为
head ,则横线处填写(   )。
// 结点结构体
struct Node {
    int val;
    Node* next;
    Node() : val(0), next(nullptr) {}
    Node(int x) : val(x), next(nullptr) {}
    Node(int x, Node *next) : val(x), next(next) {}
};
Node* removeElements(Node* head, int val) {
    Node dummy(0, head);        // 哑结点,统一处理头结点
    Node* cur = &dummy;
    while (cur->next) {
        if (cur->next->val == val) {
            _______________________        // 在此填入代码
        }
        else {
            cur = cur->next;
        }
    }
    return dummy.next;
}
Node* del = cur;
cur = del->next;
delete del;
Node* del = cur->next;
cur->next = del;
delete del;
Node* del = cur->next;
cur->next = del->next;
delete del;
Node* del = cur->next;
delete del;
cur->next = del->next;
18.2025-09 第3题
函数hasCycle 采用Floyd快慢指针法判断一个单链表中是否存在环,链表的头节点为head ,即用两个指针 在链表上前进:slow 每次走 1 步,fast 每次走 2 步,若存在环,fast 终会追上 slow (相遇);若无环,
fast 会先到达 nullptr,则横线上应填写(   )。
struct Node {
    int val;
    Node *next;
    Node(int x) : val(x), next(nullptr) {}
};
bool hasCycle(Node *head) {
    if (!head || !head->next)
        return false;
    Node* slow = head;
    Node* fast = head->next;
    while (fast && fast->next) {
        if (slow == fast) return true;
        _______________________        // 在此填入代码
    }
    return false;
}
slow = slow->next;
fast = fast->next->next;
slow = fast->next;
fast = slow->next->next;
slow = slow->next;
fast = slow->next->next;
slow = fast->next;
fast = fast->next->next;
19.2026-03 第3题
下面函数用“哑结点”统一处理删除单向链表中的头结点与中间结点。横线处应填( )。 第页共页
struct Node{
    int val;
    Node* next;
    Node(int v):val(v),next(nullptr){}
};
Node* eraseAll(Node* head, int x){
    Node dummy(0);
    dummy.next = head;
    Node* cur = &dummy;
    while(cur->next){
        if(cur->next->val == x){
            Node* del = cur->next;
            ______________________
            delete del;
        }else cur = cur->next;
    }
    return dummy.next;
}
cur = cur->next;
cur->next = del->next;
del->next = cur->next;
cur->next = nullptr;
20.2024-03 第4题
下面的代码片段用于在双向链表中删除一个节点。请在横线处填入( ),使其能正确实现相应功能。
void deleteNode(DoublyListNode*& head, int value) {
    DoublyListNode* current = head;
    while (current != nullptr && current->val != value) {
        current = current->next;
    }
    if (current != nullptr) {
        if (current->prev != nullptr) {
           ____________________________________ // 在此处填入代码
        } else {
            head = current->next;
        }
        if (current->next != nullptr) {
            current->next->prev = current->prev;
        }
        delete current;
    }
}
参考答案(第 11–20 题)
  • 11.C 双向循环链表中要在结点 p 之前插入新结点 s (均非空),以下指针…
  • 12.B 小杨采用如下双链表结构保存他喜欢的歌曲列表: 小杨想在头指针为hea…
  • 13.A 小杨用单链表保存任务序列,并同时维护头指针 head 和尾指针 ta…
  • 14.C 有关下面代码的说法正确的是( )。…
  • 15.B 有关下面C++代码的说法正确的是( )。…
  • 16.C 在循环单链表中,节点的 next 指针指向下一个节点,最后一个节点的…
  • 17.C 函数removeElements 删除单链表中所有结点值等于 val…
  • 18.A 函数hasCycle 采用Floyd快慢指针法判断一个单链表中是否存…
  • 19.B 下面函数用“哑结点”统一处理删除单向链表中的头结点与中间结点。横线处…
  • 20.B 下面的代码片段用于在双向链表中删除一个节点。请在横线处填入( ),使…
125级GESP 真题📌 链表:单链表与双向链表第 21–27 题 · 14 分
21.2024-06 第4题
小杨想在如上题所述的双向链表中加入一首新歌曲。为了能快速找到该歌曲,他将其作为链表的第一首歌 曲,则下面横线上应填入的代码为( )。
void insert(dl_node *head, string my_song) {
    p = new dl_node;
    p->song = my_song;
    p->prev = nullptr;
    p->next = head;
    if (head != nullptr) {
        ________________________________  // 在此处填入代码
    }
    head = p;
}
22.2025-06 第4题
下列C++代码用循环链表解决约瑟夫问题,即假设n 个人围成一圈,从第一个人开始数,每次数到第k 个 的人就出圈,输出最后留下的那个人的编号。横线上应填写( )。
struct Node {
    int data;
    Node* next;
};
Node* createCircularList(int n) {
    Node* head = new Node{1, nullptr};
    Node* prev = head;
    for (int i = 2; i <= n; ++i) {
        Node* node = new Node{i, nullptr};
        prev->next = node;
        prev = node;
    }
    prev->next = head;
    return head;
}
int fingLastSurvival(int n, int k) {
    Node* head = createCircularList(n);
    Node* p = head;
    Node* prev = nullptr;
    while (p->next != p) {
        for (int count = 1; count < k; ++count) {
            prev = p;
            p = p->next;
        }
        _______________________
    }
    cout << "最后留下的人编号是: " << p->data << endl;
    delete p;
    return 0;
}
prev->next = p->next;
delete p;
p = prev->next;
delete p;
prev->next = p->next;
p = prev->next;
delete p;
p = prev->next;
prev->next = p->next;
prev->next = p->next;
p = prev->next;
delete p;
23.2026-09 第3题
下面函数使用快慢指针查找单链表的中间结点。横线处应填写( )。
struct Node {
    int value;
    Node *next;
};
Node *middle(Node *head) {
    Node *slow = head;
    Node *fast = head;
    while (fast != nullptr && fast->next != nullptr) {
        slow = slow->next;
        ______________________
    }
    return slow;
}
24.2024-09 第1题
下面关于链表和数组的描述,错误的是( )。
25.2025-03 第1题
链表不具备的特点是( )。
26.2025-09 第1题
以下哪种情况使用链表比数组更合适?
27.2025-03 第7题
在程序运行过程中,如果递归调用的层数过多,会因为( )引发错误。
参考答案(第 21–27 题)
  • 21.C 小杨想在如上题所述的双向链表中加入一首新歌曲。为了能快速找到该歌曲,…
  • 22.A 下列C++代码用循环链表解决约瑟夫问题,即假设n 个人围成一圈,从第…
  • 23.B 下面函数使用快慢指针查找单链表的中间结点。横线处应填写( )。…
  • 24.C 下面关于链表和数组的描述,错误的是( )。…
  • 25.A 链表不具备的特点是( )。…
  • 26.B 以下哪种情况使用链表比数组更合适?…
  • 27.A 在程序运行过程中,如果递归调用的层数过多,会因为( )引发错误。…
④今日打卡 · 点一下就能勾选
☑ 已勾选 0 / 7 项点一下条目即可勾选
五级 · 理论 DAY 05

二分查找与二分答案

📌 考点 有序数组二分 / 左右边界 / lower_bound / upper_bound✍️ 客观题 17⏱ 建议用时 40 分钟🎯 难度 ★★★☆☆
①今日考情 · 真题分布与备考建议

本考点在 GESP C++ 5级近 14 期真题中共 17 道客观题(单选 17 / 判断 0,其中 2 道需看原卷配图)。本页把这一考点的真题全部收进来了,一道没漏,按每 10 题一张卡分组,可分次完成。

本期分布

期次题数
2023-122
2024-031
2024-061
2024-091
2024-122
2025-032
2025-062
2025-091
2026-033
2026-092

配套教材

GESP 大通关 5 级(全书 76 页):本天对应 5.5 二分查找与二分答案。教材按同一套大纲顺序编排,可对照阅读。

备考建议(出题人视角)

二分是五级里「最容易写对、也最容易写错」的一块,错的地方永远在**边界**:`l < r` 还是 `l <= r`、`mid` 要不要 +1、返回 `l` 还是 `r`。真题不考你背模板,考你能不能判断「这道题能不能二分」——判据只有一条:**答案是否具有单调性**。

②知识地图 · 本考点思维导图
二分查找与二分答案
  • 二分查找(在有序数组里找一个值)
    • 前提:数组有序
    • 每轮排除一半 → O(log n)
    • mid 写法:lo + (hi - lo) / 2
      • 防 lo + hi 溢出
    • 找不到时返回 -1 或插入位置
  • 边界问题(三个必须想清的)
    • 循环条件:l <= r(闭区间)还是 l < r(左闭右开)
    • 区间更新:l = mid + 1 / r = mid - 1 / r = mid
    • 死循环:l = mid 且 mid 向下取整时会卡住
  • 找第一个 / 最后一个
    • 第一个 ≥ x:lower_bound
    • 第一个 > x:upper_bound
    • 相等元素的个数 = upper − lower
  • 二分答案(二分枚举法)
    • 不直接在数据上二分,而是在**答案范围**上二分
    • 需要一个 check(x):判断「答案是 x 时可行吗」
    • check 必须单调:x 可行 → 更大/更小也可行
    • 典型:最小最大值、最大最小值、最少次数
  • 复杂度
    • 二分 O(log n),加上每次 check 的 O(n) → O(n log n)
③核心精讲

1. 最标准的二分查找

int binarySearch(int a[], int n, int target) {
    int lo = 0, hi = n - 1;              // 闭区间 [lo, hi]
    while (lo <= hi) {
        int mid = lo + (hi - lo) / 2;    // 防溢出
        if (a[mid] == target) return mid;
        else if (a[mid] < target) lo = mid + 1;
        else                      hi = mid - 1;
    }
    return -1;                           // 没找到
}

n = 8 时最多比较 4 次(⌈log₂8⌉+1),n = 1000 时最多 11 次。 这就是 O(log n) 的直观含义。

为什么写 lo + (hi - lo) / 2:(lo + hi) 在 lo、hi 都接近 int 上限时 会溢出成负数,再除以 2 就得到负的下标,程序直接崩。 这是五级选择题的原题考点。

2. 找左边界 / 右边界

第一个 ≥ x 的位置(lower_bound):

int lowerBound(int a[], int n, int x) {
    int lo = 0, hi = n;                  // 左闭右开 [lo, hi)
    while (lo < hi) {
        int mid = lo + (hi - lo) / 2;
        if (a[mid] < x) lo = mid + 1;    // mid 太小,答案在右边
        else            hi = mid;        // mid 可能是答案,保留
    }
    return lo;                            // 第一个 ≥ x 的下标(可能是 n)
}

第一个 > x 的位置(upper_bound):把 a[mid] < x 改成 a[mid] <= x。

于是 x 出现的次数 = upperBound(x) - lowerBound(x)。

3. 三个边界坑

坑表现正确做法
循环条件写错l <= r 配 r = mid 会死循环闭区间配 mid ± 1;左闭右开配 r = mid
mid 不 +1l = mid 时若 mid 向下取整会原地打转右半段用 mid = (l + r + 1) / 2
返回错变量返回 r 但答案是 l想清「循环结束时 l 和 r 谁指向答案」

4. 二分答案:五级的分水岭

有些题不是「在数组里找数」,而是「找一个最优的整数答案」,比如:

把 n 根绳子切成 k 段等长的,每段最长能多长? 把 n 件货物在 D 天内运完,船的载重量最小是多少?

这类题的共同点:答案是单调的。 「每段越长 → 能切出的段数越少」,这就是单调性。

// 求「每段最长多少」,check(len) = 能切出的段数 >= k
bool check(int len) {
    int cnt = 0;
    for (int i = 0; i < n; i++) cnt += a[i] / len;
    return cnt >= k;
}

int lo = 1, hi = maxLen, ans = 0;
while (lo <= hi) {
    int mid = lo + (hi - lo) / 2;
    if (check(mid)) { ans = mid; lo = mid + 1; }   // 可行,试试更长
    else            hi = mid - 1;                   // 不可行,缩短
}

判断能不能二分的唯一标准:答案变大时,可行性是单调变化的(要么一直可行、要么一直不可行)。 如果不单调,就只能枚举。

5. 二分 vs 暴力

暴力枚举二分
复杂度O(n) 或 O(n²)O(log n) 或 O(n log n)
前提无数据有序 / 答案单调
n = 10⁹超时30 次以内搞定
✍️ 真题演练 · 共 17 题,点选项即时判分
135级GESP 真题📌 二分查找与二分答案第 1–10 题 · 20 分
1.2025-06 第11题
下面的 C++ 代码用于在升序数组lst 中查找目标值target 最后一次出现的位置。相关说法,正确的是( )。
第 11 题  下面的 C++ 代码用于在升序数组lst 中查找目标值target 最后一次出现的位置。相关说法,正确的是(    
int binary_search_last_occurrence(const vector<int>& lst, int target) {
    if (lst.empty()) return -1;
    int low = 0, high = lst.size() - 1;
    while (low < high) {
        int mid = (low + high + 1) / 2;
        if (lst[mid] <= target) {
            low = mid;
        } else {
            high = mid - 1;
        }
    }
    if (lst[low] == target)
        return low;
    else
        return -1;
}
2.2024-12 第11题
给定一个长度为的有序数组nums ,其中所有元素都是唯一的。下面的函数返回数组中元素target 的索 引。 关于上述函数,描述不正确的是( )。
int binarySearch(vector<int> &nums, int target, int left, int right) {
    if (left > right) {
        return -1; 
    }
    int middle = left + ((right - left) / 2);
    if (nums[middle] == target) {
        return middle; 
    }
    else if (nums[middle] < target) {
        return binarySearch(nums, target, middle + 1, right);
    } 
    else 
        return binarySearch(nums, target, left, middle - 1);
    } 
}
int Find(vector<int> &nums, int target) {
    int n = nums.size();
    return binarySearch(nums, target, 0, n - 1);
}
📄 题干原图(本题公式在 PDF 里不是文字,以原卷为准)
题干原图
3.2025-03 第12题
下面代码实现了二分查找算法,在数组 arr 找到目标元素 target 的位置,则横线上能填写的最佳代码 是( )。
int binarySearch(int arr[], int left, int right, int target) {
    while (left <= right) {
        ________________________________       // 在此处填入代码
        if (arr[mid] == target)
            return mid;
        else if (arr[mid] < target)
            left = mid + 1;
        else
            right = mid - 1;
    }
    return -1;
}
4.2024-06 第11题
根据下述二分查找法,在排好序的数组1,3,6,9,17,31,39,52,61,79,81,90,96 中查找数值 82,和82比较的数组元素分别是( )。
int binary_search(vector<int>& nums, int target) {
    int left = 0;
    int right = nums.size() - 1;
    while (left <= right) {
        int mid = (left + right) / 2;
        if (nums[mid] == target) {
            return mid;
        } else if (nums[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return -1; // 如果找不到目标元素,返回-1
}
5.2024-09 第13题
根据下述二分查找法,在排好序的数组1,3,6,9,17,31,39,52,61,79 中查找数值31 ,循环
while (left <= right) 执行的次数为(  )。
int binary_search(vector<int>& nums, int target) {
    int left = 0;
    int right = nums.size() - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) {
            return mid;
        }
        else if (nums[mid] < target) {
            left = mid + 1;
        }
        else {
            right = mid - 1;
        }
    }
    return -1; // 如果找不到目标元素,返回-1
}
6.2024-12 第12题
给定一个长度为的有序数组nums ,其中可能包含重复元素。下面的函数返回数组中某个元素target 的 左边界,若数组中不包含该元素,则返回−1 。例如在数组nums = [5,7,7,8,8,10] 中查找target=8 ,函数返 回在数组中的左边界的索引为。则横线上应填写的代码为( )。
int getLeftBoundary(vector<int>& nums, int target) {
    int left = 0;
    int right = nums.size() - 1;
    while (left < right) {         
        int middle = left + ((right - left) / 2);
        if (target <= nums[middle])  
            ________________________________     // 在此处填入代码
        else                      
            left = middle+1;
    }
    return nums[left]==target?left:-1;
}
📄 题干原图(本题公式在 PDF 里不是文字,以原卷为准)
题干原图
7.2026-03 第8题
在升序数组中查找第一个大于等于x 的位置,下面循环中横线应填( )。 第 4 页 / 共 14 页
int lowerBound(const vector<int>& a, int x){
    int l=0, r=a.size(); 
    while(l<r){
        int mid = l + (r - l)/2;
        if(a[mid] >= x)  _____________;
        else l = mid + 1;
    }
    return l;
}
r = mid;
r = mid - 1;
l = mid;
l = mid + 1;
8.2026-09 第9题
在升序数组中查找第一个严格大于 x 的元素位置,下面代码中的横线应填写( )。
int upperBound(const vector<int> &a, int x) {
    int l = 0, r = (int)a.size();
    while (l < r) {
        int mid = l + (r - l) / 2;
        if (__________________) {
            l = mid + 1;
        } else {
            r = mid;
        }
    }
    return l;
}
9.2024-03 第8题
给定序列:1,3,6,9,17,31,39,52,61,79,81,90,96。使用以下代码进行二分查找查找元素 82 时,需要循环多少次,即最后输出的 times 值为( )。
int binarySearch(const std::vector<int>& arr, int target) {
    int left = 0;
    int right = arr.size() - 1;
    int times = 0;
    while (left <= right) {
        times ++;
        int mid = left + (right - left) / 2;
        if (arr[mid] == target) {
            cout << times << endl;
            return mid;
        } else if (arr[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    cout << times << endl;
    return -1;
}
10.2025-03 第11题
若用二分法在[1, 100]内猜数,最多需要猜( )次。
参考答案(第 1–10 题)
  • 1.A 下面的 C++ 代码用于在升序数组lst 中查找目标值target …
  • 2.C 给定一个长度为的有序数组nums ,其中所有元素都是唯一的。下面的函…
  • 3.A 下面代码实现了二分查找算法,在数组 arr 找到目标元素 targe…
  • 4.C 根据下述二分查找法,在排好序的数组1,3,6,9,17,31,39,…
  • 5.C 根据下述二分查找法,在排好序的数组1,3,6,9,17,31,39,…
  • 6.B 给定一个长度为的有序数组nums ,其中可能包含重复元素。下面的函数…
  • 7.A 在升序数组中查找第一个大于等于x 的位置,下面循环中横线应填( )。…
  • 8.C 在升序数组中查找第一个严格大于 x 的元素位置,下面代码中的横线应填…
  • 9.D 给定序列:1,3,6,9,17,31,39,52,61,79,81,…
  • 10.C 若用二分法在[1, 100]内猜数,最多需要猜( )次。…
145级GESP 真题📌 二分查找与二分答案第 11–17 题 · 14 分
11.2025-06 第12题
有关下面C++代码的说法,错误的是( )。
double sqrt_binary(long long n, double epsilon = 1e-10) {
    if (n < 0) {
        throw invalid_argument("输入必须为非负整数");
    }
    if (n == 0 || n == 1) return n;
    // 阶段 1
    long long low = 1, high = n;
    long long k = 0;
    while (low <= high) {
        long long mid = (low + high) / 2;
        long long mid_sq = mid * mid;
        if (mid_sq == n) {
            return mid;
        } else if (mid_sq < n) {
            k = mid;
            low = mid + 1;
        } else {
            high = mid - 1;
        }
    }
    long long next_k = k + 1;
    if (next_k * next_k == n) {
        return next_k;
    }
    // 阶段 2
    double low_d = (double)k;
    double high_d = (double)(k + 1);
    double mid;
    while (high_d - low_d >= epsilon) {
        mid = (low_d + high_d) / 2;
        double mid_sq = mid * mid;
        if (mid_sq < n) {
            low_d = mid;
        } else {
            high_d = mid;
        }
    }
    double result = (low_d + high_d) / 2;
    long long check_int = (long long)(result + 0.5);
    if (check_int * check_int == n) {
        return check_int;
    }
    return result;
}
12.2026-03 第10题
给定 n 根木头,第 i 根长度为 a[i] 。要切成不少于 m 段等长木段,求最大可能长度,则横线上应填 写( )。 第 5 页 / 共 14 页
const int MAXN = 100005;
long long a[MAXN];
int n, m;
bool check(long long x){
    long long cnt = 0;
    for(int i = 1; i <= n; i++){
        if(x == 0) return true;
        cnt += a[i] / x;
        if(cnt >= m) return true;
    }
    return false;
}
int main(){
    cin >> n >> m;
    long long mx = 0;
    for(int i = 1; i <= n; i++){
        cin >> a[i];
        mx = max(mx, a[i]);
    }
    long long l = 1, r = mx;
    long long ans = 0;
    while(l <= r){
        long long mid = l + (r - l) / 2;
        if(check(mid)){
            ans = mid;
            ______________________
        }else{
            ______________________
        }
    }
    cout << ans << endl;
    return 0;
}
l = mid + 1;
r = mid - 1;
l = mid - 1;
r = mid + 1;
l = mid + 1;
r = mid;
l = mid;
r = mid + 1;
13.2026-09 第10题
小杨需要把若干箱货物按原顺序分配到 days 天中,每天运输连续的若干箱,求能够完成任务的最小载重 量。函数 check(cap) 判断载重量为 cap 时能否在规定天数内运完。横线处应填写( )。
long long l = maxWeight;
long long r = totalWeight;
while (l < r) {
    long long mid = l + (r - l) / 2;
    if (check(mid)) {
        ____________________
    } else {
        ____________________
    }
}
cout << l;
14.2025-09 第10题
给定一个 n x n 的矩阵 matrix ,矩阵的每一行和每一列都按升序排列。函数countLE 返回矩阵中第
k 小的元素,则两处横线上应分别填写(  )。
// 统计矩阵中 <= x 的元素个数:从左下角开始
int countLE(const vector<vector<int>>& matrix, int x) {
    int n = (int)matrix.size();
    int i = n - 1, j = 0, cnt = 0;
    while (i >= 0 && j < n) {
        if (matrix[i][j] <= x) {
            cnt += i + 1;
            ++j;
        }
        else {
            --i;
        }
    }
    return cnt;
}
int kthSmallest(vector<vector<int>>& matrix, int k) {
    int n = (int)matrix.size();
    int lo = matrix[0][0];
    int hi = matrix[n - 1][n - 1];
    while (lo < hi) {
        int mid = lo + (hi - lo) / 2;
        if (countLE(matrix, mid) >= k) {
            ________________    // 在此处填入代码
        } else {
            ________________    // 在此处填入代码
        }
    }
    return lo;
}
hi = mid - 1;
lo = mid + 1;
hi = mid;
lo = mid;
hi = mid;
lo = mid + 1;
hi = mid + 1;
lo = mid;
📷 原卷配图(表格 / 流程图 / 代码截图,文字层无法还原)
原卷配图
15.2023-12 第10题
在上题的_binarySearch 算法中,如果lst 中有N 个元素,其时间复杂度是( )。
📄 原卷原题(四个选项都是公式/代码图,按原卷呈现)
原卷题目
16.2026-03 第7题
下面程序的运行结果为( )。 第 3 页 / 共 14 页
bool check(int n, int a[], int k, int dist) {
    int cnt = 1;
    int last = a[0];
    for (int i = 1; i < n; i++) {
        if (a[i] - last >= dist) {
            cnt++;
            last = a[i];
        }
    }
    return cnt >= k;
}
int solve(int n, int a[], int k) {
    std::sort(a, a + n);
    int l = 0;
    int r = a[n - 1] - a[0];
    while (l < r) {
        int mid = (l + r + 1) / 2;
        if (check(n, a, k, mid))
            l = mid;
        else
            r = mid - 1;
    }
    return l;
}
int main() {
    int a[] = {1, 2, 8, 4, 9};
    int n = 5;
    int k = 3;
    std::cout << solve(n, a, k) << std::endl;
    return 0;
}
17.2023-12 第14题
小杨想编写一个判断任意输入的整数N是否为素数的程序,下面哪个方法不合适?( )
参考答案(第 11–17 题)
  • 11.D 有关下面C++代码的说法,错误的是( )。…
  • 12.A 给定 n 根木头,第 i 根长度为 a[i] 。要切成不少于 m 段…
  • 13.B 小杨需要把若干箱货物按原顺序分配到 days 天中,每天运输连续的若…
  • 14.C 给定一个 n x n 的矩阵 matrix ,矩阵的每一行和每一列都…
  • 15.B 在上题的_binarySearch 算法中,如果lst 中有N 个元…
  • 16.B 下面程序的运行结果为( )。 第 3 页 / 共 14 页…
  • 17.C 小杨想编写一个判断任意输入的整数N是否为素数的程序,下面哪个方法不合…
④今日打卡 · 点一下就能勾选
☑ 已勾选 0 / 7 项点一下条目即可勾选
五级 · 理论 DAY 06

数组、字符串与综合应用

📌 考点 一维与二维数组 / 下标与遍历 / 字符数组与 string✍️ 客观题 17⏱ 建议用时 40 分钟🎯 难度 ★★★☆☆
①今日考情 · 真题分布与备考建议

本考点在 GESP C++ 5级近 14 期真题中共 17 道客观题(单选 17 / 判断 0,其中 7 道需看原卷配图)。本页把这一考点的真题全部收进来了,一道没漏,按每 10 题一张卡分组,可分次完成。

本期分布

期次题数
2023-095
2023-122
2024-031
2024-062
2024-092
2024-121
2025-031
2025-061
2026-031
2026-091

配套教材

GESP 大通关 5 级(全书 76 页):本天对应 5.6 递归与分治(快排/归并)。教材按同一套大纲顺序编排,可对照阅读。

备考建议(出题人视角)

这一天是五级的「基本盘」:数组、字符串、高精度、以及各种读程序的细节题。真题里这部分不深但量大,丢分往往不是因为不会,而是因为**看漏了一个细节**:下标从 0 还是 1、循环到 `< n` 还是 `<= n`、字符串末尾的 `\0`。高精度是五级新增考点,重点是「从低位算、进位往高位传」。

②知识地图 · 本考点思维导图
数组、字符串与综合应用
  • 一维数组
    • 下标 0 到 n-1(C++ 规矩)
    • 越界不报错但结果不可预期
    • 常见操作:求和、最值、计数、去重
  • 二维数组
    • a[i][j]:i 是行、j 是列
    • 行优先存储,按行遍历缓存友好
    • 矩阵转置:a[i][j] ↔ a[j][i]
  • 字符数组与 string
    • char s[100] 末尾自动补 '\0'
    • strlen(s) 不算 '\0',sizeof(s) 算
    • string 可以直接 + 拼接、== 比较
    • 常用:substr / find / length
  • 字符与数字互转
    • '7' - '0' = 7(转数值)
    • 7 + '0' = '7'(转字符)
    • 大小写差 32:'a' - 'A' = 32
  • 高精度(五级新增)
    • 思想:用数组存每一位,模拟手算
    • 存储:低位在前(a[0] 是个位)方便对齐
    • 加法:逐位相加 + 进位,从低位往高位
    • 减法:不够减就借位,注意结果前导零
    • 乘法:双重循环 a[i]*b[j] 累加到 c[i+j]
  • 综合读程序
    • 先看输入规模,判断复杂度够不够
    • 再找循环边界,多数错误都在这
③核心精讲

1. 数组的边界

int a[10];                    // 合法下标 0..9
for (int i = 0; i < 10; i++)  // 不是 i <= 10
    cin >> a[i];

a[10] 越界不会报错,但写到了别的变量的内存上,结果无法预测。 阅读程序题经常靠这个制造「输出莫名其妙」的现象。

2. 字符数组与 string

char s[100] = "hello";
cout << strlen(s);        // 5   不含 '\0'
cout << sizeof(s);        // 100 整个数组的字节数

string t = "hello";
cout << t.length();       // 5
cout << t.substr(1, 3);   // "ell"  从下标 1 起取 3 个
cout << t.find("ll");     // 2
写法含义
strlen(s)到第一个 \0 为止的长度
sizeof(s)数组占的总字节数(编译期常量)
s[i]第 i 个字符,'\0' 也算一个元素

3. 字符与数字互转

char c = '7';
int  x = c - '0';         // 7     字符转数值
char d = x + '0';         // '7'   数值转字符
int  diff = 'a' - 'A';    // 32    大小写差 32
char up = c - 32;         // 小写转大写

易错:'7' 的值是 55(ASCII),不是 7。(int)'7' 得到 55。 想把字符当数字用,必须 - '0'。

4. 高精度加法:模拟手算

思想:用一个数组的每一位存一个十进制位,低位存在前面(a[0] 是个位)。

string add(string A, string B) {
    vector<int> a, b, c;
    for (int i = A.size() - 1; i >= 0; i--) a.push_back(A[i] - '0');   // 逆序存
    for (int i = B.size() - 1; i >= 0; i--) b.push_back(B[i] - '0');

    int carry = 0;                                  // 进位
    int n = max(a.size(), b.size());
    for (int i = 0; i < n || carry; i++) {
        int sum = carry;
        if (i < a.size()) sum += a[i];
        if (i < b.size()) sum += b[i];
        c.push_back(sum % 10);                      // 本位
        carry = sum / 10;                           // 进位往高位传
    }
    string res;
    for (int i = c.size() - 1; i >= 0; i--) res += char(c[i] + '0');
    return res;
}

手推 123 + 89:

  1 2 3
+   8 9
───────
个位:3+9 = 12 → 本位 2,进位 1
十位:2+8+1 = 11 → 本位 1,进位 1
百位:1+0+1 = 2 → 本位 2
结果:2 1 2

三个要点:

  1. 逆序存储,让个位对齐;
  2. 进位从低位往高位传(carry 变量);
  3. 循环条件要带 || carry,否则最高位的进位会丢。

5. 高精度减法与乘法(要点)

减法:要先比较大小决定符号,逐位不够减就向高位借 1,最后去掉前导零。

乘法:a[i] * b[j] 的结果累加到 c[i + j]:

for (int i = 0; i < a.size(); i++)
    for (int j = 0; j < b.size(); j++)
        c[i + j] += a[i] * b[j];
// 然后从低位开始处理进位

6. 读程序题的检查清单

检查项常见错误
循环边界< n 写成 <= n(越界)
下标起点0 起还是 1 起
类型int 溢出、整数除法丢小数
字符串忘了 - '0'、忘了 \0
输出格式空格、换行、前导零
✍️ 真题演练 · 共 17 题,点选项即时判分
155级GESP 真题📌 数组、字符串与综合应用第 1–10 题 · 20 分
1.2023-12 第11题
下面的C++代码使用数组模拟整数加法,可以处理超出大整数范围的加法运算。横线处应填入代码是( )。
📷 原卷配图(表格 / 流程图 / 代码截图,文字层无法还原)
原卷配图
2.2024-09 第14题
以下关于高精度运算的说法错误的是( )。
3.2024-03 第7题
下面的代码片段用于将两个高精度整数进行相加。请在横线处填入( ),使其能正确实现相应功能。
string add(string num1, string num2) {
    string result;
    int carry = 0;
    int i = num1.size() - 1, j = num2.size() - 1;
    while (i >= 0 || j >= 0 || carry) {
        int x = (i >= 0) ? num1[i--] - '0' : 0;
        int y = (j >= 0) ? num2[j--] - '0' : 0;
        int sum = x + y + carry;
        carry = sum / 10;
        _______________________________________
    }
    return result;
}
4.2024-06 第12题
要实现一个高精度减法函数,则下面代码中加划线应该填写的代码为( )。
//假设a和b均为正数,且a表示的数比b大
vector<int> minus(vector<int> a, vector<int> b) {
    vector<int> c;
    int len1 = a.size();
    int len2 = b.size();
    int i, t;
    for (i = 0; i < len2; i++) {
        if (a[i] < b[i]) {  //借位
            _____________   // 在此处填入代码
            a[i] += 10;
        }
        t = a[i] - b[i];
        c.push_back(t);
    }
    for (; i < len1; i++)
        c.push_back(a[i]);
    len3 = c.size();
    while (c[len3 - 1] == 0) {//去除前导0
        c.pop_back();
        len3--;
    }
    return c;
}
5.2026-03 第15题
下面代码实现两个整数除法,其中被除数为一个“大整数”,用字符串表示,除数是一个小整数,用int 表 示,则横线处应该填写( )。 第 8 页 / 共 14 页
int main(){
    string s;
    int b;
    cin >> s >> b;
    vector<int> a;
    for(char c : s){
        a.push_back(c - '0');
    }
    vector<int> c;
    long long rem = 0;
    for(int i = 0; i < a.size(); i++){
        rem = rem * 10 + a[i];
        int q = rem / b;
        c.push_back(q);
        ______________________
    }
    int pos = 0;
    while(pos < c.size() - 1 && c[pos] == 0) pos++;
    for(int i = pos; i < c.size(); i++){
        cout << c[i];
    }
    cout << endl;
    cout << rem << endl;
    return 0;
}
rem /= b;
rem %= b;
rem = b;
rem = q;
6.2026-09 第15题
数组 a 和 b 按低位在前的顺序保存两个非负大整数。下面代码实现高精度加法,横线处应填写 ( )。
vector<int> add(const vector<int> &a, const vector<int> &b) {
    vector<int> c;
    int carry = 0;
    int n = max(a.size(), b.size());
    for (int i = 0; i < n; i++) {
        int sum = carry;
        if (i < a.size())
            sum += a[i];
        if (i < b.size())
            sum += b[i];
        c.push_back(sum % 10);
        ____________________
    }
    if (carry)
        c.push_back(carry);
    return c;
}
📷 原卷配图(表格 / 流程图 / 代码截图,文字层无法还原)
原卷配图
7.2023-09 第1题
近年来,线上授课变得普遍,很多有助于改善教学效果的设备也逐渐流行,其中包括比较常用的手写板,那 么它属于哪类设备?( )。
8.2023-09 第3题
如果变量a 和b 分别为double 类型和int 类型,则表达式(a = 6, b = 3 * (7 + 8) / 2, b += a) 的 计算结果为( )。
9.2023-09 第8题
有关下面代码正确的是( )。
📷 原卷配图(表格 / 流程图 / 代码截图,文字层无法还原)
原卷配图
10.2023-09 第9题
有关下面C++代码正确的是( )。
📷 原卷配图(表格 / 流程图 / 代码截图,文字层无法还原)
原卷配图
参考答案(第 1–10 题)
  • 1.D 下面的C++代码使用数组模拟整数加法,可以处理超出大整数范围的加法运…
  • 2.C 以下关于高精度运算的说法错误的是( )。…
  • 3.A 下面的代码片段用于将两个高精度整数进行相加。请在横线处填入( ),使…
  • 4.A 要实现一个高精度减法函数,则下面代码中加划线应该填写的代码为( )。…
  • 5.B 下面代码实现两个整数除法,其中被除数为一个“大整数”,用字符串表示,…
  • 6.C 数组 a 和 b 按低位在前的顺序保存两个非负大整数。下面代码实现高…
  • 7.A 近年来,线上授课变得普遍,很多有助于改善教学效果的设备也逐渐流行,其…
  • 8.C 如果变量a 和b 分别为double 类型和int 类型,则表达式(…
  • 9.C 有关下面代码正确的是( )。…
  • 10.C 有关下面C++代码正确的是( )。…
165级GESP 真题📌 数组、字符串与综合应用第 11–17 题 · 14 分
11.2023-09 第10题
下面代码执行后的输出是( )。
📷 原卷配图(表格 / 流程图 / 代码截图,文字层无法还原)
原卷配图
12.2023-12 第3题
阅读下面的C++代码,执行后其输出是( )。
📷 原卷配图(表格 / 流程图 / 代码截图,文字层无法还原)
原卷配图
13.2024-06 第15题
给定如下函数(函数功能同上题,增加输出打印): 时,屏幕上输出序列为( )。 则当
int fun(int n) {
    cout << n << " ";
    if (n == 1) return 1;
    if (n == 2) return 2;
    return fun(n - 2) - fun(n - 1);
}
📷 原卷配图(表格 / 流程图 / 代码截图,文字层无法还原)
原卷配图
14.2024-09 第11题
现在有n 个人要过河,每只船最多载2人,船的承重为100kg。下列代码中,数组weight 中保存有n 个人 的体重(单位为kg),已经按从小到大排好序,代码输出过河所需要的船的数目,采用的思想为( )。
int i, j;
int count = 0;
for (i = 0, j = n - 1; i < j; j--) {
    if (weight[i] + weight[j] <= 100) {
        i++;
    }
    count++;
}
printf("过河的船数:%d\n", count);
15.2024-12 第7题
下述代码实现素数表的埃拉托色尼(埃氏)筛法,筛选出所有小于等于的素数。 下面说法,正确的是( )。
vector<int> sieve_Eratosthenes(int n) {
    vector<bool> is_prime(n +1, true);
    vector<int> primes;
    for (int i = 2; i * i <= n; i++) {
        if (is_prime[i]) {
            primes.push_back(i);
            for (int j = i * i; j <= n; j += i) {
                is_prime[j] = false;
            }
        }
    }
    for (int i = sqrt(n) + 1; i <= n; i++) {
        if (is_prime[i]) {
            primes.push_back(i);
        }
    }
    return primes;
}
16.2025-06 第1题
与数组相比,链表在( )操作上通常具有更高的效率。
17.2025-03 第14题
函数int findMax(int arr[], int low, int high) 计算数组中最大元素,其中数组arr 从索引
low 到high ,(   )正确实现了分治逻辑。
if (low == high)
    return arr[low];
int mid = (low + high) / 2;
return arr[mid];
if (low >= high)
    return arr[low];
int mid = (low + high) / 2;
int leftMax = findMax(arr, low, mid - 1);
int rightMax = findMax(arr, mid, high);
return leftMax + rightMax;
if (low > high)
    return 0;
int mid = low + (high - low) / 2;
int leftMax = findMax(arr, low, mid);
int rightMax = findMax(arr, mid + 1, high);
return leftMax * rightMax;
if (low == high)
    return arr[low];
int mid = low + (high - low) / 2;
int leftMax = findMax(arr, low, mid);
int rightMax = findMax(arr, mid + 1, high);
return (leftMax > rightMax) ? leftMax : rightMax;
参考答案(第 11–17 题)
  • 11.D 下面代码执行后的输出是( )。…
  • 12.D 阅读下面的C++代码,执行后其输出是( )。…
  • 13.C 给定如下函数(函数功能同上题,增加输出打印): 时,屏幕上输出序列为…
  • 14.B 现在有n 个人要过河,每只船最多载2人,船的承重为100kg。下列代…
  • 15.B 下述代码实现素数表的埃拉托色尼(埃氏)筛法,筛选出所有小于等于的素数…
  • 16.C 与数组相比,链表在( )操作上通常具有更高的效率。…
  • 17.D 函数int findMax(int arr[], int low, …
④今日打卡 · 点一下就能勾选
☑ 已勾选 0 / 7 项点一下条目即可勾选
五级 · 理论 DAY 07

指针、动态内存与复杂度

📌 考点 指针与地址 / 引用与传参 / new / delete✍️ 客观题 20⏱ 建议用时 45 分钟🎯 难度 ★★★★☆
①今日考情 · 真题分布与备考建议

本考点在 GESP C++ 5级近 14 期真题中共 20 道客观题(单选 20 / 判断 0,其中 8 道需看原卷配图)。本页把这一考点的真题全部收进来了,一道没漏,按每 10 题一张卡分组,可分次完成。

本期分布

期次题数
2023-091
2023-122
2024-032
2024-062
2024-092
2024-123
2025-031
2025-062
2025-092
2026-032
2026-091

配套教材

GESP 大通关 5 级(全书 76 页):本天对应 5.7 贪心算法与复杂度估算。教材按同一套大纲顺序编排,可对照阅读。

备考建议(出题人视角)

指针 + 复杂度是五级的「送分 + 送命」组合:概念题(指针是什么、new/delete 配对)基本是送分;复杂度题(数循环次数)稍不留神就错。复杂度的算法很简单:**数最内层语句执行了多少次**,然后只保留最高阶项、去掉常数。贪心也放在这天一起收:它的判断标准只有一条——能不能举出反例。

②知识地图 · 本考点思维导图
指针、动态内存与复杂度
  • 指针与地址
    • &x 取地址,*p 解引用
    • 指针的类型决定「一次走多远」
    • int *p 与 int *p, q 的区别(q 不是指针)
    • 空指针 nullptr
  • 引用与参数传递
    • 值传递:改不了实参
    • 地址传递:int *p,函数内 *p 能改实参
    • 引用传递:int &x,写法像值传递但能改实参
  • 动态内存
    • new 申请、delete 释放(必须配对)
    • new[] 配 delete[]
    • 忘记 delete → 内存泄漏
    • delete 后继续用 → 悬空指针
    • delete 两次 → 未定义行为
  • 时间复杂度
    • 单层循环 O(n)
    • 嵌套两层 O(n²)、三层 O(n³)
    • 每次减半 O(log n)
    • 排序 O(n log n)
    • 只留最高阶项、去掉常数系数
  • 空间复杂度
    • 数额外开了多少数组/变量
  • 贪心算法
    • 每步取当前最优,不回头
    • 正确性需要「贪心选择性质 + 最优子结构」
    • 只要能举出一个反例,贪心就是错的
③核心精讲

1. 指针三件套

int  x = 10;
int *p = &x;      // p 存的是 x 的地址
cout << *p;       // 10  解引用,取出 p 指向的值
*p = 20;          // 通过指针改 x
cout << x;        // 20
写法含义
&x取 x 的地址
*pp 指向的那个变量(解引用)
int *p, q;p 是指针,q 是普通 int(星号只作用于紧邻的变量)
nullptr空指针,不指向任何对象

int *p, q; 这个陷阱连续多年出现在 GESP 的选择题里: 星号只跟着 p,q 是普通的 int。

2. 三种参数传递

void byValue(int a)  { a = 100; }        // 值传递:改的是副本
void byAddr (int *a) { *a = 100; }       // 地址传递:能改实参
void byRef  (int &a) { a = 100; }        // 引用传递:能改实参

int x = 1;
byValue(x);   // x 仍是 1
byAddr(&x);   // x 变成 100
byRef(x);     // x 变成 100

3. new / delete 必须配对

int *p = new int(5);          // 申请一个 int
delete p;                     // 释放

int *arr = new int[100];      // 申请数组
delete[] arr;                 // 释放数组要用 delete[]
错误后果
new 了没 delete内存泄漏(程序运行久了内存越来越大)
delete 之后还访问悬空指针(野指针),结果不可预测
同一个指针 delete 两次未定义行为,常导致崩溃
new[] 配 delete未定义行为,数组要配 delete[]

4. 时间复杂度:数最内层语句跑了几次

// ① O(n)
for (int i = 0; i < n; i++) sum += a[i];

// ② O(n²)
for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++) cnt++;

// ③ O(log n)
for (int i = 1; i < n; i *= 2) cnt++;      // i 每次翻倍

// ④ O(n log n)
for (int i = 0; i < n; i++)
    for (int j = 1; j < n; j *= 2) cnt++;

// ⑤ O(√n)
for (int i = 1; i * i <= n; i++) cnt++;

化简规则:只保留最高阶项,去掉常数系数。

原式化简
3n² + 100n + 5000O(n²)
n + log nO(n)
2n × 3nO(n²)
n/2O(n)

易错:for (i = 1; i < n; i *= 2) 是 O(log n) 不是 O(n)。 判据是「i 怎么变」:i++ 是 n 次,i *= 2 是 log₂n 次,i * i <= n 是 √n 次。

5. 空间复杂度

只数额外开的空间,输入本身不算。

int sum = 0;                       // O(1)
for (...) sum += a[i];

int b[n];                          // O(n)
int c[n][n];                       // O(n²)

6. 贪心:能不能举出反例

贪心的写法永远是「排序 + 逐个决策」,但正确性不是自动成立的。

经典反例(找零问题):面额 1、3、4,要凑 6。

  • 贪心:先拿最大的 4,剩 2,只能拿 1+1 → 共 3 张;
  • 最优:3 + 3 → 共 2 张。

所以「每次拿面额最大的」这个贪心是错的。

贪心成立的条件:

  1. 贪心选择性质:每步的局部最优能推出全局最优;
  2. 最优子结构:子问题的最优解能组合成原问题的最优解。

考试里遇到贪心题,如果拿不准,先试着举一个小反例; 举不出来再相信它(但也要在草稿上验算一遍)。

✍️ 真题演练 · 共 20 题,点选项即时判分
175级GESP 真题📌 指针、动态内存与复杂度第 1–10 题 · 20 分
1.2026-03 第11题
下面代码用分治求“最大连续子段和”,其时间复杂度为( )。 第 6 页 / 共 14 页
int solve(vector<int>& a, int l, int r){
    if(l == r) return a[l];
    int mid = l + (r - l) / 2;
    int left = solve(a, l, mid);
    int right = solve(a, mid + 1, r);
    int sum = 0, lmax = INT_MIN;
    for(int i = mid; i >= l; i--){
        sum += a[i];
        lmax = max(lmax, sum);
    }
    sum = 0;
    int rmax = INT_MIN;
    for(int i = mid + 1; i <= r; i++){
        sum += a[i];
        rmax = max(rmax, sum);
    }
    return max({left, right, lmax + rmax});
}
📄 原卷原题(四个选项都是公式/代码图,按原卷呈现)
原卷题目
📄 原卷原题(四个选项都是公式/代码图,按原卷呈现)
原卷题目
2.2024-12 第1题
下面关于链表和数组的描述,错误的是( )。
3.2025-06 第10题
下面的C++代码,用于求一系列数据中的最大值。有关其算法说法错误的是( )。
int find_max(const vector<int>& nums) {
    if (nums.empty()) {
        throw invalid_argument("输入数组不能为空");
    }
    int max_value = nums[0];
    for (int num : nums) {
        if (num > max_value) {
            max_value = num;
        }
    }
    return max_value;
}
4.2026-03 第12题
游戏大赛决赛,两组选手分别按得分从小到大排好队,现在要把他们合并成一个有序排行榜。 A组:A = {12, 35, 67, 89} ,B组:B = {20, 45, 55, 78} ,下面是归并合并函数的核心循环,横线处应填 入( )。
int i = 0, j = 0;
vector<int> result;
while (i < A.size() && j < B.size()) {
    if (___________________) {
        result.push_back(A[i++]);
    } else {
        result.push_back(B[j++]);
    }
}
while (i < A.size()) {
    result.push_back(A[i++]);
}
while (j < B.size()) {
    result.push_back(B[j++]);
}
5.2023-12 第4题
下面的C++用于对lstA 排序,使得偶数在前奇数在后,横线处应填入( )。
A. !isEven(lstA[j]) && isEven(lstA[j+1])
B. isEven(lstA[j]) && !isEven(lstA[j+1])
📷 原卷配图(表格 / 流程图 / 代码截图,文字层无法还原)
原卷配图
6.2025-09 第13题
假设你是一家电影院的排片经理,只有一个放映厅。你有一个电影列表 movies ,其中 movies[i] = 别填写的代码为( )。
[start_i, end_i] 表示第i 部电影的开始和结束时间。请你找出最多能安排多少部不重叠的电影,则横线上应分
int maxMovies(vector<vector<int>>& movies) {
    if (movies.empty()) return 0;
    sort(movies.begin(), movies.end(), [](const vector<int>& a, const vector<int>& b) {
        return ______; // 在此处填入代码
    });
    int count = 1;
    int lastEnd = movies[0][1];
    for (int i = 1; i < movies.size(); i++) {
        if (movies[i][0] >= lastEnd) {
            count++;
            ______ = movies[i][1]; // 在此处填入代码
        }
    }
    return count;
}
7.2024-06 第8题
上题代码的时间复杂度是( )。
📄 原卷原题(四个选项都是公式/代码图,按原卷呈现)
原卷题目
8.2024-09 第8题
现在用如下代码来计算(个相乘),其时间复杂度为( )。
double quick_power(double x, unsigned n) {
    if (n == 0) return 1;
    if (n == 1) return x;
    return quick_power(x, n / 2) * quick_power(x, n / 2) * ((n & 1) ? x : 1);
}
📄 原卷原题(四个选项都是公式/代码图,按原卷呈现)
原卷题目
9.2024-12 第13题
假设有多个孩子,数组g 保存所有孩子的胃口值。有多块饼干,数组s 保存所有饼干的尺寸。小杨给孩子 们发饼干,每个孩子最多只能给一块饼干。饼干的尺寸大于等于孩子的胃口时,孩子才能得到满足。小杨的目标是 尽可能满足越多数量的孩子,因此打算采用贪心算法来找出能满足的孩子的数目,则横线上应填写的代码为( )。
int cooki4children(vector<int>& g, vector<int>& s) {
    sort(g.begin(), g.end());
    sort(s.begin(), s.end());
    int index = s.size() - 1; // 饼干数组下标
    int result = 0;
    for (int i = g.size() - 1; i >= 0; i--) {
        if (index >= 0 && s[index] >= g[i]) {
            ________________________________     // 在此处填入代码
        }
    }
    return result;
}
10.2025-03 第15题
小杨编写了一个如下的高精度乘法函数,则横线上应填写的代码为( )。
vector<int> multiply(vector<int>& a, vector<int>& b) {
    int m = a.size(), n = b.size();
    vector<int> c(m + n, 0);
    // 逐位相乘,逆序存储
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            c[i + j] += a[i] * b[j];
        }
    }
    // 处理进位
    int carry = 0;
    for (int k = 0; k < c.size(); ++k) {
        ________________________________     // 在此处填入代码
        c[k] = temp % 10;
        carry = temp / 10;
    }
    while (c.size() > 1 && c.back() == 0)
        c.pop_back();
    return c;
}
参考答案(第 1–10 题)
  • 1.B 下面代码用分治求“最大连续子段和”,其时间复杂度为( )。 第 6 …
  • 2.C 下面关于链表和数组的描述,错误的是( )。…
  • 3.D 下面的C++代码,用于求一系列数据中的最大值。有关其算法说法错误的是…
  • 4.B 游戏大赛决赛,两组选手分别按得分从小到大排好队,现在要把他们合并成一…
  • 5.A 下面的C++用于对lstA 排序,使得偶数在前奇数在后,横线处应填入…
  • 6.B 假设你是一家电影院的排片经理,只有一个放映厅。你有一个电影列表 mo…
  • 7.D 上题代码的时间复杂度是( )。…
  • 8.A 现在用如下代码来计算(个相乘),其时间复杂度为( )。…
  • 9.A 假设有多个孩子,数组g 保存所有孩子的胃口值。有多块饼干,数组s 保…
  • 10.B 小杨编写了一个如下的高精度乘法函数,则横线上应填写的代码为( )。…
185级GESP 真题📌 指针、动态内存与复杂度第 11–20 题 · 20 分
11.2025-06 第15题
小杨编写了一个如下的高精度除法函数,则横线上应填写的代码为( )。
const int MAXN = 1005; // 最大位数
struct BigInt {
    int d[MAXN]; // 存储数字,d[0]是个位,d[1]是十位,...
    int len;     // 数字长度
    BigInt() {
        memset(d, 0, sizeof(d));
        len = 0;
    }
};
// 比较两个高精度数的大小
int compare(BigInt a, BigInt b) {
    if(a.len != b.len) return a.len > b.len ? 1 : -1;
    for(int i = a.len - 1; i >= 0; i--) {
        if(a.d[i] != b.d[i]) return a.d[i] > b.d[i] ? 1 : -1;
    }
    return 0;
}
// 高精度减法
BigInt sub(BigInt a, BigInt b) {
    BigInt c;
    for(int i = 0; i < a.len; i++) {
        c.d[i] += a.d[i] - b.d[i];
        if(c.d[i] < 0) {
            c.d[i] += 10;
            c.d[i+1]--;
        }
    }
    c.len = a.len;
    while(c.len > 1 && c.d[c.len-1] == 0) c.len--;
    return c;
}
// 高精度除法(a/b,返回商和余数)
pair<BigInt, BigInt> div(BigInt a, BigInt b) {
    BigInt q, r; // q是商,r是余数
    if(compare(a, b) < 0) { // 如果a<b,商为0,余数为a
        q.len = 1;
        q.d[0] = 0;
        r = a;
        return make_pair(q, r);
    }
    // 初始化余数r为a的前b.len位
    r.len = b.len;
    for(int i = a.len - 1; i >= a.len - b.len; i--) {
        r.d[i - (a.len - b.len)] = a.d[i];
    }
    // 逐位计算商
    for(int i = a.len - b.len; i >= 0; i--) {
        // 把下一位加入余数
        if(r.len > 1 || r.d[0] != 0) {
            for(int j = r.len; j > 0; j--) {
                r.d[j] = r.d[j-1];
            }
            _______________________
        } else {
            r.d[0] = a.d[i];
            r.len = 1;
        }
        // 计算当前位的商
        while(compare(r, b) >= 0) {
            r = sub(r, b);
            q.d[i]++;
        }
    }
    // 确定商的长度
    q.len = a.len - b.len + 1;
    while(q.len > 1 && q.d[q.len-1] == 0) q.len--;
    // 处理余数前导零
    while(r.len > 1 && r.d[r.len-1] == 0) r.len--;
    return make_pair(q, r);
}
r.d[0] = a.d[i];
r.len++;
r.d[i] = a.d[i];
r.len++;
r.d[i] = a.d[i];
r.len = 1;
r.d[0] = a.d[i];
r.len = 1;
12.2025-09 第15题
给定一个由非负整数组成的数组digits ,表示一个非负整数的各位数字,其中最高位在数组首位,且
digits 不含前导0(除非是0本身)。下面代码对该整数执行 +1 操作,并返回结果数组,则横线上应填写(   )。
vector<int> plusOne(vector<int>& digits) {
    for (int i = (int)digits.size() - 1; i >= 0; --i) {
        if (digits[i] < 9) {
            digits[i] += 1;
            return digits;
        }
        ________________    // 在此处填入代码
    }
    digits.insert(digits.begin(), 1);
    return digits;
}
digits[i] = 0;
digits[i] = 9;
digits[i] = 1;
digits[i] = 10;
13.2026-09 第14题
下面函数使用迭代方法求最大连续子段和。对于数组 {-2, 3, -1, 5, -6, 2} ,函数返回值是 ( )。
int maxSubArray(const vector<int> &a) {
    int best = a[0];
    int current = a[0];
    for (int i = 1; i < (int)a.size(); i++) {
        current = max(a[i], current + a[i]);
        best = max(best, current);
    }
    return best;
}
14.2023-09 第7题
根据下面C++代码的注释,两个横线处应分别填入( )。
📷 原卷配图(表格 / 流程图 / 代码截图,文字层无法还原)
原卷配图
15.2023-12 第13题
通讯卫星在通信网络系统中主要起到()的作用。
16.2024-03 第3题
下面的 C++ 代码片段用于计算阶乘。请在横线处填入( ),实现正确的阶乘计算。
int factorial(int n) {
    if (n == 0 || n == 1) {
        return 1;
    } else {
        _________________________________  // 在此处填入代码
    }
}
17.2024-03 第6题
下面的代码片段用于计算斐波那契数列。该代码的时间复杂度是( )?
int fibonacci(int n) {
    if (n <= 1) {
        return n;
    } else {
        return fibonacci(n - 1) + fibonacci(n - 2);
    }
}
📄 原卷原题(四个选项都是公式/代码图,按原卷呈现)
原卷题目
18.2024-06 第14题
给定如下函数: 时,函数返回值为( )。 则当
int fun(int n) {
    if (n == 1) return 1;
    if (n == 2) return 2;
    return fun(n - 2) - fun(n - 1);
}
19.2024-09 第15题
当时,下面函数的返回值为( )。
int fun(int n) {
    if (n == 1) return 1;
    else if (n >= 5) return n * fun(n - 2);
    else return n * fun(n - 1);
}
20.2024-12 第15题
小杨编写了一个如下的高精度减法函数: 下面说法,正确的是( )。
vector<int> highPrecisionSubtract(vector<int> a, vector<int> b) {
    vector<int> result;
    int borrow = 0;
    for (int i = 0; i < a.size(); ++i) {
        int digitA = a[i];
        int digitB = i < b.size() ? b[i] : 0;
        int diff = digitA - digitB - borrow;
        if (diff < 0) {
            diff += 10;
            borrow = 1;
        }
        else {
            borrow = 0;
        }
        result.push_back(diff);
    }
    while (result.size() > 1 && result.back() == 0) {
        result.pop_back();
    }
    return result;
}
参考答案(第 11–20 题)
  • 11.A 小杨编写了一个如下的高精度除法函数,则横线上应填写的代码为( )。…
  • 12.A 给定一个由非负整数组成的数组digits ,表示一个非负整数的各位数…
  • 13.C 下面函数使用迭代方法求最大连续子段和。对于数组 {-2, 3, -1…
  • 14.A 根据下面C++代码的注释,两个横线处应分别填入( )。…
  • 15.B 通讯卫星在通信网络系统中主要起到()的作用。…
  • 16.A 下面的 C++ 代码片段用于计算阶乘。请在横线处填入( ),实现正确…
  • 17.C 下面的代码片段用于计算斐波那契数列。该代码的时间复杂度是( )?…
  • 18.D 给定如下函数: 时,函数返回值为( )。 则当…
  • 19.C 当时,下面函数的返回值为( )。…
  • 20.B 小杨编写了一个如下的高精度减法函数: 下面说法,正确的是( )。…
④今日打卡 · 点一下就能勾选
☑ 已勾选 0 / 7 项点一下条目即可勾选
五级 · 编程 DAY 01

枚举与因数分解(上)

💻 编程题 6 道📚 知识点 枚举与因数分解(上)⏱ 建议用时 180 分钟
①本日知识点 · 枚举与因数分解(上)

本组 6 道题全部来自 GESP 真题,按「枚举与因数分解(上)」归在一起练。题面取洛谷原题(含公式与样例),题解取美力程 GESP 题解库(思路 + 参考代码 + 复杂度)。

B3871因数分解2023-09 · 数论
数论
📝 题目描述
每个正整数都可以分解成素数的乘积,例如: 6=2× 3,20=2^2×5。

现在,给定一个正整数,请按要求输出它的因数分解式。

⌨️ 输入格式
输入第一行,包含一个正整数 N。约定 2 ≤ N ≤ 10^{12}。
🖨 输出格式
输出一行,为 N 的因数分解式。要求按质因数由小到大排列,乘号用星号 * 表示,且左右各空一格。当且仅当一个素数出现多次时,将它们合并为指数形式,用上箭头 ^ 表示,且左右不空格。
🔎 样例
#输入输出
1
6
2 * 3
2
20
2^2 * 5
3
23
23
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
题目拆解
📝 题目原文
给定正整数 N(2 ≤ N ≤ 10¹²),输出它的因数分解式:
按质因数从小到大排列
乘号用 * 表示,左右各一个空格
同一质数出现多次时合并为指数形式 p^e(^ 左右不空格)
例:6 = 2 * 3;20 = 2^2 * 5;23 = 23。
💡人话翻译:两步走——① 质因数分解(试除到 √N);② 按格式拼接字符串。难点其实在格式细节:乘号周围要有空格,但 ^ 周围不能有;指数为 1 时不输出 ^1。

🔍 关键词提取
试除法分解格式输出边界处理long long
已知条件
项目说明
输入一个正整数 N
输出一行因数分解式
数据范围2 ≤ N ≤ 10¹²
排序质因数从小到大
格式乘号写 * (左右各一空格);指数写 p^e
需要解决的问题
试除到多少?只需试到 √N。N ≤ 10¹² 时最多试 10⁶ 次
怎么合并指数?对每个质因子用 while (t % p == 0) 统计次数 e
格式怎么控制?用一个"是否已输出过"的标记,决定前面要不要加 *

思维导图
🔬 分解 + 格式化拼接

📥 读入
N ≤ 10¹²
必须用 long long
试除上限 √N
i 从 2 开始

🔬 分解
若 t % i == 0
循环统计指数 e
t 除以 i 的 e 次幂
记录 (i, e)

🧾 格式化
第一项前不加乘号
后续项前加 " * "
e == 1 只输出 p
e > 1 输出 "p^e"

⚠️ 易错点
用 int 读入(10¹² 溢出)
忘记最后剩余的大质因子
指数 1 输出了 ^1
乘号空格数不对

样例手算推导
🧮 样例逐个走一遍
先分解,再按格式拼接。
1
N = 6
i = 2:6 % 2 == 0,统计到指数 1,t 变 3
i = 3:但此时 i × i = 9 > t = 3,循环结束
t = 3 > 1,把 3 作为最后一个质因子(指数 1)
因子列表:(2,1)、(3,1)
✅ 输出 "2 * 3"

2
N = 20
i = 2:20 % 2 == 0,连续除两次 → 指数 2,t 变 5
i = 3:i × i = 9 > t = 5,循环结束
t = 5 > 1 → 因子 (5,1)
因子列表:(2,2)、(5,1)
✅ 输出 "2^2 * 5"

3
N = 23(质数)
i 从 2 试到 √23 ≈ 4.8,都不整除
循环结束后 t = 23 > 1 → 因子 (23,1)
只有一个因子,前面不加乘号
指数为 1,所以只写 23
✅ 输出 "23"

📊 因子与输出格式对照
N质因数分解因子列表输出
62 × 3(2,1), (3,1)2 * 3
202² × 5(2,2), (5,1)2^2 * 5
2323(23,1)23
82³(2,3)2^3
10000000000002¹² × 5¹²(2,12), (5,12)2^12 * 5^12
🔑格式的两个关键点:① 指数为 1 时不写 ^1——这是最常见的错误;② 乘号写成 * (左右各一空格),但 ^ 两侧不能有空格。对照着看:2^2 * 5。

🧮 为什么试除到 √N 就够
这是分解质因数的核心性质,务必理解。
1
性质
如果 N 是合数,那么它一定有一个 ≤ √N 的质因子
因为若 N = a × b 且 a ≤ b,则 a ≤ √N
所以小的质因子一定能被试除发现

2
推理
试除到 √N 后,如果还没有把 N 除到 1
说明剩下的 t 不可能再分解成两个 ≥ 2 的数
否则它们的乘积 ≥ (√N)² = N
所以剩下的 t 一定是质数
✅ 剩下的 t 直接作为质因子

3
复杂度
N ≤ 10¹² → √N ≤ 10⁶
所以最多试除 10⁶ 次
每次循环还会快速缩小 t,实际更快
完全够快

⚠️这就是"最后剩余的大质因子"为什么必须单独处理:例如 N = 2 × 999983(999983 是大质数),试除 2 之后 t = 999983,而 √999983 ≈ 1000,循环会在 i = 1000 左右结束,此时 t 还没变成 1——所以必须把 t 作为最后一个质因子记录。

解法对比
⚔️ 解法对比
🟢 试除法(推荐) 推荐
i 从 2 试到 √t,找到因子就统计指数并除干净
时间 O(√N) = 10⁶
空间 O(1)
代码 15 行
不需要预处理
💡实现要点:循环条件用 (long long)i * i <= t,注意 t 在循环中会变小,所以条件是动态的。这样能自动减少循环次数。

🟠 先筛出 10⁶ 以内的质数
用埃氏筛打出质数表,再用质数去试除
预处理 O(10⁶ log log 10⁶)
试除次数减少到 π(10⁶) ≈ 7.8 万
代码多 10 行
单次询问更快
⚠️什么时候值得:本题只询问一次,打表 10⁶ 的预处理成本与直接试除相当,没必要。但如果需要分解很多个数(如 10⁵ 次),预处理质数表就非常划算。

📈 性能对比
方案本题成本代码量
试除法约 10⁶ 次约 15 行
筛法预处约 10⁶ + 8 × 10⁴约 25 行

算法流程图
开始读入 N(long long);t = N;first = truei 从 2 开始,当 i × i ≤ t 时循环t % i == 0 吗?是 ✓统计指数 e,t 除以 i^e,输出该项否 ✗i 加 1循环结束后 t 是否大于 1?是 ✓把 t 作为一个质因子输出否 ✗结束结束i 加 1 继续试除← 左右滑动查看完整流程图
动手算一算
🔬 因数分解器

输入一个正整数 N(2 ≤ N ≤ 10¹²),程序会分解并给出格式化的结果。

输入 N


算一下!
随机出题


结果会显示在这里

点按钮开始 →

代码精讲
💻 完整 C++ 代码
include <bits/stdc++.h>
using namespace std;

int main() {
long long n;
scanf("%lld", &n);

long long t = n;
bool first = true; // 是否还没输出过任何因子

for (long long i = 2; i * i <= t; i++) {
if (t % i == 0) {
int e = 0;
while (t % i == 0) { t /= i; e++; } // 统计指数并除干净

if (!first) printf(" * "); // 非首项前加 " * "
first = false;

if (e == 1) printf("%lld", i); // 指数为 1,不写 ^1
else printf("%lld^%d", i, e);
}
}

// 剩下的大质因子
if (t > 1) {
if (!first) printf(" * ");
printf("%lld", t);
}
printf("\n");
return 0;
}
🔑i * i <= t 这个条件是动态的:因为循环中 t 会不断变小,上界也跟着缩小。比如 N = 20,除掉 2 之后 t = 5,此时条件变成 i * i <= 5,i = 3 时 9 > 5 就退出了——省掉了大量无用试除。另外注意用 long long 计算 i * i 防溢出。

📖 关键几行怎么看
代码作用为什么这样写
i * i <= t试除上界只需试到 √t,且 t 会变小
while (t % i == 0) { t /= i; e++; }统计指数除干净,保证 i 是质因子
if (!first) printf(" * ")控制乘号首项前不加乘号
if (e == 1)指数格式指数 1 不写 ^1
if (t > 1)剩余大质因子循环结束后 t 若 > 1 必为质数
⚠️三个坑:① 用 int 读入(N 可达 10¹²,会溢出);② 忘记最后的 if (t > 1);③ 指数为 1 时也输出了 ^1。

边界测试 &amp; 易错点
🧪 边界测试用例表
写完程序后,用这些数据自查一遍:
输入答案考察点
62 * 3题面样例 1
202^2 * 5题面样例 2
2323题面样例 3(质数)
82^3只有一个质因子,无乘号
22最小值
10000000000002^12 * 5^12最大值 10¹²
✅自查清单:① 用 long long 了吗?② 补了剩余因子吗?③ 格式完全对吗?

🚨 易错点清单
⚠️用 int:N 可达 10¹²,必须用 long long(%lld)。

⚠️漏掉最后的大质因子:循环结束后若 t > 1,必须把它输出。

⚠️格式细节错:指数 1 不写 ^1;乘号是 * (左右各一空格)。

复杂度分析
📊 复杂度四宫格
时间复杂度
O(√N)

空间复杂度
O(1)

N 最大
10¹²

试除次数
≤ 10⁶

时间怎么算的?
i 从 2 试到 √t,最多 10⁶ 次
每次找到因子后 t 快速缩小
实际远少于 10⁶ 次
空间都用在哪?
只用几个变量,不需要数组(输出直接拼接)。
✅ 最多约 100 万次试除,瞬间完成。

知识拓展
🔗 常用技巧小抄
// 质因数分解(保存结果)的标准模板
vector<pair<long long,int>> factorize(long long n) {
vector<pair<long long,int>> res;
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) {
int e = 0;
while (n % i == 0) { n /= i; e++; }
res.push_back({i, e});
}
}
if (n > 1) res.push_back({n, 1}); // 剩余大质因子
return res;
}

// 由分解式还原出原数
long long restore(const vector<pair<long long,int>> &f) {
long long r = 1;
for (auto &p : f)
for (int k = 0; k < p.second; k++) r *= p.first;
return r;
}

// 输出格式控制要点
// - 首项前不加分隔符(用 first 标记)
// - 指数为 1 时省略 "^1"
// - 分隔符要用 " * "(左右各一空格)

🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
试除法分解试到 √n + 剩余因子所有质因数分解题
指数形式输出合并相同因子数学表达式输出、格式化题目
首项标记first 变量所有"用分隔符连接多项"的输出
🌟思考题:如果题目要求输出因数的个数(即约数个数 d(N)),该怎么算?(提示:若 N = p₁^e₁ × p₂^e₂ × …,则约数个数 = (e₁+1)(e₂+1)…。因为每个质因数的指数可以独立取 0 ~ eᵢ——分解式一出来,约数个数、约数和都能顺带算出来。)

💻 参考代码
#include &lt;bits/stdc++.h&gt;

using namespace std;



int main() {

    long long n;

    scanf(&quot;%lld&quot;, &amp;n);



    long long t = n;

    bool first = true;          // 是否还没输出过任何因子



    for (long long i = 2; i * i &lt;= t; i++) {

        if (t % i == 0) {

            int e = 0;

            while (t % i == 0) { t /= i; e++; }   // 统计指数并除干净



            if (!first) printf(&quot; * &quot;);             // 非首项前加 &quot; * &quot;

            first = false;



            if (e == 1) printf(&quot;%lld&quot;, i);         // 指数为 1,不写 ^1

            else        printf(&quot;%lld^%d&quot;, i, e);

        }

    }



    // 剩下的大质因子

    if (t &gt; 1) {

        if (!first) printf(&quot; * &quot;);

        printf(&quot;%lld&quot;, t);

    }

    printf(&quot;\n&quot;);

    return 0;

}
💻 参考代码
// 质因数分解(保存结果)的标准模板

vector&lt;pair&lt;long long,int&gt;&gt; factorize(long long n) {

    vector&lt;pair&lt;long long,int&gt;&gt; res;

    for (long long i = 2; i * i &lt;= n; i++) {

        if (n % i == 0) {

            int e = 0;

            while (n % i == 0) { n /= i; e++; }

            res.push_back({i, e});

        }

    }

    if (n &gt; 1) res.push_back({n, 1});      // 剩余大质因子

    return res;

}



// 由分解式还原出原数

long long restore(const vector&lt;pair&lt;long long,int&gt;&gt; &amp;f) {

    long long r = 1;

    for (auto &amp;p : f)

        for (int k = 0; k &lt; p.second; k++) r *= p.first;

    return r;

}



// 输出格式控制要点

// - 首项前不加分隔符(用 first 标记)

// - 指数为 1 时省略 &quot;^1&quot;

// - 分隔符要用 &quot; * &quot;(左右各一空格)
B3969B-smooth 数2024-03 · 素数判断 / 线性筛法
素数判断线性筛法
📝 题目描述
小杨同学想寻找一种名为 B -smooth 数的正整数。

如果一个正整数的最大质因子不超过 B ,则该正整数为 B -smooth 数。小杨同学想知道,对于给定的 n 和 B ,有多少个不超过 n 的 B -smooth 数。

⌨️ 输入格式
第一行包含两个正整数 n 和 B ,含义如题面所示。
🖨 输出格式
输出一个非负整数,表示不超过 n 的 B -smooth 数的数量。
🔎 样例
#输入输出
1
10 3
7
📌 说明 / 数据范围
样例解释
在不超过 10 的正整数中,3-smooth 数有 {1,2,3,4,6,8,9},共 7 个。

数据规模与约定
| 子任务 | 得分 | n ≤q | B |
| :-: | :-: | :-: | :-: |
| 1 | 30 | 10^3 | 1 ≤q B ≤q 10^3 |
| 2 | 30 | 10^6 | \sqrt n ≤q B ≤q 10^6 |
| 3 | 40 | 10^6 | 1 ≤q B ≤q 10^6 |

对全部的测试数据,保证 1 ≤q n, B ≤q 10^6。

💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
题目拆解
📝 题目原文
若一个正整数的最大质因子不超过 B,则称它为 B-smooth 数。
给定 n 和 B,求不超过 n 的 B-smooth 数有多少个。
💡人话翻译:直接求"最大质因子"有点绕,换个角度——反过来标记"不合格的数":凡是含有大于 B 的质因子的数都不是 B-smooth 数。所以先筛出所有质数,再把每个大于 B 的质数的所有倍数标记为不合格,剩下的就是答案。

🔍 关键词提取
B-smooth质因子埃氏筛反向标记
已知条件
项目说明
输入两个正整数 n、B
输出不超过 n 的 B-smooth 数的个数
数据范围1 ≤ n, B ≤ 10⁶
定义最大质因子 ≤ B
特例1 是 B-smooth 数(没有质因子)
需要解决的问题
怎么判断一个数"所有质因子 ≤ B"?等价于"它不含任何 > B 的质因子"
反向标记怎么做?先筛出 ≤ n 的所有质数;对每个质数 p > B,把 p, 2p, 3p, … 都标记为不合格
1 算不算?算——1 没有质因子,"最大质因子不超过 B"空真成立;样例里的 7 个数就包含 1

思维导图
🔍 反向标记大质因子的倍数

🧠 定义转化
最大质因子 ≤ B
⟺ 不含任何 > B 的质因子
改判为"标记不合格的数"
剩下的即答案

📊 筛质数
埃氏筛出 ≤ n 的质数
再对 p > B 处理
p 的所有倍数标记不合格
调和级数复杂度

✅ 统计
合格 = 未被标记
1 也算合格
遍历 1 ~ n 计数
输出个数

⚠️ 易错点
忘记 1 算 B-smooth
B ≥ n 时全部合格(可直接输出 n)
用试除法逐个分解(会超时)
只标记 p 本身忘记倍数

样例手算推导
🧮 样例:n = 10,B = 3,答案 7
先筛出 ≤ 10 的质数,再对 > 3 的质数标记倍数。
1
筛出 ≤ 10 的质数
2, 3, 5, 7
质数:2、3、5、7

2
对 p = 5(> B = 3)标记倍数
5, 10 被标记为不合格
20 超出范围不管
不合格:5、10

3
对 p = 7(> B = 3)标记倍数
7 被标记为不合格
14 超出范围
不合格:5、7、10

数质因数分解最大质因子≤ B = 3?合格
1(无)—✅(空真)是
222✅是
333✅是
42²2✅是
555❌否
62 × 33✅是
777❌否
82³2✅是
93²3✅是
102 × 55❌否
合格的有 1、2、3、4、6、8、9 共 7 个 ✓
🔑注意 1 的处理:1 没有质因子,"最大质因子不超过 B"对它空真成立——所以 1 算 B-smooth。这一点在样例里得到确认:7 个数中包含 1。很多同学会漏掉 1,白白丢分。

🧮 两个极端的边界
情形结果原因
B ≥ n答案 = n所有 ≤ n 的数的质因子都 ≤ n ≤ B
B = 1答案 = 1只有 1 合格(2 的最小质因子是 2 > 1)
n = 1答案 = 1只有 1
n = 10, B = 10答案 = 10全部合格
⚠️关于 B = 1 的验证:任何大于 1 的整数都有至少一个质因子,而最小的质因子是 2 > 1,所以除 1 以外全不合格。这可以用来自测代码的边界处理。

解法对比
⚔️ 解法对比
🟢 反向标记(推荐) 推荐
筛出质数,把 > B 的质数的倍数标为不合格,统计剩余
时间 O(n log log n)
n = 10⁶ 时约 3 × 10⁶
代码 20 行
统一处理所有数
💡复杂度估算:标记量是 Σp>B n/p。最坏情况 B = 1 时,约 Σp≤n n/p ≈ n ln ln n ≈ 3 × 10⁶。完全够快。

🟠 对每个数分解质因数
逐个求最大质因子,判断是否 ≤ B
每个数 O(√x)
总数约 10⁶ × 10³ = 10⁹
可能超时
代码直观但慢
⚠️对比量级:逐个数分解需要 10⁹ 级别,而反向标记只需 3 × 10⁶ 级别——差了三个数量级。这正是"筛法式批量处理胜过"逐个处理"的典型例子。

📈 性能对比
方案运算量(n = 10⁶)可行性
反向标记约 3 × 10⁶✅ 稳过
逐个分解约 10⁹❌ 可能超时

算法流程图
开始读入 n、B;bad[1..n] 全为 false用埃氏筛找出 1 ~ n 的所有质数遍历每个质数 pp 是否大于 B?是 ✓把 p 的所有倍数标记为 bad否 ✗跳过统计 1 ~ n 中未被标记的数,输出个数结束处理下一个质数← 左右滑动查看完整流程图
动手算一算
🔍 B-smooth 计数

输入 n 和 B,程序会标记不合格的数并统计 B-smooth 数。

输入 n 和 B


算一下!
随机出题


结果会显示在这里

点按钮开始 →

代码精讲
💻 完整 C++ 代码
include <bits/stdc++.h>
using namespace std;

const int MAXN = 1000005;

bool isP[MAXN]; // 是否为质数
bool bad[MAXN]; // 是否不合格(含有 > B 的质因子)

int main() {
int n, B;
scanf("%d %d", &n, &B);

// 埃氏筛:找出 1 ~ n 的所有质数
for (int i = 0; i <= n; i++) isP[i] = true;
isP[0] = isP[1] = false;
for (int i = 2; (long long)i * i <= n; i++)
if (isP[i])
for (int j = i * i; j <= n; j += i) isP[j] = false;

// 对每个大于 B 的质数,标记它的所有倍数
for (int p = 2; p <= n; p++) {
if (isP[p] && p > B) {
for (int m = p; m <= n; m += p)
bad[m] = true;
}
}

// 统计合格(含 1)
int ans = 0;
for (int i = 1; i <= n; i++)
if (!bad[i]) ans++;

printf("%d\n", ans);
return 0;
}
🔑为什么标记倍数时从 m = p 开始(而不是 p * p)?因为在这里我们要标记 p 本身——p > B 说明 p 的最大质因子是 p,本身就不合格。这与"埃氏筛标记合数"不同(那里 p 本身是质数,所以从 p² 开始)。两处起点不同,务必分清。

📖 关键几行怎么看
代码作用为什么这样写
isP[0] = isP[1] = false筛法特殊值0 和 1 不是质数
if (isP[p] && p > B)筛选条件只处理"大于 B 的质数"
for (m = p; m <= n; m += p)标记倍数从 p 开始(p 本身也不合格)
for (i = 1; i <= n; i++) if (!bad[i]) ans++统计从 1 开始,让 1 被计入
⚠️三个坑:① 统计时从 2 开始(漏掉 1);② 标记倍数从 p * p 开始(漏掉 p 本身);③ 用逐个分解代替筛法(可能超时)。

边界测试 &amp; 易错点
🧪 边界测试用例表
写完程序后,用这些数据自查一遍:
输入答案考察点
10 37题面样例:{1,2,3,4,6,8,9}
1 11只有 1
5 11B = 1 时只有 1 合格
20 252-smooth 数:1、2、4、8、16
10 1010B ≥ n 时全部合格
100 5运行验证更大的规模
✅自查清单:① 1 算进去了吗?② 标记倍数从 p 开始吗?③ 用的是筛法吗?

🚨 易错点清单
⚠️漏掉 1:1 没有质因子,"最大质因子 ≤ B"空真成立,所以 1 是 B-smooth 数。

⚠️标记起点错:应写成 for (m = p; ...),因为 p 本身(> B)也不合格。

⚠️逐个分解:复杂度约 10⁹,可能超时,要用筛法批量标记。

复杂度分析
📊 复杂度四宫格
时间复杂度
O(n log log n)

空间复杂度
O(n)

n 最大
10⁶

标记量
约 3 × 10⁶

时间怎么算的?
埃氏筛:O(n log log n)
标记倍数:Σp>B n/p,最坏约 n ln ln n
统计:O(n)
合计约 3 × 10⁶
空间都用在哪?
两个长度为 n + 1 的布尔数组。
✅ 约几百万次操作,瞬间完成。相比逐个分解的 10⁹,快了三个数量级。

知识拓展
🔗 常用技巧小抄
// 反向标记模板:从"满足定义"转化为"排除不合格"
for (int p = 2; p <= n; p++)
if (isP[p] && p > B)
for (int m = p; m <= n; m += p) bad[m] = true;

// 另一种写法:直接求每个数的最大质因子(线性筛)
int mpf[N]; // 最大质因子
for (int i = 2; i <= n; i++) {
if (!mpf[i]) { // i 是质数
for (int j = i; j <= n; j += i) mpf[j] = i;
}
}
// 然后 mpf[i] <= B 即为 B-smooth

// C++17 求质因数分解(配合试除)
// 用 __gcd、__builtin_popcount 等内置函数提高效率

// 复杂度速记
// 埃氏筛:O(n log log n)
// Σ_{p <= n} n/p ≈ n ln ln n
// 逐个试除分解:O(n√n)

🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
反向标记改判为"排除不合格"含"最大/最小质因子"约束的计数题
筛法批量处理调和级数复杂度所有涉及"倍数的性质"的统计
1 的特殊性没有质因子,空真成立所有质因子相关定义都要留意
🌟思考题:如果题目改成"求最大质因子恰好为 B 的数的个数",该怎么算?(提示:用容斥——"最大质因子 ≤ B 的个数" 减去 "最大质因子 ≤ B−1 的个数",(注意 B 需要是质数,否则答案为 0)。把"恰好"转化为"两个前缀相减",是很常用的计数技巧。)

💻 参考代码
#include &lt;bits/stdc++.h&gt;

using namespace std;



const int MAXN = 1000005;



bool isP[MAXN];      // 是否为质数

bool bad[MAXN];      // 是否不合格(含有 &gt; B 的质因子)



int main() {

    int n, B;

    scanf(&quot;%d %d&quot;, &amp;n, &amp;B);



    // 埃氏筛:找出 1 ~ n 的所有质数

    for (int i = 0; i &lt;= n; i++) isP[i] = true;

    isP[0] = isP[1] = false;

    for (int i = 2; (long long)i * i &lt;= n; i++)

        if (isP[i])

            for (int j = i * i; j &lt;= n; j += i) isP[j] = false;



    // 对每个大于 B 的质数,标记它的所有倍数

    for (int p = 2; p &lt;= n; p++) {

        if (isP[p] &amp;&amp; p &gt; B) {

            for (int m = p; m &lt;= n; m += p)

                bad[m] = true;

        }

    }



    // 统计合格(含 1)

    int ans = 0;

    for (int i = 1; i &lt;= n; i++)

        if (!bad[i]) ans++;



    printf(&quot;%d\n&quot;, ans);

    return 0;

}
💻 参考代码
// 反向标记模板:从&quot;满足定义&quot;转化为&quot;排除不合格&quot;

for (int p = 2; p &lt;= n; p++)

    if (isP[p] &amp;&amp; p &gt; B)

        for (int m = p; m &lt;= n; m += p) bad[m] = true;



// 另一种写法:直接求每个数的最大质因子(线性筛)

int mpf[N];                 // 最大质因子

for (int i = 2; i &lt;= n; i++) {

    if (!mpf[i]) {          // i 是质数

        for (int j = i; j &lt;= n; j += i) mpf[j] = i;

    }

}

// 然后 mpf[i] &lt;= B 即为 B-smooth



// C++17 求质因数分解(配合试除)

// 用 __gcd、__builtin_popcount 等内置函数提高效率



// 复杂度速记

// 埃氏筛:O(n log log n)

// Σ_{p &lt;= n} n/p ≈ n ln ln n

// 逐个试除分解:O(n√n)
P10720小杨的幸运数字2024-06 · 数论
数论
📝 题目描述
小杨认为他的幸运数字应该恰好有两种不同的质因子,例如,12=2× 2× 3 的质因子有 2,3,恰好为两种不同的质因子,因此 12 是幸运数字,而 30=2×3×5 的质因子有 2,3,5,不符合要求,不为幸运数字。

小杨现在有 n 个正整数,他想知道每个正整数是否是他的幸运数字。

⌨️ 输入格式
第一行包含一个正整数 n,代表正整数个数。

之后 n 行,每行一个正整数。

🖨 输出格式
输出 n 行,对于每个正整数,如果是幸运数字,输出 1,否则输出 0。
🔎 样例
#输入输出
1
3
7
12
30
0
1
0
📌 说明 / 数据范围
样例解释
7 的质因子有 7,只有一种。

12 的质因子有 2,3,恰好有两种。

30 的质因子有 2,3,5,有三种。

数据范围
子任务编号|数据点占比|n|正整数值域
:-:|:-:|:-:|:-:
1|40%|≤q 100|≤q 10^5
2|60%|≤q 10^4|≤q 10^6

对于全部数据,保证有 1≤q n≤q 10^4,每个正整数 a_i 满足 2≤q a_i≤q 10^6。

💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
题目拆解
📝 题目原文
如果一个正整数的质因子恰好有两种不同的,则称为幸运数字。
例:12 = 2 × 2 × 3,质因子是 2 和 3,恰好两种 → 是幸运数字;30 = 2 × 3 × 5 有三种质因子 → 不是。
给定 n 个正整数,逐个判断,是输出 1,不是输出 0。
💡人话翻译:把每个数做质因数分解,去重后数一数有几种不同的质数,恰好等于 2 就输出 1。注意"不同的质因子"——12 = 2² × 3 里 2 出现两次,但只算一种。

🔍 关键词提取
质因数分解去重计数试除法边界处理
已知条件
项目说明
输入第一行 n;随后 n 行每行一个正整数
输出每行一个 0 或 1
数据范围n ≤ 10⁴
数值范围≤ 10⁶
判定不同质因子个数恰好为 2
需要解决的问题
怎么分解质因数?从 2 试除到 √x,每找到一个因子就把它除干净并计数
为什么除干净后不用再判质数?因为小的因子已经被除完了,剩下的因子必然是质数
有什么边界?1 没有质因子(0 种);质数只有 1 种;分解完若 x > 1,还要再计一种

思维导图
🔬 分解 + 去重计数

📥 读入
n ≤ 10⁴
每行一个数
值 ≤ 10⁶
逐个独立判断

🔬 试除分解
i 从 2 试到 √x
若 x % i == 0
把 i 除干净并计数 +1
循环结束后若 x > 1 再计一种

✅ 判定
不同质因子个数 == 2
输出 1
否则输出 0
注意 1 的情况

⚠️ 易错点
忘记"除干净"导致重复计数
漏掉最后剩下的 x > 1
忘了质数只有一种因子
分解时改了原数导致后续出错

样例手算推导
🧮 样例:7、12、30
逐个分解并统计不同的质因子个数。
1
7
i 从 2 试到 √7 ≈ 2.6,即 i = 2
7 % 2 ≠ 0,试除结束
此时 x = 7 > 1 → 再计一种质因子 7
不同质因子:{7},共 1 种
❌ 输出 0

2
12
i = 2:12 % 2 == 0 → 计一种(2),x 除干净变 3
i = 3:3 % 3 == 0 → 计一种(3),x 变 1
x = 1,不再有剩余
不同质因子:{2, 3},共 2 种
✅ 输出 1

3
30
i = 2:30 % 2 == 0 → 计一种(2),x 变 15
i = 3:15 % 3 == 0 → 计一种(3),x 变 5
i = 4:5 % 4 ≠ 0;i = 5 时 5 × 5 > 5,循环结束
x = 5 > 1 → 再计一种(5)
不同质因子:{2, 3, 5},共 3 种
❌ 输出 0

数分解不同质因子个数输出
77{7}10
122² × 3{2, 3}21
302 × 3 × 5{2, 3, 5}30
输出 0、1、0 ✓

🧮 几个边界情形
数分解不同质因子个数输出
1(无质因子)00
2210
42²10
62 × 321
362² × 3²21
2 × 3 × 5 = 30三个质数30
10000002⁶ × 5⁶21
⚠️两个容易写错的点:① 必须"除干净"——比如 12 里因子 2 出现两次,如果只计数不计次、没除干净,后面还会重复遇到 2,导致重复计数;② 循环结束后若 x > 1,要再计一种——比如 7、30 这种情况,剩下的大质因子在试除范围内找不到,必须单独统计。

解法对比
⚔️ 解法对比
🟢 逐个数试除(推荐) 推荐
对每个数从 2 试除到 √x,统计不同质因子个数
单次 O(√x)
x ≤ 10⁶ 时最多试 1000 次
n = 10⁴ 时约 10⁷ 次
代码 15 行
💡量级估算:n ≤ 10⁴、x ≤ 10⁶,每个数试除到 √x ≈ 1000,总共约 10⁷ 次运算,完全可以接受。

🟠 预处理最小质因子表
先筛出 1 ~ 10⁶ 的最小质因子,之后分解 O(log x)
预处理 O(10⁶ log log 10⁶)
每次分解更快
代码多 10 行
本题属于锦上添花
⚠️什么时候值得:如果 n 很大(比如 10⁶)或数值范围更大,筛法能显著加速。本题直接试除已经够快。

📈 性能对比
方案总运算量(n = 10⁴)代码量
试除法约 10⁷约 15 行
最小质因子筛约 10⁶ + 10⁵约 25 行

算法流程图
开始读入 n处理每个数 xcnt = 0;i 从 2 试到 i × i ≤ xx % i == 0 吗?是 ✓cnt 加 1,把 i 除干净否 ✗i 加 1 继续循环结束后 x 是否大于 1?是 ✓cnt 加 1(剩下一个大质因子)否 ✗不处理输出 cnt == 2 ? 1 : 0结束还有数字 → 继续分解← 左右滑动查看完整流程图
动手算一算
🔬 幸运数字判定器

每行输入一个正整数,程序会分解质因数并判断是否恰好有两种不同质因子。

输入正整数(每行一个)7
12
30
36
1


算一下!
随机出题


结果会显示在这里

点按钮开始 →

代码精讲
💻 完整 C++ 代码
include <bits/stdc++.h>
using namespace std;

int main() {
int n;
scanf("%d", &n);

while (n--) {
int x;
scanf("%d", &x);

int cnt = 0; // 不同的质因子个数
for (int i = 2; (long long)i * i <= x; i++) {
if (x % i == 0) {
cnt++; // i 是一个新的质因子
while (x % i == 0) x /= i; // 把 i 除干净,避免重复计数
}
}
if (x > 1) cnt++; // 剩下的大质因子

printf("%d\n", cnt == 2 ? 1 : 0);
}
return 0;
}
🔑为什么"除干净"这么重要?以 12 为例:若只把 i = 2 计数一次但不除干净,那 x 还是 12;下一轮 i 变化后仍可能再次遇到因子 2,导致同一种质因子被计数多次。写成 while (x % i == 0) x /= i; 就能保证每种质因子只被统计一次。

📖 关键几行怎么看
代码作用为什么这样写
i * i <= x试除上界只需试到 √x;注意 x 在变化,所以条件用当前 x
cnt++计数一种质因子每发现一个新因子就加一
while (x % i == 0) x /= i;除干净保证同一质因子只统计一次
if (x > 1) cnt++;处理剩余剩下的是一个大质因子,别忘了计
⚠️三个坑:① 忘记除干净导致重复计数;② 循环结束后没有 if (x > 1) cnt++;③ 判断写成 cnt >= 2(题目要求恰好两种)。

边界测试 &amp; 易错点
🧪 边界测试用例表
写完程序后,用这些数据自查一遍:
输入答案考察点
70只有一种质因子(7)
121题面样例:2² × 3
300三种质因子:2、3、5
10没有质因子,0 种
20质数,只有一种
36136 = 2² × 3²,不同质因子只有 2、3 两种
1000000110⁶ = 2⁶ × 5⁶,两种质因子
✅自查清单:① 除干净了吗?② 补了剩余因子吗?③ 判断是"恰好等于 2"吗?

🚨 易错点清单
⚠️没除干净:12 里因子 2 出现两次,若不除干净会被重复计数,把 12 误判为 3 种因子。

⚠️漏掉剩余大质因子:如 7、30 的最后一个因子在试除范围内找不到,必须用 if (x > 1) cnt++ 补上。

⚠️判断写成 ≥ 2:题目要求恰好两种。

复杂度分析
📊 复杂度四宫格
时间复杂度
O(n √X)

空间复杂度
O(1)

n 最大
10⁴

X 最大
10⁶

时间怎么算的?
每个数试除到 √x,最多约 1000 次
n = 10⁴ 时约 10⁷ 次运算
每次除法会快速缩小 x,实际更快
空间都用在哪?
只用几个整型变量。
✅ 约千万次运算,C++ 一秒内轻松完成。如果数据范围更大,可改用最小质因子筛法。

知识拓展
🔗 常用技巧小抄
// 质因数分解(统计不同质因子)的标准模板
int distinctPrimeFactors(int x) {
int cnt = 0;
for (int i = 2; (long long)i * i <= x; i++) {
if (x % i == 0) {
cnt++;
while (x % i == 0) x /= i; // 除干净
}
}
if (x > 1) cnt++; // 剩余的大质因子
return cnt;
}

// 如果要统计"总的质因子个数(含重数)"
// 就把 while 里的 cnt++ 移到循环内
int totalPrimeFactors(int x) {
int cnt = 0;
for (int i = 2; (long long)i * i <= x; i++)
while (x % i == 0) { x /= i; cnt++; }
if (x > 1) cnt++;
return cnt;
}

🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
质因数分解试除 + 除干净约数、质因子、gcd/lcm 类题目
去重计数同一质因子只算一次所有涉及"不同质因子"的题
剩余大质因子if (x > 1) cnt++分解模板的必备收尾
🌟思考题:如果题目改成"恰好有 k 种不同质因子",代码要改哪里?(提示:只需把最后的判断从 cnt == 2 改成 cnt == k,其余完全不动。而"恰好 k 个质因子(含重数)"则需要用另一个统计方式——注意区分"不同质因子"和"质因子总个数"这两个概念。)

💻 参考代码
#include &lt;bits/stdc++.h&gt;

using namespace std;



int main() {

    int n;

    scanf(&quot;%d&quot;, &amp;n);



    while (n--) {

        int x;

        scanf(&quot;%d&quot;, &amp;x);



        int cnt = 0;                 // 不同的质因子个数

        for (int i = 2; (long long)i * i &lt;= x; i++) {

            if (x % i == 0) {

                cnt++;               // i 是一个新的质因子

                while (x % i == 0) x /= i;   // 把 i 除干净,避免重复计数

            }

        }

        if (x &gt; 1) cnt++;            // 剩下的大质因子



        printf(&quot;%d\n&quot;, cnt == 2 ? 1 : 0);

    }

    return 0;

}
💻 参考代码
// 质因数分解(统计不同质因子)的标准模板

int distinctPrimeFactors(int x) {

    int cnt = 0;

    for (int i = 2; (long long)i * i &lt;= x; i++) {

        if (x % i == 0) {

            cnt++;

            while (x % i == 0) x /= i;    // 除干净

        }

    }

    if (x &gt; 1) cnt++;                      // 剩余的大质因子

    return cnt;

}



// 如果要统计&quot;总的质因子个数(含重数)&quot;

// 就把 while 里的 cnt++ 移到循环内

int totalPrimeFactors(int x) {

    int cnt = 0;

    for (int i = 2; (long long)i * i &lt;= x; i++)

        while (x % i == 0) { x /= i; cnt++; }

    if (x &gt; 1) cnt++;

    return cnt;

}
B3929小杨的幸运数2023-12 · 二分 / 线性筛法
二分线性筛法
📝 题目描述
小杨认为,所有大于等于 a 的完全平方数都是他的超级幸运数。

小杨还认为,所有超级幸运数的倍数都是他的幸运数。自然地,小杨的所有超级幸运数也都是幸运数。

对于一个非幸运数,小杨规定,可以将它一直 +1,直到它变成一个幸运数。我们把这个过程叫做幸运化。例如,如果 a=4,那么 4 是最小的幸运数,而 1 不是,但我们可以连续对 1 做 3 次 +1 操作,使其变为 4,所以我们可以说, 1 幸运化后的结果是 4。

现在,小杨给出 N 个数,请你首先判断它们是不是幸运数;接着,对于非幸运数,请你将它们幸运化。

⌨️ 输入格式
第一行 2 个正整数 a, N。

接下来 N 行,每行一个正整数 x ,表示需要判断(幸运化)的数。

🖨 输出格式
输出 N 行,对于每个给定的 x ,如果它是幸运数,请输出 lucky,否则请输出将其幸运化后的结果。
🔎 样例
#输入输出
1
2 4 
1 
4 
5 
9
4 
lucky 
8 
lucky
2
16 11 
1 
2 
4 
8 
16 
32 
64 
128 
256 
512
1024
16 
16 
16 
16 
lucky 
lucky 
lucky 
lucky 
lucky 
lucky 
lucky
📌 说明 / 数据范围
样例解释 1

1 虽然是完全平方数,但它小于 a,因此它并不是超级幸运数,也不是幸运数。将其进行 3 次 +1 操作后,最终得到幸运数 4。

4 是幸运数,因此直接输出 lucky。

5 不是幸运数,将其进行 3 次 +1 操作后,最终得到幸运数 8。

9 是幸运数,因此直接输出 lucky。

数据规模

对于 30% 的测试点,保证 a,x ≤ 100,N ≤ 100。

对于 60% 的测试点,保证 a,x ≤ 10^6。

对于所有测试点,保证 a ≤ 1,000,000;保证 N ≤ 2 × 10^5;保证 1 ≤ x ≤ 1,000,001。

💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
题目拆解
📝 题目原文
规定:
超级幸运数:所有 ≥ a 的完全平方数
幸运数:所有超级幸运数的倍数(超级幸运数本身也算)
幸运化:把一个数不断 +1,直到它变成幸运数,得到的那个值
给定 N 个 x,若 x 是幸运数输出 lucky,否则输出幸运化后的结果。
💡人话翻译:分两步——① 预处理:把 1 ~ MAXV 中所有"幸运数"标记出来(对每个超级幸运数 p,把 p 的所有倍数标记);② 预处理"下一个幸运数":从后往前扫一遍,记录每个位置之后最近的幸运数,之后每次询问就能 O(1) 回答。
这是"打表预处理 + O(1) 查询"的经典套路。

🔍 关键词提取
筛法标记倍数后缀最近值离线预处理O(1) 查询
已知条件
项目说明
输入第一行 a、N;随后 N 行每行一个 x
输出每行 lucky 或幸运化结果
数据范围a ≤ 10⁶,N ≤ 2 × 10⁵,x ≤ 10⁶ + 1
超级幸运数完全平方数 k² 且 ≥ a
幸运数超级幸运数的倍数
需要解决的问题
怎么标记所有幸运数?枚举所有 k 使 k² ≥ a,然后把 k² 的所有倍数标记为幸运数
要多大的表?x 最大 10⁶ + 1,而幸运化的结果可能超过它——比如 a = 10⁶ 时最小的超级幸运数是 10⁶,那么 10⁶ + 1 会幸运化成 2 × 10⁶。所以要开到约 2.1 × 10⁶
怎么快速回答"下一个幸运数"?从后往前递推:nxt[i] = lucky[i] ? i : nxt[i+1]

思维导图
🍀 标记幸运数 + 后缀最近

📐 定义链
超级幸运数 = k² ≥ a
幸运数 = 超级幸运数的倍数
幸运化 = 不断 +1 到最近的幸运数
注意:小于 a 的平方数不算

🎨 第一步标记
枚举 k 使 k² ≥ a 且 ≤ MAXV
把 k² 的所有倍数标记
调和级数复杂度
总约 1.6 × MAXV

🔗 第二步后缀
从 MAXV 往前扫
lucky[i] 为真 → nxt[i] = i
否则 nxt[i] = nxt[i+1]
查询 O(1)

⚠️ 易错点
表开太小(幸运化结果会超出 x 上限)
忘记标记超级幸运数自身
把小于 a 的平方数也当超级幸运数
发现 nxt 越界

样例手算推导
🧮 样例 1:a = 2
先找出超级幸运数与幸运数。
1
超级幸运数
所有 ≥ 2 的完全平方数:
2² = 4、3² = 9、4² = 16、5² = 25、…
注意 1² = 1 < 2,所以 1 不是超级幸运数
超级幸运数:4, 9, 16, 25, …

2
幸运数(超级幸运数的倍数)
4 的倍数:4, 8, 12, 16, 20, 24, …
9 的倍数:9, 18, 27, …
16 的倍数:16, 32, …(16 已在 4 的倍数中)
合并后从小到大:4, 8, 9, 12, 16, 18, 20, …
幸运数集合已确定

询问 x是幸运数吗幸运化结果输出
1否不断 +1:2、3 都不是,4 是 → 44
4是—lucky
5否6、7 不是,8 是 → 88
9是—lucky
输出 4、lucky、8、lucky ✓

🧮 样例 2:a = 16
这次 a 较大,最小超级幸运数是 16。
1
超级幸运数
≥ 16 的完全平方数:16, 25, 36, 49, 64, 81, 100, 121, 144, …
注意 9 = 3² < 16,所以 9 不是超级幸运数
超级幸运数:16, 25, 36, …

2
幸运数(从 16 起)
16 的倍数:16, 32, 48, 64, 80, 96, 112, 128, …, 1024, …
25 的倍数:25, 50, 75, 100, …
所以 1 ~ 15 里没有任何幸运数
1 ~ 15 全不是幸运数

询问 x输出说明
1161 ~ 15 都不是幸运数,最近的是 16
216同上
4164 < a=16,虽然是平方数但不合格
816同上
16lucky16 是超级幸运数
32lucky32 = 16 × 2
64lucky64 = 16 × 4
128lucky128 = 16 × 8
256lucky256 = 16 × 16
512lucky512 = 16 × 32
1024lucky1024 = 16 × 64
输出 16、16、16、16、lucky × 7 ✓
⚠️注意 4 这个例子:4 = 2² 确实是完全平方数,但它小于 a = 16,所以不是超级幸运数,自然也不是幸运数,要输出幸运化结果 16。这是本题最容易搞错的地方——"完全平方数"和"超级幸运数"不是一回事。

解法对比
⚔️ 解法对比
🟢 离线打表 + O(1) 查询(推荐) 推荐
标记所有幸运数,再用后缀递推求"下一个幸运数"
预处理 O(MAXV log MAXV)
每次询问 O(1)
N = 2 × 10⁵ 时总耗时极少
代码 25 行
💡为什么能预处理:所有询问的数值范围是固定的(≤ 10⁶ 级别),所以可以一次性把整张表建好,之后每个询问只是查数组。

🟠 每个询问单独暴力 +1 并判定
对每个 x 不断 +1,每次判断是否幸运数
判定单个数的代价高
每次询问可能 +1 很多次
N = 2 × 10⁵ 时 必然超时
且重复计算严重
⚠️注意最坏情况:a = 10⁶ 时,x = 1 要 +1 到 10⁶ 才成为幸运数——单次询问就要 10⁶ 步,乘以 2 × 10⁵ 个询问就是 2 × 10¹¹,必然超时。

📈 性能对比
方案总复杂度可行性
打表 + 后缀O(MAXV log MAXV + N)✅ 稳过
逐次暴力 +1最坏 O(N × MAXV)❌ 超时

算法流程图
开始读入 a、N;lucky[1..MAXV] 全为 false枚举 k,使 k² ≥ a 且 k² ≤ MAXV把 k² 以及它的所有倍数标记为 lucky从 MAXV 往前扫:nxt[i] = lucky[i] ? i : nxt[i+1]处理每个询问 xlucky[x] ? 输出 lucky : 输出 nxt[x]结束处理下一个询问← 左右滑动查看完整流程图
动手算一算
🍀 幸运数判定器

第一行输入 a 和 N,随后 N 行输入要判断的数。

输入数据2 4
1
4
5
9


算一下!
随机出题


结果会显示在这里

点按钮开始 →

代码精讲
💻 完整 C++ 代码
include <bits/stdc++.h>
using namespace std;

const int MAXV = 2100000; // 需略大于 2 × 10^6

bool lucky[MAXV + 2];
int nxt[MAXV + 2];

int main() {
int a, N;
scanf("%d %d", &a, &N);

// 第一步:标记所有幸运数
// 超级幸运数 = 所有 k^2 且 k^2 >= a
int k = 1;
while ((long long)k * k < a) k++; // 找到最小的 k 使 k^2 >= a
for (; (long long)k * k <= MAXV; k++) {
int p = k * k; // p 是超级幸运数
for (int m = p; m <= MAXV; m += p) // p 的所有倍数也是幸运数
lucky[m] = true;
}

// 第二步:从后往前求"最近的下一个幸运数"
nxt[MAXV + 1] = 0; // 0 表示不存在
for (int i = MAXV; i >= 1; i--)
nxt[i] = lucky[i] ? i : nxt[i + 1];

// 回答询问
while (N--) {
int x;
scanf("%d", &x);
if (lucky[x]) printf("lucky\n");
else printf("%d\n", nxt[x]);
}
return 0;
}
🔑while ((long long)k * k < a) k++; 在做什么?它在找最小的 k 使 k² ≥ a——这正好是最小的超级幸运数。注意用 (long long) 强制转换,因为 k * k 可能接近 int 上限。不能从 k = 1 开始标记!否则会把小于 a 的平方数(如 a=16 时的 4、9)错误地标记为超级幸运数。

📖 关键几行怎么看
代码作用为什么这样写
while ((long long)k*k < a) k++;起点跳过所有小于 a 的平方数
for (m = p; m <= MAXV; m += p)标记倍数超级幸运数的倍数都是幸运数
nxt[i] = lucky[i] ? i : nxt[i+1];后缀递推从后往前,一次扫描得到所有"最近幸运数"
if (lucky[x])回答是则 lucky,否则输出 nxt[x]
⚠️三个坑:① k 从 1 开始(应跳过 k² < a);② 表开得太小(a = 10⁶ 时 x = 10⁶+1 会幸运化成 2 × 10⁶);③ 忘记标记超级幸运数自身(循环从 m = p 开始保证包含)。

边界测试 &amp; 易错点
🧪 边界测试用例表
写完程序后,用这些数据自查一遍:
输入答案考察点
2 4
1 / 4 / 5 / 94
lucky
8
lucky题面样例 1
16 11
1 2 4 8 16 32 64 128 256 512 102416
16
16
16
lucky × 7题面样例 2
1 2
1 / 2lucky
luckya = 1 时 1 也是超级幸运数
4 3
2 / 3 / 44
4
luckya = 4 时 1、2、3 都要幸运化到 4
✅自查清单:① 跳过了 k² < a 吗?② 表够大吗?③ 后缀递推是从后往前吗?

🚨 易错点清单
⚠️k 从 1 开始标记:应先用 while (k*k < a) k++; 跳过小平方数,否则 4、9 等会被误判。

⚠️表开小:幸运化结果可能超过 x 的上限,MAXV 要开到约 2.1 × 10⁶。

⚠️逐次暴力 +1:最坏会到 2 × 10¹¹ 次运算,必须打表。

复杂度分析
📊 复杂度四宫格
预处理时间
O(MAXV log MAXV)

每次询问
O(1)

空间
O(MAXV)

MAXV
约 2.1 × 10⁶

时间怎么算的?
标记倍数:Σ over p=k² 的 MAXV/p,约 1.6 × MAXV 量级
后缀递推:O(MAXV)
每次询问 O(1)
总预处理约 5 × 10⁶ 次操作
空间都用在哪?
一个布尔数组 + 一个整数数组,各约 2.1 × 10⁶。
✅ 预处理约几百万次操作,瞬间完成;N = 2 × 10⁵ 次询问都是 O(1)。

知识拓展
🔗 常用技巧小抄
// "打表 + 后缀最近值"通用套路
// 第一步:标记所有满足条件的数
for (每个"基元" p) for (int m = p; m <= MAXV; m += p) good[m] = true;

// 第二步:从后往前求"最近的下一个满足条件的数"
nxt[MAXV + 1] = INF;
for (int i = MAXV; i >= 1; i--) nxt[i] = good[i] ? i : nxt[i + 1];

// 第三步:O(1) 回答
int ans = good[x] ? x : nxt[x];

// 找"最小的 k 使 k^2 >= a"
int k = 1; while ((long long)k * k < a) k++; // 或 k = ceil(sqrt(a))

// 类似的"筛法标记倍数"套路
// - 埃氏筛:标记合数
// - 本题:标记超级幸运数的倍数

🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
筛法标记倍数把基元的倍数全部标记质数筛、倍数标记类问题
后缀最近值从后往前递推求"最近的下一个满足条件的数"
打表 + O(1) 查询用空间换时间询问多、值域固定的题目
🌟思考题:如果题目改成"幸运化时是不断 −1"(往下找最近的幸运数),要改哪里?(提示:把后缀递推改成前缀递推——prv[i] = lucky[i] ? i : prv[i-1],从左往右扫一遍即可。"往前找"用前缀、"往后找"用后缀,这是同一个套路的两面。)

💻 参考代码
#include &lt;bits/stdc++.h&gt;

using namespace std;



const int MAXV = 2100000;      // 需略大于 2 × 10^6



bool lucky[MAXV + 2];

int nxt[MAXV + 2];



int main() {

    int a, N;

    scanf(&quot;%d %d&quot;, &amp;a, &amp;N);



    // 第一步:标记所有幸运数

    // 超级幸运数 = 所有 k^2 且 k^2 &gt;= a

    int k = 1;

    while ((long long)k * k &lt; a) k++;          // 找到最小的 k 使 k^2 &gt;= a

    for (; (long long)k * k &lt;= MAXV; k++) {

        int p = k * k;                          // p 是超级幸运数

        for (int m = p; m &lt;= MAXV; m += p)      // p 的所有倍数也是幸运数

            lucky[m] = true;

    }



    // 第二步:从后往前求&quot;最近的下一个幸运数&quot;

    nxt[MAXV + 1] = 0;                          // 0 表示不存在

    for (int i = MAXV; i &gt;= 1; i--)

        nxt[i] = lucky[i] ? i : nxt[i + 1];



    // 回答询问

    while (N--) {

        int x;

        scanf(&quot;%d&quot;, &amp;x);

        if (lucky[x]) printf(&quot;lucky\n&quot;);

        else          printf(&quot;%d\n&quot;, nxt[x]);

    }

    return 0;

}
💻 参考代码
// &quot;打表 + 后缀最近值&quot;通用套路

// 第一步:标记所有满足条件的数

for (每个&quot;基元&quot; p) for (int m = p; m &lt;= MAXV; m += p) good[m] = true;



// 第二步:从后往前求&quot;最近的下一个满足条件的数&quot;

nxt[MAXV + 1] = INF;

for (int i = MAXV; i &gt;= 1; i--) nxt[i] = good[i] ? i : nxt[i + 1];



// 第三步:O(1) 回答

int ans = good[x] ? x : nxt[x];



// 找&quot;最小的 k 使 k^2 &gt;= a&quot;

int k = 1; while ((long long)k * k &lt; a) k++;   // 或 k = ceil(sqrt(a))



// 类似的&quot;筛法标记倍数&quot;套路

// - 埃氏筛:标记合数

// - 本题:标记超级幸运数的倍数
B4050挑战怪物2024-09 · 贪心 / 数论 / 枚举
贪心数论枚举
📝 题目描述
小杨正在和一个怪物战斗,怪物的血量为 h,只有当怪物的血量恰好为 0 时小杨才能够成功击败怪物。

小杨有两种攻击怪物的方式:
- 物理攻击。假设当前为小杨第 i 次使用物理攻击,则会对怪物造成 2^{i - 1} 点伤害。
- 魔法攻击。小杨选择任意一个质数 x( 不能超过怪物当前血量),对怪物造成 x 点伤害。由于小杨并不擅长魔法,他只能使用至多一次魔法攻击。

小杨想知道自己能否击败怪物,如果能,小杨想知道自己最少需要多少次攻击。

⌨️ 输入格式
本题单个测试点内有多组测试数据。第一行包含一个正整数 t,代表测试用例组数。

接下来是 t 组测试用例。对于每组测试用例,只有一行一个整数 h,代表怪物血量。

🖨 输出格式
对于每组测试用例,如果小杨能够击败怪物,输出一个整数,代表小杨需要的最少攻击次数,如果不能击败怪物,
输出 -1。
🔎 样例
#输入输出
1
3
6
188
9999
2
4
-1
📌 说明 / 数据范围
样例 1 解释
对于第一组测试用例,一种可能的最优方案为,小杨先对怪物使用魔法攻击,选择质数 5 造成 5 点伤害,之后对怪
物使用第 1 次物理攻击,造成 2^{1 - 1} = 1 点伤害,怪物血量恰好为 0,小杨成功击败怪物。

数据规模与约定
| 子任务编号 | 分数占比 | t | h |
| :-: | :-: | :-: | :-: |
| 1 | 20% | ≤q 5 | ≤q 10 |
| 2 | 20% | ≤q 10 | ≤q 100 |
| 3 | 60% | ≤q 10 | ≤q 10^5 |

对于全部的测试数据,保证 1 ≤q t ≤q 10,1 ≤q h ≤q 10^5。

⚠️ 这道题美力程题解库暂未收录文字题解。建议按考点自己先推一遍:
· 先排序,再按「每步取最优」推一遍,验证有没有反例。
· 定范围、写条件、逐个试;能推出的量就别多写一层循环。
写完后可到洛谷 B4050 对照题解。
B4070奇妙数字2024-12 · 数学 / 数论
数学数论
📝 题目描述
小杨认为一个数字 x 是奇妙数字当且仅当 x=p^a,其中 p 为任意质数且 a 为正整数。例如,8=2^3,所以 8 是奇妙的,而 6 不是。

对于一个正整数 n,小杨想要构建一个包含 m 个奇妙数字的集合 {x_1,x_2,…,x_m},使其满足以下条件:
- 集合中不包含相同的数字。
- x_1× x_2× …× x_m 是 n 的因子(即 x_1,x_2,…,x_m 这 m 个数字的乘积是 n 的因子)。

小杨希望集合包含的奇妙数字尽可能多,请你帮他计算出满足条件的集合最多包含多少个奇妙数字。

⌨️ 输入格式
第一行包含一个正整数 n,含义如题面所示。
🖨 输出格式
输出一个正整数,代表满足条件的集合最多包含的奇妙数字个数。
🔎 样例
#输入输出
1
128
3
📌 说明 / 数据范围
样例解释
关于本样例,符合题意的一个包含 3 个奇妙数字的集合是 {2,4,8}。首先,因为 2=2^1,4=2^2,8=2^3,所以 2,4,8 均为奇妙数字。同时,2× 4× 8=64 是 128 的的因子。

由于无法找到符合题意且同时包含 4 个奇妙数字的集合,因此本样例的答案为 3。

数据范围
对于 100% 的数据,保证 2≤ n≤ 10^{12}。

| 子任务编号 | 得分占比 | n |
| :--: | :--: | :--: |
| 1 | 20% | ≤ 10 |
| 2 | 20% | ≤ 1 000 |
| 3 | 60% | ≤ 10^{12} |

💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
题目拆解
📝 题目原文
若 x = p^a(p 为质数、a 为正整数),则称 x 是奇妙数字。如 8 = 2³ 是奇妙的,而 6 不是。
对于一个正整数 n,要构造一个包含 m 个奇妙数字的集合 {x₁, x₂, …, x_m},满足:
集合中不含相同的数字
x₁ × x₂ × … × x_m 是 n 的因子
求 m 的最大值。
💡人话翻译:把 n 分解质因数后,每个质数可以独立处理——因为不同质数的幂之间互不影响。对某个指数为 e 的质数 p,我们能选的奇妙数字是 p¹, p², p³, …(各不相同),它们的指数之和不能超过 e。为了让个数最多,就取 1 + 2 + 3 + … + k ≤ e 的最大 k。答案就是各质数贡献之和。

🔍 关键词提取
质因数分解独立子问题等差数列求和贪心
已知条件
项目说明
输入一个正整数 n
输出集合最多能包含的奇妙数字个数
奇妙数字p^a(p 质数,a ≥ 1)
约束 1集合内元素互不相同
约束 2所有元素的乘积整除 n
需要解决的问题
为什么可以分质数独立算?因为乘积整除 n 意味着每个质数的总指数不能超过 n 中的指数,而不同质数之间完全不干扰
每种质数能选几个?选 p¹, p², …, p^k 最省指数(指数和 1+2+…+k 最小);所以 k 是使 k(k+1)/2 ≤ e 的最大值
为什么取最小的那些指数?因为我们要个数最多,用最小的互异正整数(1,2,3,…)最省预算

思维导图
🔢 分质数独立 + 取最小指数

🔬 分解
n 分解为 ∏pᵉ
每个质数 p 的指数为 e
不同质数互不干扰
可以分别最大化

🎯 单个质数
可选 p¹、p²、…
要互不相同
指数之和 ≤ e
取 1+2+…+k 使 k 最大

📐 公式
k(k+1)/2 ≤ e
k = 最大的可行值
答案 = Σ k(eᵢ)
用循环累加即可

⚠️ 易错点
以为要输出乘积(其实是个数)
忽略"互不相同"
用 int 处理大 n
忘了每个质数至少可以取 1 个

样例手算推导
🧮 样例:n = 128,答案 3
128 = 2⁷,只有一个质数 2,指数 e = 7。
1
可行性分析
可选的奇妙数字:2, 4, 8, 16, 32, …(即 2¹, 2², …)
选 k 个的话,指数之和至少是 1 + 2 + … + k = k(k+1)/2
要求这个和 ≤ 7
求最大的 k

2
逐个试
k = 3 时:1 + 2 + 3 = 6 ≤ 7 ✅
k = 4 时:1 + 2 + 3 + 4 = 10 > 7 ❌
所以最多取 3 个
✅ k = 3

3
构造一组方案
取 {2, 4, 8} = {2¹, 2², 2³}
乘积 = 2^(1+2+3) = 2⁶ = 64
64 整除 128 ✓
共 3 个元素
✅ 输出 3

答案 3 ✓
🔑为什么取 2, 4, 8 而不是 2, 4, 8, 16?因为后者指数和是 1+2+3+4 = 10 > 7,乘积 2¹⁰ = 1024 不整除 128。注意 128 = 2⁷,所以任何整除 128 的数的 2 的指数最多是 7。

🧮 几个小例子的验证
用不同 n 检验"分质数独立相加"这个结论。
n分解各质数指数 e各自最大 k答案
22¹e₂ = 1k(1) = 11
62 × 3e₂ = 1, e₃ = 11 + 12
122² × 3e₂ = 2, e₃ = 11 + 12
362² × 3²e = 2, 21 + 12
642⁶e₂ = 6k(6) = 3(1+2+3=6)3
1282⁷e₂ = 7k(7) = 3(6 ≤ 7 < 10)3
10242¹⁰e₂ = 10k(10) = 4(1+2+3+4=10)4
1(无质因子)——0
1
验证 6:为什么答案不是 1?
n = 6 = 2 × 3
质数 2 可以贡献 1 个(取 2)
质数 3 也可以贡献 1 个(取 3)
集合 {2, 3},乘积 6 整除 6 ✓
共 2 个
✅ 答案 2

2
验证 12:为什么也是 2?
n = 12 = 2² × 3,e₂ = 2
k(2):1 ≤ 2 但 1+2 = 3 > 2 → k = 1
质数 3 贡献 1 个
方案 {4, 3}(=2² 和 3¹),乘积 12 整除 12 ✓
共 2 个。能不能 3 个?需 3 个互异奇妙数字,可选 {2,3,4} 乘积 24 ∤ 12 ❌
✅ 答案 2

3
验证 1024
1024 = 2¹⁰
1 + 2 + 3 + 4 = 10 ≤ 10 ✅
1 + 2 + 3 + 4 + 5 = 15 > 10 ❌
所以 k = 4,取 {2, 4, 8, 16}
乘积 2¹⁰ = 1024 恰好整除自身 ✓
✅ 答案 4

⚠️两个容易混淆的点:① 输出的是元素个数,不是乘积;② 每个质数至少可以贡献 1 个(只要它的指数 e ≥ 1,就能取该质数本身),所以"含有不同质数越多,答案越大"这一点要意识到——n = 30 = 2×3×5 的答案就是 3。

解法对比
⚔️ 解法对比
🟢 分质数独立贪心(推荐) 推荐
每个质数取使 1+2+…+k ≤ e 的最大 k,再相加
时间 O(√n)
只需分解质因数
每个质数内层循环极小(k ≈ √(2e))
代码 20 行
💡为什么贪心最优:要在一个质数上塞进尽量多的元素,当然用"指数最小"的那些(即 1, 2, 3, …)。任何其他选择都会用掉更多指数、装下更少的元素。而不同质数相互独立,所以各自取最大再相加就是全局最优。

🟠 枚举所有奇妙数字后背包
把 n 的所有质数幂作为物品,做 0/1 背包
物品数可能较多
约束是"各质数指数分别不超过 e"(多维背包)
无法用一维背包
实现复杂且没必要
⚠️为什么背包不合适:本题的约束是按质数分别限制的,属于多维约束;而由于各维完全独立,直接分解成多个一维子问题分别贪心即可。这体现了"发现变量独立性"的威力。

📈 性能对比
方案复杂度代码量
分质数贪心O(√n)约 20 行
多维背包很高约 50 行

算法流程图
开始读入 n;ans = 0i 从 2 试到 i × i ≤ nn 是否被 i 整除?是 ✓统计指数 e;令 k = 0,当 1+2+…+(k+1) ≤ e 时 k 加 1;ans += k否 ✗i 加 1循环结束后 n 是否大于 1?是 ✓说明剩一个质数,指数为 1,ans += 1否 ✗不处理输出 ans结束i 加 1 继续试除← 左右滑动查看完整流程图
动手算一算
🔢 最多奇妙数字个数

输入一个正整数 n,程序会分解质因数并给出最多能选的奇妙数字个数。

输入 n


算一下!
随机出题


结果会显示在这里

点按钮开始 →

代码精讲
💻 完整 C++ 代码
include <bits/stdc++.h>
using namespace std;

int main() {
long long n;
scanf("%lld", &n);

long long ans = 0;

// 分解质因数
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) {
int e = 0;
while (n % i == 0) { n /= i; e++; } // 统计指数

// 找最大的 k 使 1 + 2 + ... + k <= e
int k = 0, sum = 0;
while (sum + k + 1 <= e) {
k++;
sum += k;
}
ans += k;
}
}

// 剩下的大质因子,指数为 1
if (n > 1) ans += 1;

printf("%lld\n", ans);
return 0;
}
🔑为什么"剩下的 n > 1"只加 1?因为循环结束后如果 n > 1,说明它必是质数,且指数恰好为 1(否则早就在 √n 范围内被除掉了)。指数为 1 时最多只能取 1 个(就是该质数本身),所以直接 ans += 1。这与"质因数分解的收尾"完全一致。

📖 关键几行怎么看
代码作用为什么这样写
while (n % i == 0) { n /= i; e++; }统计指数把该质数的指数算出来
while (sum + k + 1 <= e) { k++; sum += k; }求最大 k保证 1+2+…+k ≤ e 的最大 k
ans += k累加贡献每个质数独立贡献
if (n > 1) ans += 1;收尾剩余大质数指数为 1,贡献 1 个
⚠️三个坑:① 用 int 读入 n(可能较大);② 求 k 时把条件写成 sum + k + 1 <= e 之外的形式导致多算或少算;③ 忘记收尾的 if (n > 1) ans += 1。

边界测试 &amp; 易错点
🧪 边界测试用例表
写完程序后,用这些数据自查一遍:
输入答案考察点
1283题面样例:128 = 2⁷ → k = 3
10无质因子,只能取空集
212 = 2¹ → k = 1
626 = 2 × 3 → 1 + 1 = 2
12212 = 2² × 3 → k(2)=1,k(1)=1,合计 2
64364 = 2⁶ → 1+2+3 = 6 ≤ 6 → k = 3
102441024 = 2¹⁰ → 1+2+3+4 = 10 → k = 4
30330 = 2 × 3 × 5,三个质数各贡献 1
✅自查清单:① 每个质数独立算吗?② k 的条件是 1+2+…+k ≤ e 吗?③ 收尾加 1 了吗?

🚨 易错点清单
⚠️用 int:n 可能较大,应用 long long。

⚠️忘记收尾:循环结束后若 n > 1,该质数指数为 1,贡献 1 个。

⚠️误解为求乘积:题目要的是集合中元素个数。

复杂度分析
📊 复杂度四宫格
时间复杂度
O(√n)

空间复杂度
O(1)

n 范围
可较大

内层循环
k ≈ √(2e)

时间怎么算的?
试除分解:O(√n)
每个质数求 k:循环 k 次,而 k ≈ √(2e),极小
合计 O(√n)
空间都用在哪?
只用几个变量。
✅ 分解是主要开销,瞬间完成。关键洞察是"不同质数相互独立",把问题拆成独立的子问题。

知识拓展
🔗 常用技巧小抄
// 本题核心:按质数独立 + 每个质数取最小指数集合
// 对指数 e,最大 k 满足 k(k+1)/2 <= e
// 直接循环累加(或解方程 k = floor((-1 + sqrt(1 + 8e)) / 2))

int maxK(int e) {
int k = 0, sum = 0;
while (sum + k + 1 <= e) { k++; sum += k; }
return k;
}

// 主流程
long long ans = 0;
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) {
int e = 0;
while (n % i == 0) { n /= i; e++; }
ans += maxK(e);
}
}
if (n > 1) ans += 1;

// 类似"按维度独立"的问题
// - 本题:按质数维度独立
// - 数位 DP:按位维度独立
// - 网格问题:按行列独立

🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
独立维度分解不同质数互不干扰所有"多质数约束"的计数题
最小代价原则用 1,2,3,… 最省预算在预算下最大化"件数"的贪心
等差数列求和1+2+…+k = k(k+1)/2所有涉及"最少用多少个名额"的题
🌟思考题:如果题目改成"集合中元素必须两两互质"(仍然是质数幂,且乘积整除 n),答案会变吗?(提示:不会变——因为同一个质数的不同幂(如 2 和 4)并不互质(gcd = 2 > 1),所以每个质数只能取一个元素;那答案就等于"n 的不同质因子个数"。约束条件的微小变化会完全改变结论,这就是"读题要精"的重要性。)

💻 参考代码
#include &lt;bits/stdc++.h&gt;

using namespace std;



int main() {

    long long n;

    scanf(&quot;%lld&quot;, &amp;n);



    long long ans = 0;



    // 分解质因数

    for (long long i = 2; i * i &lt;= n; i++) {

        if (n % i == 0) {

            int e = 0;

            while (n % i == 0) { n /= i; e++; }   // 统计指数



            // 找最大的 k 使 1 + 2 + ... + k &lt;= e

            int k = 0, sum = 0;

            while (sum + k + 1 &lt;= e) {

                k++;

                sum += k;

            }

            ans += k;

        }

    }



    // 剩下的大质因子,指数为 1

    if (n &gt; 1) ans += 1;



    printf(&quot;%lld\n&quot;, ans);

    return 0;

}
💻 参考代码
// 本题核心:按质数独立 + 每个质数取最小指数集合

// 对指数 e,最大 k 满足 k(k+1)/2 &lt;= e

// 直接循环累加(或解方程 k = floor((-1 + sqrt(1 + 8e)) / 2))



int maxK(int e) {

    int k = 0, sum = 0;

    while (sum + k + 1 &lt;= e) { k++; sum += k; }

    return k;

}



// 主流程

long long ans = 0;

for (long long i = 2; i * i &lt;= n; i++) {

    if (n % i == 0) {

        int e = 0;

        while (n % i == 0) { n /= i; e++; }

        ans += maxK(e);

    }

}

if (n &gt; 1) ans += 1;



// 类似&quot;按维度独立&quot;的问题

// - 本题:按质数维度独立

// - 数位 DP:按位维度独立

// - 网格问题:按行列独立
②编程打卡 · 点一下就能勾选
☑ 已勾选 0 / 7 项点一下条目即可勾选
五级 · 编程 DAY 02

枚举与因数分解(下)

💻 编程题 7 道📚 知识点 枚举与因数分解(下)⏱ 建议用时 205 分钟
①本日知识点 · 枚举与因数分解(下)

本组 7 道题全部来自 GESP 真题,按「枚举与因数分解(下)」归在一起练。题面取洛谷原题(含公式与样例),题解取美力程 GESP 题解库(思路 + 参考代码 + 复杂度)。

P14073数字选取2025-09 · 数学 / 贪心 / 数论
数学贪心数论枚举素数判断线性筛法
📝 题目描述
给定正整数 n,现在有 1,2,…,n 共计 n 个整数。你需要从这 n 个整数中选取一些整数,使得所选取的整数中任意两个不同的整数均互质(也就是说,这两个整数的最大公因数为 1)。请你最大化所选取整数的数量。

例如,当 n=9 时,可以选择 1,5,7,8,9 共计 5 个整数。可以验证不存在数量更多的选取整数的方案。

⌨️ 输入格式
一行,一个正整数 n,表示给定的正整数。
🖨 输出格式
一行,一个正整数,表示所选取整数的最大数量。
🔎 样例
#输入输出
1
6
4
2
9
5
📌 说明 / 数据范围
对于 40% 的测试点,保证 1≤ n≤ 1000。

对于所有测试点,保证 1≤ n≤ 10^5。

💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
题目拆解
📝 题目原文
给定正整数 n,现在有 1, 2, …, n 共 n 个整数。请你从中选取一些整数,使得所选取的任意两个不同整数均互质(即最大公因数为 1)。求最多能选多少个。
例:n = 9 时可以选 1, 5, 7, 8, 9 共 5 个。
💡人话翻译:这题有一个漂亮的结论——答案就是 1 +(1 ~ n 中质数的个数)。因为 1 与任何数互质,而所有质数之间两两互质;并且不可能再多选了,原因是"每个大于 1 的数都要占用一个不同的质因子"。

🔍 关键词提取
互质质数计数上界证明埃氏筛
已知条件
项目说明
输入一个正整数 n
输出最多能选取的整数个数
数据范围1 ≤ n ≤ 10⁵
约束所选集合中任意两个不同的数互质
含 1gcd(1, x) = 1 对任意 x 成立
需要解决的问题
能不能选所有质数?能!质数之间互质,且都与 1 互质
还能加合数吗?任何合数 x ≤ n 的最小质因子 p 也 ≤ n,而我们已选了 p——gcd(x, p) = p > 1,冲突
怎么求质数个数?用埃氏筛 O(n log log n) 打表统计

思维导图
🔢 答案是 1 + 质数个数

💡 构造下界
选 1(与谁都互质)
选所有 ≤ n 的质数
质数之间两两互质
得到 1 + π(n) 个数

🚫 证明上界
设 x 是所选的大于 1 的数
记 p(x) 为它的最小质因子
p(x) ≤ n 且 p(x) 是质数
不同 x 的 p(x) 必不相同

🔍 关键推理
若 p(x) = p(y)
则 p 同时整除 x 和 y
gcd(x,y) ≥ p > 1
与互质矛盾!

📊 计数
所以最多 π(n) 个大于 1 的数
加上 1 共 1 + π(n)
用埃氏筛统计 π(n)
输出答案

样例手算推导
🧮 样例 1:n = 6,答案 4
1 ~ 6 中的质数是 2、3、5,共 3 个。
1
构造一组可行解
选 1、2、3、5
检查两两:gcd(1,2)=1、gcd(1,3)=1、gcd(1,5)=1
gcd(2,3)=1、gcd(2,5)=1、gcd(3,5)=1
全部互质 ✅
✅ 得到 4 个数

2
能不能选 5 个?
1 ~ 6 中偶数是 2、4、6
任取 5 个数,由抽屉原理必然包含至少 2 个偶数
而任意两个偶数 gcd ≥ 2,不互质
所以不可能选到 5 个
❌ 上限就是 4

1 + 3 = 4 ✓

🧮 样例 2:n = 9,答案 5
1 ~ 9 中的质数是 2、3、5、7,共 4 个。
选取方案元素是否两两互质
质数 + 11, 2, 3, 5, 7✅(4+1 = 5 个)
题面给的方案1, 5, 7, 8, 9✅ 也是 5 个
尝试加合数 41, 2, 3, 5, 7, 4❌ gcd(2,4) = 2
尝试加合数 61, 2, 3, 5, 7, 6❌ gcd(2,6) = 2
尝试加合数 91, 2, 3, 5, 7, 9❌ gcd(3,9) = 3
🔑注意题面给的方案和"质数方案"不同,但个数相同。题面用 1, 5, 7, 8, 9——它没有选 2 和 3,所以腾出了位置给 8 和 9(8 只含质因子 2,9 只含质因子 3)。这说明最优解不唯一,但个数是唯一确定的:1 + π(n)。

🧮 上界证明(这是本题的精髓)
证明"不可能超过 1 + π(n)"用了一个很巧妙的映射思路。
1
给每个大于 1 的数配一个"标签"
设选出的集合为 S
对 S 中每个 x > 1,取它的最小质因子 p(x)
显然 p(x) 是质数,且 p(x) ≤ x ≤ n
标签是"≤ n 的质数"

2
不同数的标签必须不同
假设 x ≠ y 但 p(x) = p(y) = p
那么 p | x 且 p | y
所以 gcd(x, y) ≥ p > 1
这与"任意两个数互质"矛盾!
✅ 标签互不相同

3
得出结论
所以 S 中大于 1 的元素与"≤ n 的质数"之间是一一对应
个数 ≤ π(n)
再加上元素 1(最多一个)
所以 |S| ≤ 1 + π(n)
✅ 上界得证

⚠️注意上界证明中的关键点:我们用的是"最小质因子"而不是"任意质因子"——因为只有唯一确定的"最小"才能保证标签是良定义的,从而能建立一一对应。这是数论证明中常用的"构造单射"技巧。

解法对比
⚔️ 解法对比
🟢 埃氏筛 + 质数计数(推荐) 推荐
筛出 1 ~ n 的质数,答案 = 1 + 质数个数
时间 O(n log log n)
n = 10⁵ 时约 10⁴ 次标记
代码 12 行
有严格的证明支撑
💡实现:isP[0] = isP[1] = false; 筛完后统计 isP 中为 true 的个数再加 1。注意 n = 1 时答案也是 1(只选 1)。

🟠 回溯搜索
枚举子集或回溯选择,检查互质性
时间指数级
n = 30 就已不可行
完全不可行
没有任何优化空间
⚠️注意:本题 n ≤ 10⁵,搜索类做法根本不可能。而且本题有精确的数学结论,不需要搜索——这类"求最大数量"的题往往有贪心或数论结论。

📈 性能对比
方案复杂度(n = 10⁵)可行性
埃氏筛 + 计数约 10⁴✅ 瞬间完成
回溯搜索指数级❌ 完全不可行

算法流程图
开始读入 n;isP[1..n] 全部初始化为 trueisP[1] = false(1 不是质数)i 从 2 到 √nisP[i] 为真吗?是 ✓把 i 的所有倍数标记为非质数否 ✗跳过统计 isP[2..n] 中 true 的个数 cnt输出 cnt + 1(加上数字 1)结束i 加 1 继续筛← 左右滑动查看完整流程图
动手算一算
🔢 最多可选取数量计算器

输入 n,程序会筛出 1 ~ n 的质数并给出最大选取数量。

输入 n


算一下!
随机出题


结果会显示在这里

点按钮开始 →

代码精讲
💻 完整 C++ 代码
include <bits/stdc++.h>
using namespace std;

bool isP[100005];

int main() {
int n;
scanf("%d", &n);

// 埃氏筛
for (int i = 0; i <= n; i++) isP[i] = true;
if (n >= 0) isP[0] = false;
if (n >= 1) isP[1] = false;
for (int i = 2; (long long)i * i <= n; i++) {
if (isP[i]) {
for (int j = i * i; j <= n; j += i) isP[j] = false; // 从 i*i 开始标记
}
}

int cnt = 0;
for (int i = 2; i <= n; i++) if (isP[i]) cnt++;

printf("%d\n", cnt + 1); // 质数个数 + 数字 1
return 0;
}
🔑为什么内层循环从 i * i 开始?因为比 i * i 更小的 i 的倍数(如 2i、3i)已经在前面的质数轮次里被标记过了,不必重复。这个优化让埃氏筛的复杂度降到 O(n log log n)。

📖 关键几行怎么看
代码作用为什么这样写
isP[0] = isP[1] = false;特殊值0 和 1 都不是质数
for (j = i * i; j <= n; j += i)筛掉倍数从 i² 开始,避免重复标记
cnt++统计质数个数得到 π(n)
printf("%d\n", cnt + 1)输出答案别忘了加 1(数字 1 也要选)
⚠️两个坑:① 忘记加 1(1 与任何数互质,一定可以选);② 内层从 i 而不是 i * i 开始,虽然结果正确但会慢一些。

边界测试 &amp; 易错点
🧪 边界测试用例表
写完程序后,用这些数据自查一遍:
输入答案考察点
64题面样例 1
95题面样例 2
11只有 1 可选(1 不是质数,所以答案是 0 + 1 = 1)
22选 1 和 2
33选 1、2、3
105质数有 2、3、5、7 共 4 个 → 4 + 1 = 5
✅自查清单:① 统计的是质数个数吗?② 最后加 1 了吗?③ n = 1 的边界对吗?

🚨 易错点清单
⚠️忘记加 1:数字 1 与任何数互质,一定可以选,答案是 π(n) + 1。

⚠️n = 1 时出错:此时 π(1) = 0,答案应为 1(只选 1)。

⚠️以为答案与具体选法有关:最优解可能不唯一,但个数是唯一确定的。

复杂度分析
📊 复杂度四宫格
时间复杂度
O(n log log n)

空间复杂度
O(n)

n 最大
10⁵

运算量
约 10⁴ ~ 10⁵

时间怎么算的?
埃氏筛的复杂度是 O(n log log n)
n = 10⁵ 时约几万次标记操作
统计质数个数是 O(n)
空间都用在哪?
一个长度为 n + 1 的布尔数组。
✅ 瞬间完成。关键在于识别出"答案是 1 + π(n)"这个结论,而不是去搜索。

知识拓展
🔗 常用技巧小抄
// 埃氏筛标准模板
bool isP[N];
for (int i = 2; i < N; i++) isP[i] = true;
for (int i = 2; (long long)i * i < N; i++)
if (isP[i])
for (int j = i * i; j < N; j += i) isP[j] = false;

// 线性筛(欧拉筛):每个合数只被最小质因子筛一次,O(n)
vector<int> primes;
vector<bool> isP(N, true);
for (int i = 2; i < N; i++) {
if (isP[i]) primes.push_back(i);
for (int p : primes) {
if ((long long)i * p >= N) break;
isP[i * p] = false;
if (i % p == 0) break;
}
}

// 结论汇总:从 [1, n] 中选最多互质的数 -> 1 + π(n)

🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
埃氏筛标记倍数筛质数所有需要质数表的题目
单射构造证明给每个元素配唯一标签组合计数、上界证明
识别数学结论答案 = 1 + π(n)避免无谓的搜索
🌟思考题:如果题目改成"选出的数中任意两个的gcd 都不超过 1"(即允许相等),答案会变吗?(提示:不会变——因为题目已经要求"两个不同的数",而 gcd(x, x) = x,所以同一个数不能选两次。这类"读清约束条件"的功夫在竞赛中非常重要。)

💻 参考代码
#include &lt;bits/stdc++.h&gt;

using namespace std;



bool isP[100005];



int main() {

    int n;

    scanf(&quot;%d&quot;, &amp;n);



    // 埃氏筛

    for (int i = 0; i &lt;= n; i++) isP[i] = true;

    if (n &gt;= 0) isP[0] = false;

    if (n &gt;= 1) isP[1] = false;

    for (int i = 2; (long long)i * i &lt;= n; i++) {

        if (isP[i]) {

            for (int j = i * i; j &lt;= n; j += i) isP[j] = false;   // 从 i*i 开始标记

        }

    }



    int cnt = 0;

    for (int i = 2; i &lt;= n; i++) if (isP[i]) cnt++;



    printf(&quot;%d\n&quot;, cnt + 1);      // 质数个数 + 数字 1

    return 0;

}
💻 参考代码
// 埃氏筛标准模板

bool isP[N];

for (int i = 2; i &lt; N; i++) isP[i] = true;

for (int i = 2; (long long)i * i &lt; N; i++)

    if (isP[i])

        for (int j = i * i; j &lt; N; j += i) isP[j] = false;



// 线性筛(欧拉筛):每个合数只被最小质因子筛一次,O(n)

vector&lt;int&gt; primes;

vector&lt;bool&gt; isP(N, true);

for (int i = 2; i &lt; N; i++) {

    if (isP[i]) primes.push_back(i);

    for (int p : primes) {

        if ((long long)i * p &gt;= N) break;

        isP[i * p] = false;

        if (i % p == 0) break;

    }

}



// 结论汇总:从 [1, n] 中选最多互质的数 -&gt; 1 + π(n)
P15798有限不循环小数2026-03 · 数论
数论
📝 题目描述

若 \frac{1}{a} 可化为一个有限的,不循环的小数,则称 a 为终止数。

请你求出在 L 到 R 中终止数的数量。

⌨️ 输入格式

输入一行,包含两个整数 L,R。
🖨 输出格式

输出一行,包含一个整数,表示 L 到 R 中终止数的数量。
🔎 样例
#输入输出
1
2 11
5
📌 说明 / 数据范围

样例解释
在 [2,11] 终止数有 2、4、5、8、10。

数据范围
保证 1 ≤ L ≤ R ≤ 10^6。

💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
题目拆解
📝 题目原文
若 1/a 可以化为一个有限的、不循环的小数,则称 a 为终止数。求 [L, R] 中终止数的个数。
例:在 [2, 11] 中,终止数有 2、4、5、8、10,共 5 个。
💡人话翻译:这是一个经典的数论结论题——1/a 是有限小数 ⟺ a 的质因数只有 2 和 5。换句话说,a 必须能写成 2ˣ × 5ʸ 的形式。所以我们要做的就是在 [L, R] 里数出所有这种形式的数。

🔍 关键词提取
质因数分解有限小数判定枚举 2 与 5 的幂数论结论
已知条件
项目说明
输入一行两个整数 L、R
输出[L, R] 中终止数的个数
数据范围1 ≤ L ≤ R ≤ 10⁶
终止数定义1/a 是有限且不循环的小数
等价条件a = 2ˣ × 5ʸ(x, y ≥ 0)
需要解决的问题
为什么是"只有质因子 2 和 5"?因为十进制小数的每一位对应分母的 10 的幂;若分母含 2、5 之外的质因子,该因子无法被 10 的幂消掉,于是变成无限循环小数
怎么枚举?因为 R ≤ 10⁶,所以 x ≤ 19、y ≤ 8,双重循环最多约 20 × 9 = 180 个候选
要注意什么?用 long long 累乘防止溢出,超过 R 就提前退出

思维导图
🔢 枚举 2ˣ × 5ʸ

🧠 数论结论
1/a 有限小数
⟺ a = 2ˣ × 5ʸ
不含其他质因子
经典结论务必记牢

🔁 双重枚举
x 从 0 开始,2ˣ ≤ R
y 从 0 开始,2ˣ5ʸ ≤ R
R ≤ 10⁶ → x ≤ 19、y ≤ 8
约 180 个候选

✅ 计数
若在 [L, R] 内 → 计数加 1
用 long long 累乘
超过 R 就 break

⚠️ 易错点
忘记 x = 0 或 y = 0 的情况
把 1 漏掉(1 = 2⁰5⁰)
用 int 累乘溢出
以为要真的算小数

样例手算推导
🧮 样例:逐个判断 2 ~ 11
对每个数做质因数分解,看是否只含 2 和 5。
数字分解只含 2 和 5?是否终止数
22✅是
33❌ 含质因子 3否
42²✅是
55✅是
62 × 3❌否
77❌否
82³✅是
93²❌否
102 × 5✅是
1111❌否
1
验证 1/4 = 0.25
4 = 2²,符合条件
1/4 = 0.25,确实有限 ✅
✅ 终止数

2
验证 1/6 = 0.1666…
6 = 2 × 3,含质因子 3
1/6 = 0.16666…,无限循环 ❌
❌ 不是终止数

共 5 个 ✓

🧮 用"枚举 2ˣ × 5ʸ"的方法求解
与其逐个分解质因数(每个数最坏 O(√a)),不如直接枚举所有 2ˣ × 5ʸ 形式的数——数量极少。
x2ˣy = 0 ~ 8 得到的数(≤ 11 范围内的)
011、5(2⁰5⁰=1、2⁰5¹=5)
122、10
244
388
416超出 11,但仍要枚举(可能配 y=0 时 16 > 11 就不计)
1
枚举顺序
外层 x:从 0 开始,令 p2 = 2^x,只要 p2 ≤ R
内层 y:从 0 开始,令 v = p2 × 5^y,只要 v ≤ R
若 v ≥ L,就计数加 1
双重循环即可

2
候选总数
R ≤ 10⁶ 时,2^x ≤ 10⁶ → x ≤ 19
5^y ≤ 10⁶ → y ≤ 8
最多 20 × 9 = 180 个候选
远少于逐个分解的 10⁶ 次
✅ 效率极高

🔑别忘了 x = 0 或 y = 0 的情况:2⁰ × 5⁰ = 1,而 1/1 = 1 确实是有限小数 ✅,所以 1 也是终止数。同理 2⁰ × 5¹ = 5、2¹ × 5⁰ = 2 都要算上。如果循环从 x = 1 开始,就会漏掉这些。

解法对比
⚔️ 解法对比
🟢 枚举 2ˣ × 5ʸ(推荐) 推荐
双重循环枚举所有候选并判断是否落在区间内
时间 O(log²R)
R = 10⁶ 时约 180 个候选
代码 10 行
不需要筛法或分解
💡实现:for (x = 0, p2 = 1; p2 <= R; x++, p2 *= 2) for (y = 0, v = p2; v <= R; y++, v *= 5) if (v >= L) ans++;

🟠 逐个分解质因数
对 [L, R] 中每个数分解质因数,检查是否只含 2 和 5
时间 O((R−L) × √R)
R = 10⁶ 时约 10⁹ 次
可能超时
代码也不短
⚠️为什么不好:区间最长可达 10⁶,每个数试除到 √a(约 1000 次),总共 10⁹ 次运算,很容易超时。而"枚举候选"的思路把工作量降到了几百次。

📈 性能对比
方案运算量(10⁶ 区间)是否可行
枚举 2ˣ5ʸ约 180✅ 极快
逐个分解约 10⁹❌ 可能超时

算法流程图
开始读入 L、R;ans = 0x 从 0 开始,p2 = 2ˣ;只要 p2 ≤ Ry 从 0 开始,v = p2 × 5ʸ;只要 v ≤ Rv ≥ L 吗?是 ✓ans 加 1否 ✗不计数y 加 1,v 乘 5,继续内层x 加 1,p2 乘 2,继续外层输出 ans结束v 还 ≤ R → 继续内层← 左右滑动查看完整流程图
动手算一算
🔢 终止数统计器

输入 L 和 R,程序会列出所有 2ˣ × 5ʸ 形式的数并统计落在区间内的个数。

输入 L R


算一下!
随机出题


结果会显示在这里

点按钮开始 →

代码精讲
💻 完整 C++ 代码
include <bits/stdc++.h>
using namespace std;

int main() {
long long L, R;
scanf("%lld %lld", &L, &R);

int ans = 0;

// 枚举所有 2^x × 5^y 形式的数
for (long long p2 = 1, x = 0; p2 <= R; p2 *= 2, x++) {
for (long long v = p2, y = 0; v <= R; v *= 5, y++) {
if (v >= L) ans++;
}
}

printf("%d\n", ans);
return 0;
}
🔑循环里用 v *= 5 累乘而不是每次调用 pow:一是避免浮点误差,二是让每轮只做一次乘法。注意内层循环的 v 必须从 p2 开始(也就是 y = 0 的情形),否则会漏掉"只含 2 的幂"的那些数(如 4、8)。

📖 关键几行怎么看
代码作用为什么这样写
for (p2 = 1; p2 <= R; p2 *= 2)枚举 2 的幂p2 从 1 开始,覆盖 x = 0
for (v = p2; v <= R; v *= 5)枚举 5 的幂从 p2 开始,覆盖 y = 0
if (v >= L) ans++;区间判断等价于 L ≤ v ≤ R
long long类型累乘过程中可能短暂超过 int
⚠️三个坑:① 内层从 p2 * 5 开始(漏掉 y = 0 的情况);② 外层从 p2 = 2 开始(漏掉 1 这个终止数);③ 用逐个分解质因数的方法,复杂度太高可能超时。

边界测试 &amp; 易错点
🧪 边界测试用例表
写完程序后,用这些数据自查一遍:
输入答案考察点
2 115题面样例
1 111 = 2⁰ × 5⁰,1/1 = 1 是有限小数
1 1071、2、4、5、8、10(还有 1 本身)共 7 个
3 303 含质因子 3
1000 100011000 = 2³ × 5³,是终止数
1 1000000运行验证最大范围
✅自查清单:① x 从 0 开始吗?② 内层 v 从 p2 开始吗?③ 判断了 v ≥ L 吗?

🚨 易错点清单
⚠️漏掉 x = 0 或 y = 0:1 = 2⁰5⁰、2 = 2¹5⁰、5 = 2⁰5¹ 都是终止数,循环必须从 1 开始。

⚠️用逐个分解质因数:区间长达 10⁶ 时会超时,应改用"枚举 2ˣ5ʸ 候选"。

⚠️忘记判断下界:枚举出的值必须 ≥ L 才计数。

复杂度分析
📊 复杂度四宫格
时间复杂度
O(log₂R × log₅R)

空间复杂度
O(1)

R 最大
10⁶

候选总数
约 180

时间怎么算的?
外层枚举 2 的幂:x ≤ log₂10⁶ ≈ 20
内层枚举 5 的幂:y ≤ log₅10⁶ ≈ 9
候选总数最多 20 × 9 = 180 个
空间都用在哪?
只用几个变量,不需要额外空间。
✅ 不到 200 次循环,瞬间完成。关键在于"转换视角":不枚举区间里的数,而是枚举可行解。

知识拓展
🔗 常用技巧小抄
// 数论结论:1/a 是有限小数 ⟺ a 只含质因子 2 和 5
// 证明思路:
// 十进制小数的第 k 位对应分母 10^k = 2^k * 5^k
// 若 a 含其他质因子 p,则 p 无法被 10^k 消掉 -> 必然循环
// 反之若 a = 2^x * 5^y,取 k = max(x, y),则 10^k / a 是整数 -> 有限

// 枚举所有 2^x * 5^y <= R
for (long long p2 = 1; p2 <= R; p2 *= 2)
for (long long v = p2; v <= R; v *= 5)
/* 处理 v */;

// 类似思路:枚举"特殊结构的数"而非枚举区间
// 例如"只含因子 3 的数""只含 2、3、5 的数"(丑数)等

🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
数论结论有限小数 ⟺ 只含 2、5小数性质、分数化简类题目
枚举可行解不枚举区间而是枚举候选所有"满足特殊条件"的计数题
累乘代替 pow避免浮点误差所有需要幂次的整数运算
🌟思考题:本题把"质因子只有 2 和 5"换成"质因子只有 2、3、5"(这就是著名的丑数),代码要怎么改?(提示:多加一层循环枚举 3 的幂即可,三重循环最多约 20 × 13 × 9 ≈ 2300 个候选,依然极快。所以"枚举可行解"的思路有很强的可扩展性。)

💻 参考代码
#include &lt;bits/stdc++.h&gt;

using namespace std;



int main() {

    long long L, R;

    scanf(&quot;%lld %lld&quot;, &amp;L, &amp;R);



    int ans = 0;



    // 枚举所有 2^x × 5^y 形式的数

    for (long long p2 = 1, x = 0; p2 &lt;= R; p2 *= 2, x++) {

        for (long long v = p2, y = 0; v &lt;= R; v *= 5, y++) {

            if (v &gt;= L) ans++;

        }

    }



    printf(&quot;%d\n&quot;, ans);

    return 0;

}
💻 参考代码
// 数论结论:1/a 是有限小数 ⟺ a 只含质因子 2 和 5

// 证明思路:

//   十进制小数的第 k 位对应分母 10^k = 2^k * 5^k

//   若 a 含其他质因子 p,则 p 无法被 10^k 消掉 -&gt; 必然循环

//   反之若 a = 2^x * 5^y,取 k = max(x, y),则 10^k / a 是整数 -&gt; 有限



// 枚举所有 2^x * 5^y &lt;= R

for (long long p2 = 1; p2 &lt;= R; p2 *= 2)

    for (long long v = p2; v &lt;= R; v *= 5)

        /* 处理 v */;



// 类似思路:枚举&quot;特殊结构的数&quot;而非枚举区间

// 例如&quot;只含因子 3 的数&quot;&quot;只含 2、3、5 的数&quot;(丑数)等
P17011晚宴2026-06 · 数学 / 枚举 / 最大公约数 gcd
数学枚举最大公约数 gcd
📝 题目描述
小明去参加晚宴。晚宴中有 n 个菜肴,每个菜肴都有一个美味度,第 i 个菜肴的美味度为 v_i。

晚宴规定小明只能恰好选取两道菜肴,并且这两道菜肴的美味度必须要互质(即最大公约数为 1)。

请帮助小明选取两道菜肴,使得两道菜肴美味度之和最大。

⌨️ 输入格式
输入 2 行,

第一行为一个正整数 n,表示菜肴的个数;

第二行为 n 个整数 v_1, v_2, …, v_n 表示菜肴的美味度,整数之间以空格分隔。

🖨 输出格式
输出一个整数,表示两道互质菜肴美味度之和的最大值。
🔎 样例
#输入输出
1
5
3 5 7 35 105
38
📌 说明 / 数据范围
样例解释 1
最优选择是 3 和 35。

注意到,105 与其他任意菜肴的最大公约数都大于 1,因此无法参与合法选择。

数据范围
2 ≤ n ≤ 1000, 1 ≤ v_i ≤ 1000000。

数据保证不存在相同美味度的菜肴。

数据保证至少存在一种选取两道菜肴的方案。

⚠️ 这道题美力程题解库暂未收录文字题解。建议按考点自己先推一遍:
· 把公式化简后再算,注意取整与取余的方向。
· 定范围、写条件、逐个试;能推出的量就别多写一层循环。
写完后可到洛谷 P17011 对照题解。
P17455哥德巴赫猜想2026-09 · 数论 / 枚举 / 素数判断
数论枚举素数判断
📝 题目描述
众所周知,哥德巴赫猜想是说,任何大于 2 的偶数都能写成两个质数(素数)之和。例如:

- 4=2+2
- 6=3+3
- 8=3+5
- 10=3+7=5+5

聪明的你肯定想知道,对于大于 2 的偶数 n,它有多少种写成两个质数之和的方法。例如 4、6 和 8 都只有一种方法,10 有两种方法。请你编写程序计算这个问题的答案。

在本题中,我们认为两种方案不同,当且仅当两种分解方案包含的素数互不相同;即 10=3+7 和 10=7+3 是同一种方案,不能重复计数。

⌨️ 输入格式
一行,一个大于 2 的偶数 n。
🖨 输出格式
一行,一个整数,表示将 n 写成两个质数之和的方法数。
🔎 样例
#输入输出
1
4
1
2
10
2
📌 说明 / 数据范围
对于 40% 的测试点,保证 4≤ n≤ 100。

对于所有测试点,保证 4≤ n≤ 10^6。

💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
题目拆解
📝 题目原文
哥德巴赫猜想:任何大于 2 的偶数都能写成两个质数之和。如 4 = 2+2、6 = 3+3、8 = 3+5、10 = 3+7 = 5+5。
给定大于 2 的偶数 n,求把它写成两个质数之和的方案数。两种方案不同当且仅当包含的素数互不相同(即 10 = 3+7 与 10 = 7+3 算同一种)。
💡人话翻译:枚举第一个质数 p,判断 n − p 是否也是质数。关键:只枚举 p ≤ n/2,这样每种方案只被数一次,自然满足了"不计顺序"的要求。判断质数用筛法预处理,做到 O(1) 查询。

🔍 关键词提取
埃氏筛质数判定枚举去重对称性
已知条件
项目说明
输入一个大于 2 的偶数 n
输出方案数
数据范围4 ≤ n ≤ 10⁶
方案定义n = p + q,p、q 均为质数
去重(p, q) 与 (q, p) 视为同一方案
需要解决的问题
怎么快速判质数?用埃氏筛预处理 1 ~ n 的质数表,之后 O(1) 查询
怎么避免重复计数?只让 p 取 ≤ n/2 的值;或干脆要求 p ≤ q
要另外检查 q 吗?要——必须同时确认 p 和 q 都是质数

思维导图
🔢 筛表 + 枚举小的一半

📊 预处理
埃氏筛出 1~n 的质数
isP[x] 表示 x 是否质数
O(n log log n)
查询 O(1)

🔁 枚举
p 从 2 到 n/2
q = n − p
若 p 和 q 都是质数
计数加 1

✂️ 去重技巧
只枚举 p ≤ n/2
(p,q) 与 (q,p) 只算一次
不需要集合去重
自然满足"不计顺序"

⚠️ 易错点
枚举到 n 导致重复计数(答案翻倍)
漏判 q 的质数性
筛法数组开小
忘记 p 从 2 开始(1 不是质数)

样例手算推导
🧮 验证几个小偶数
先把小规模的方案列出来,确认理解正确。
n拆分方案(p ≤ q)方案数
42 + 21
63 + 31
83 + 51
103 + 7、5 + 52
125 + 71
143 + 11、7 + 72
1003+97、11+89、17+83、29+71、41+59、47+536
1
为什么 n = 10 是 2 种?
p 从 2 枚举到 n/2 = 5
p = 2:q = 8,8 不是质数 ✗
p = 3:q = 7,7 是质数 ✅(方案 3+7)
p = 4:4 不是质数 ✗
p = 5:q = 5,是质数 ✅(方案 5+5)
共 2 种
✅ 输出 2

2
如果枚举到 n 会怎样?
那样 3+7 和 7+3 会被分别数到
5+5 也会被数两次(p=5 时一次,p=5 还是同一次)
实际上 (3,7) 和 (7,3) 都会出现
答案会变成 3(多算了)
❌ 必须限制 p ≤ n/2

🔑为什么"限制 p ≤ n/2"就能去重?因为每个合法方案 {p, q} 里,较小的那个一定 ≤ n/2。所以"让 p 走遍 ≤ n/2 的范围",每个方案恰好被枚举一次。这比"枚举全部再除以 2"更稳妥——因为 p = q = n/2 的情况只出现一次,直接除以 2 会错。

🧮 n = 100 的完整枚举
我们逐个检查 p ≤ 50 的情况。
pq = 100 − pp 是质数?q 是质数?计数
298✅❌ 98 是偶数—
397✅✅1
595✅❌ 95 = 5 × 19—
793✅❌ 93 = 3 × 31—
1189✅✅2
1387✅❌ 87 = 3 × 29—
1783✅✅3
1981✅❌ 81 = 9²—
2377✅❌ 77 = 7 × 11—
2971✅✅4
3169✅❌ 69 = 3 × 23—
3763✅❌ 63 = 7 × 9—
4159✅✅5
4357✅❌ 57 = 3 × 19—
4753✅✅6
n = 100 共有 6 种方案 ✓
⚠️注意 p 只能取质数:比如 p = 4、6、8 等合数时根本不用检查 q,直接用 if (!isP[p]) continue; 跳过。这能省掉一半以上的检查。

解法对比
⚔️ 解法对比
🟢 筛法预处理 + 枚举(推荐) 推荐
先筛出质数表,再枚举 p ≤ n/2 查表
时间 O(n log log n)
n = 10⁶ 时约 3 × 10⁶ 次
每次查询 O(1)
代码 20 行
💡为什么必须筛:枚举阶段要做约 n/2 = 5 × 10⁵ 次质数判定,如果每次都试除到 √n,总复杂度会变成 O(n√n) ≈ 10⁹,必然超时。筛法把判定降到 O(1)。

🟠 每次试除判质数
枚举 p 时用试除法判断 p 和 q 是否为质数
时间 O(n√n) ≈ 10⁹
必然超时
代码短但过不了
典型的"想简单但不可行"
⚠️量级对比:试除法每次判定要 √(10⁶) = 1000 次,乘以 5 × 10⁵ 次枚举,总共 5 × 10⁸ 次——即使 C++ 也极可能超时。

📈 性能对比
方案运算量(n = 10⁶)可行性
筛法 + 枚举约 3 × 10⁶✅ 稳过
试除判质数约 5 × 10⁸❌ 超时

算法流程图
开始读入 n;用埃氏筛建立 isP[0..n]ans = 0p 从 2 到 n / 2isP[p] 为真吗?是 ✓检查 q否 ✗p 加 1isP[n − p] 为真吗?是 ✓ans 加 1否 ✗跳过输出 ans结束p 加 1 继续← 左右滑动查看完整流程图
动手算一算
🔢 哥德巴赫拆分数

输入一个大于 2 的偶数,程序会列出所有拆分方案并计数。

输入偶数 n


算一下!
随机出题


结果会显示在这里

点按钮开始 →

代码精讲
💻 完整 C++ 代码
include <bits/stdc++.h>
using namespace std;

bool isP[1000005];

int main() {
int n;
scanf("%d", &n);

// 埃氏筛:预处理 0 ~ n 的质数标记
for (int i = 0; i <= n; i++) isP[i] = true;
isP[0] = isP[1] = false;
for (int i = 2; (long long)i * i <= n; i++) {
if (isP[i])
for (int j = i * i; j <= n; j += i) isP[j] = false;
}

int ans = 0;
for (int p = 2; p <= n / 2; p++) { // 只枚举较小的一半,天然去重
if (!isP[p]) continue;
int q = n - p;
if (isP[q]) ans++;
}

printf("%d\n", ans);
return 0;
}
🔑为什么用 p <= n / 2 而不是 p <= n?这是本题去重的核心。每个方案 {p, q} 中较小的那个一定不超过 n/2,所以让 p 只走到 n/2,每个方案恰好被枚举一次。注意要用整数除法,写成 p <= n/2 对偶数 n 正好正确。

📖 关键几行怎么看
代码作用为什么这样写
isP[0] = isP[1] = false特殊值0 和 1 都不是质数
for (j = i * i; ...)筛法从 i² 开始标记,避免重复
p <= n / 2去重只枚举小的一半,避免重复计数
if (isP[q]) ans++判定同时要求 p 和 q 都是质数
⚠️三个坑:① 枚举到 p <= n 导致答案翻倍;② 漏判 q 的质数性;③ 用试除法代替筛法(会超时)。

边界测试 &amp; 易错点
🧪 边界测试用例表
写完程序后,用这些数据自查一遍:
输入答案考察点
41题面样例 1:2 + 2
102题面样例 2:3+7、5+5
613 + 3
813 + 5
10063+97、11+89、17+83、29+71、41+59、47+53
1000000运行验证最大规模
✅自查清单:① 用筛法了吗?② p 只枚举到 n/2 吗?③ 检查了 q 吗?

🚨 易错点清单
⚠️枚举范围写错:必须只枚举 p ≤ n/2,否则 (p,q) 与 (q,p) 会被重复计数。

⚠️漏判 q:必须确认 n − p 也是质数。

⚠️用试除判质数:复杂度会到 10⁸ ~ 10⁹,必须用筛法。

复杂度分析
📊 复杂度四宫格
时间复杂度
O(n log log n)

空间复杂度
O(n)

n 最大
10⁶

运算量
约 3 × 10⁶

时间怎么算的?
埃氏筛:O(n log log n)
枚举:约 n/2 次,每次 O(1) 查询
合计约 3 × 10⁶ 次操作
空间都用在哪?
需要一个长度为 n + 1 的布尔数组。
✅ 约 300 万次操作,瞬间完成。关键是用筛法把质数判定降到 O(1)。

知识拓展
🔗 常用技巧小抄
// 埃氏筛模板
bool isP[N];
for (int i = 0; i <= n; i++) isP[i] = true;
isP[0] = isP[1] = false;
for (int i = 2; (long long)i * i <= n; i++)
if (isP[i])
for (int j = i * i; j <= n; j += i) isP[j] = false;

// 本题核心:只枚举较小的加数,天然去重
for (int p = 2; p <= n / 2; p++)
if (isP[p] && isP[n - p]) ans++;

// 类似的"两数和"问题都可以用这个框架
// 例如:和为定值的两数之积最大、两数之差最小等
// 关键在于"用筛法预处理 + 枚举较小一侧"

🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
埃氏筛O(1) 质数判定所有需要大量质数判断的题
枚举较小一侧天然去重两数之和/之差类问题
预处理换查询速度时间空间权衡多次查询的优化套路
🌟思考题:如果题目改成"求所有方案中两个质数之差最大的那一组",要改哪里?(提示:p 越小则 q 越大、差越大。所以可以从 p = 2 开始枚举,找到第一个满足条件的 p 就停——不必数完所有方案,能提前退出。这说明同一套枚举框架可以做不同"目标"的优化。)

💻 参考代码
#include &lt;bits/stdc++.h&gt;

using namespace std;



bool isP[1000005];



int main() {

    int n;

    scanf(&quot;%d&quot;, &amp;n);



    // 埃氏筛:预处理 0 ~ n 的质数标记

    for (int i = 0; i &lt;= n; i++) isP[i] = true;

    isP[0] = isP[1] = false;

    for (int i = 2; (long long)i * i &lt;= n; i++) {

        if (isP[i])

            for (int j = i * i; j &lt;= n; j += i) isP[j] = false;

    }



    int ans = 0;

    for (int p = 2; p &lt;= n / 2; p++) {      // 只枚举较小的一半,天然去重

        if (!isP[p]) continue;

        int q = n - p;

        if (isP[q]) ans++;

    }



    printf(&quot;%d\n&quot;, ans);

    return 0;

}
💻 参考代码
// 埃氏筛模板

bool isP[N];

for (int i = 0; i &lt;= n; i++) isP[i] = true;

isP[0] = isP[1] = false;

for (int i = 2; (long long)i * i &lt;= n; i++)

    if (isP[i])

        for (int j = i * i; j &lt;= n; j += i) isP[j] = false;



// 本题核心:只枚举较小的加数,天然去重

for (int p = 2; p &lt;= n / 2; p++)

    if (isP[p] &amp;&amp; isP[n - p]) ans++;



// 类似的&quot;两数和&quot;问题都可以用这个框架

// 例如:和为定值的两数之积最大、两数之差最小等

// 关键在于&quot;用筛法预处理 + 枚举较小一侧&quot;
B3941小杨的锻炼样题 · 数论 / 最大公约数 gcd
数论最大公约数 gcd
📝 题目描述
小杨的班级里共有 n 名同学,每位同学都有各自的锻炼习惯。具体来说,第 i 位同学每隔 a_i 天就会进行一次锻炼(也就是说,每次锻炼会在上一次锻炼的 a_i 天后进行)。某一天,班上的 n 名同学恰好都来进行了锻炼。他们对此兴奋不已,想要计算出下一次所有同学都来锻炼,至少要过多少天。但他们不会计算,你能帮帮他们吗?
⌨️ 输入格式
第一行一个整数 n,表示同学的数量。
第二行 n 个用空格隔开的正整数,依次为 a_0, a_1, …, a_{n-1}。
🖨 输出格式
输出一个整数,表示下一次所有同学都来锻炼,至少要过多少天。
🔎 样例
#输入输出
1
3
1 2 3
6
2
4
2 4 8 16
16
3
4
2 4 6 8
24
📌 说明 / 数据范围
样例 1 解释
第一位同学每天都锻炼;第二位同学每 2 天锻炼一次;第三位同学每 3 天锻炼一次。因此,6 天之后,三位同学都会进行锻炼。在此之前,第二位同学只会在第 2, 4 天进行锻炼,第三位同学只会在第 3 天进行锻炼,他们都无法相遇。

样例 2 解释
第四位同学每 16 天锻炼一次,而 16 天后也恰好是前三位同学锻炼的日子。

数据规模与约定
- 对 20% 的数据,n = 2。
- 对 50% 的数据,n = 4。
- 对 100% 的数据,2 ≤q n ≤q 10,1 ≤q a_i ≤q 50。

💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
题目拆解
📝 题目原文
班上共 n 名同学,第 i 位同学每隔 aᵢ 天锻炼一次。某一天所有人恰好都来锻炼了,求下一次所有同学都来锻炼至少还要过多少天。
💡人话翻译:这题就是求所有周期的最小公倍数(LCM)。因为"同时锻炼"意味着经过的天数必须同时是每个 aᵢ 的倍数。关键公式:lcm(x, y) = x / gcd(x, y) × y——先除后乘,可以有效避免中间结果溢出。

🔍 关键词提取
最小公倍数最大公约数辗转相除防溢出
已知条件
项目说明
输入第一行 n;第二行 n 个正整数 aᵢ
输出最少要过的天数(即 LCM)
含义第 i 位同学的锻炼发生在 aᵢ, 2aᵢ, 3aᵢ, … 天
目标最小的正数 T,使 T 是每个 aᵢ 的倍数
需要解决的问题
为什么是 LCM?因为"都来锻炼"要求 T 同时是每个 aᵢ 的倍数——这正是公倍数的定义
怎么求多个数的 LCM?从左到右累乘:ans = lcm(ans, aᵢ)
怎么防溢出?写成 ans / gcd(ans, aᵢ) * aᵢ,先除后乘

思维导图
📅 求所有周期的最小公倍数

🧠 模型转化
第 i 人每 aᵢ 天一次
同时锻炼 ⟺ 天数同时是各 aᵢ 的倍数
所以答案是 LCM
结论:求 LCM(a₁…aₙ)

🔧 单个 LCM
lcm(x,y) = x / gcd(x,y) × y
先除后乘防溢出
gcd 用辗转相除
O(log A)

🔄 累积
ans 初始为 1
依次 ans = lcm(ans, aᵢ)
或从 a₁ 开始
n 个数的 LCM = 反复两两求

⚠️ 易错点
用 int 溢出
写成 x * y / gcd(先乘会溢出)
gcd 写成递归但未处理 0
以为答案是乘积 Σ 而非 LCM

样例手算推导
🧮 样例 1:a = [1, 2, 3],答案 6
逐个累积求 LCM。
1
初始 ans = 1
把第 1 个数 1 并入:lcm(1, 1) = 1
ans = 1

2
并入 2
gcd(1, 2) = 1
lcm(1, 2) = 1 / 1 × 2 = 2
ans = 2

3
并入 3
gcd(2, 3) = 1
lcm(2, 3) = 2 / 1 × 3 = 6
ans = 6

验证:第 1 人天天来;第 2 人在第 2、4、6 天来;第 3 人在第 3、6 天来 → 第 6 天三人同来 ✓

🧮 样例 2 与样例 3 的对比
这两组数据很能说明 LCM 的含义。
样例aLCM说明
22, 4, 8, 1616每个数都是前一个的倍数,所以最大那个就是 LCM
32, 4, 6, 8244 和 6 的 LCM 是 12,再与 8 求 LCM 得 24
1
样例 3 逐步算
ans = 2
并入 4:gcd(2,4)=2 → lcm = 2/2×4 = 4
并入 6:gcd(4,6)=2 → lcm = 4/2×6 = 12
并入 8:gcd(12,8)=4 → lcm = 12/4×8 = 24
✅ ans = 24

🔑注意"先除后乘"的重要性:以 lcm(12, 8) 为例,12 × 8 = 96 再除以 4 得 24——这里 96 还没溢出。但如果 aᵢ 达到 10⁹ 量级,x × y 会到 10¹⁸,恰好接近 long long 上限,再多乘一次就溢出了。写成 x / gcd * y 能把中间值控制住。

解法对比
⚔️ 解法对比
🟢 累积 LCM(推荐) 推荐
从左到右依次求 lcm(ans, aᵢ)
时间 O(n log A)
代码 10 行
不需要分解质因数
最直接
💡注意先除后乘:ans = ans / __gcd(ans, a[i]) * a[i];——这个顺序能有效减小中间结果,是写 LCM 的标准姿势。

🟠 分解质因数后取最大指数
把每个 aᵢ 分解,对各质数取指数的最大值再相乘
理论正确但代码长
需要分解每个数
还要处理大质数
完全没必要
⚠️两者等价:lcm = ∏ p^(max e_i)。但直接用 gcd 的公式更省事,只有在需要"按质因数分析"时才用分解法。

📈 性能对比
方案代码量适用性
累积 LCM约 10 行通用
质因数分解法约 35 行需要质因数视角时

算法流程图
开始读入 n 和数组 aans = 1i 从 0 到 n−1ans = ans / gcd(ans, a[i]) × a[i]n 个数都并入了吗?输出 ans结束i 加 1 继续← 左右滑动查看完整流程图
动手算一算
📅 全员同练天数计算器

输入每位同学的锻炼周期,程序会逐步求最小公倍数。

输入各同学周期


算一下!
随机出题


结果会显示在这里

点按钮开始 →

代码精讲
💻 完整 C++ 代码
include <bits/stdc++.h>
using namespace std;

long long a[100];

int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%lld", &a[i]);

long long ans = 1; // LCM 的单位元是 1
for (int i = 0; i < n; i++) {
// 先除后乘,避免 ans * a[i] 这一步溢出
ans = ans / __gcd(ans, a[i]) * a[i];
}

printf("%lld\n", ans);
return 0;
}
🔑为什么初始值取 1 而不是 0?因为 LCM 的"单位元"是 1——lcm(1, x) = x。如果取 0,lcm(0, x) 在数学上是 0,整个答案就变成 0 了。注意区分:求 gcd 时初值取 0(因为 gcd(0,x)=x),求 lcm 时初值取 1。

📖 关键几行怎么看
代码作用为什么这样写
long long ans = 1初值lcm 的单位元是 1
__gcd(ans, a[i])求 gcdC++ 内置函数,等价于辗转相除
ans / __gcd(...) * a[i]先除后乘避免中间结果溢出
long long类型LCM 可能很大
⚠️三个坑:① 写成 ans * a[i] / __gcd(ans, a[i])(先乘会溢出);② 初值取 0 而不是 1;③ 用 int 存结果。

边界测试 &amp; 易错点
🧪 边界测试用例表
写完程序后,用这些数据自查一遍:
输入答案考察点
3
1 2 36题面样例 1
4
2 4 8 1616题面样例 2:都是倍数关系
4
2 4 6 824题面样例 3
1
77只有一位同学,周期就是答案
2
1 11都是 1,明天就全员同练
3
6 10 1530lcm(6,10)=30,lcm(30,15)=30
✅自查清单:① 初值是 1 吗?② 先除后乘了吗?③ 用 long long 吗?

🚨 易错点清单
⚠️先乘后除:写成 ans * a[i] / gcd 会让中间结果过大而溢出。

⚠️初值取 0:lcm(0, x) = 0,答案会全错。LCM 的初值应取 1。

⚠️用 int:LCM 可能超出 int 范围,用 long long。

复杂度分析
📊 复杂度四宫格
时间复杂度
O(n log A)

空间复杂度
O(n)

n
本题不大

每次 gcd
O(log A)

时间怎么算的?
n 次循环
每次做一次 gcd(辗转相除),O(log A)
合计 O(n log A)
空间都用在哪?
需要存下 n 个周期(也可以边读边算,省掉数组)。
✅ 运算量极小,瞬间完成。关键是把问题识别成 LCM,以及注意"先除后乘"防溢出。

知识拓展
🔗 常用技巧小抄
// 最大公约数(辗转相除)
long long gcd(long long a, long long b) {
while (b) { long long t = a % b; a = b; b = t; }
return a;
}

// 最小公倍数:必须先除后乘
long long lcm(long long a, long long b) {
return a / gcd(a, b) * b;
}

// 多个数的 LCM
long long ans = 1;
for (int i = 0; i < n; i++) ans = lcm(ans, nums[i]);

// 记忆要点
// gcd 的单位元 = 0 (gcd(0, x) = x)
// lcm 的单位元 = 1 (lcm(1, x) = x)

// 溢出检查(如果需要)
if (a / gcd(a,b) > LLONG_MAX / b) { /* 会溢出 */ }

🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
LCM 模型同时发生 ⟺ 取最小公倍数周期问题、相遇问题、齿轮咬合
辗转相除求 gcd 的高效方法所有数论题目
先除后乘避免中间结果溢出所有涉及 lcm / 乘除的题
🌟思考题:如果题目改成"求上一次全员同时锻炼是几天前",答案会变吗?(提示:不会变——因为"同时锻炼"的事件是周期性发生的,周期恰好是 LCM。所以"下一次"和"上一次"的间隔都是 LCM。这体现了周期性问题中"往返时间对称"的特点。)

💻 参考代码
#include &lt;bits/stdc++.h&gt;

using namespace std;



long long a[100];



int main() {

    int n;

    scanf(&quot;%d&quot;, &amp;n);

    for (int i = 0; i &lt; n; i++) scanf(&quot;%lld&quot;, &amp;a[i]);



    long long ans = 1;                        // LCM 的单位元是 1

    for (int i = 0; i &lt; n; i++) {

        // 先除后乘,避免 ans * a[i] 这一步溢出

        ans = ans / __gcd(ans, a[i]) * a[i];

    }



    printf(&quot;%lld\n&quot;, ans);

    return 0;

}
💻 参考代码
// 最大公约数(辗转相除)

long long gcd(long long a, long long b) {

    while (b) { long long t = a % b; a = b; b = t; }

    return a;

}



// 最小公倍数:必须先除后乘

long long lcm(long long a, long long b) {

    return a / gcd(a, b) * b;

}



// 多个数的 LCM

long long ans = 1;

for (int i = 0; i &lt; n; i++) ans = lcm(ans, nums[i]);



// 记忆要点

// gcd 的单位元 = 0   (gcd(0, x) = x)

// lcm 的单位元 = 1   (lcm(1, x) = x)



// 溢出检查(如果需要)

if (a / gcd(a,b) &gt; LLONG_MAX / b) { /* 会溢出 */ }
P14918相等序列2025-12 · 贪心 / 数论 / 素数判断
贪心数论素数判断
📝 题目描述
小 A 有一个包含 N 个正整数的序列 A={A_1,A_2,…,A_N}。小 A 每次可以花费 1 个金币执行以下任意一种操作:

- 选择序列中一个正整数 A_i(1≤ i≤ N),将 A_i 变为 A_i× P,P 为任意质数;
- 选择序列中一个正整数 A_i(1≤ i≤ N),将 A_i 变为 \frac{A_i}{P},P 为任意质数,要求 A_i 是 P 的倍数。

小 A 想请你帮他计算出令序列中所有整数都相同,最少需要花费多少金币。

⌨️ 输入格式
第一行一个正整数 N,含义如题面所示。

第二行包含 N 个正整数 A_1,A_2,…,A_N,代表序列 A。

🖨 输出格式
输出一行,代表最少需要花费的金币数量。
🔎 样例
#输入输出
1
5
10 6 35 105 42
8
📌 说明 / 数据范围
对于 60% 的测试点,保证 1≤ N,A_i≤ 100。

对于所有测试点,保证 1≤ N,A_i≤ 10^5。

💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
题目拆解
📝 题目原文
给定 N 个正整数。每次可花 1 个金币执行以下操作之一:
把某个 Aᵢ 变成 Aᵢ × P(P 为任意质数)
把某个 Aᵢ 变成 Aᵢ / P(P 为任意质数,要求 Aᵢ 是 P 的倍数)
求让序列中所有整数都相等所需的最少金币数。
💡人话翻译:每次操作相当于给某个数的质因数分解中某个质数的指数加 1 或减 1。要让所有数相等,就要让每个质数的指数在所有数中变成同一个值——而"让一组数变成相同"的最优值是它们的中位数(绝对值之和最小)。关键是:不同质数之间完全独立,可以分别处理。

🔍 关键词提取
质因数分解指数向量中位数性质独立分解
已知条件
项目说明
输入第一行 N;第二行 N 个正整数
输出最少金币数
数据范围1 ≤ N ≤ 10⁵,1 ≤ Aᵢ ≤ 10⁵
操作代价每个指数 ±1 花 1 金币
目标所有数完全相等
需要解决的问题
把数看成什么?一个"指数向量":对每个质数 p 记录它的指数
操作改变了什么?只改变某一个质数的指数(±1)
怎么求最小代价?对每个质数独立处理:把 N 个指数排好,让它们都变成中位数,代价是各指数与中位数的距离之和

思维导图
🧮 按质数独立取中位数

🔬 分解
对每个 Aᵢ 质因数分解
得到"质数 → 指数"表
Aᵢ ≤ 10⁵
用线性筛求最小质因子

🧩 独立分解
每个质数互不影响
因为操作只改一个指数
所以可以分开算再相加
这是关键洞察

📐 取中位数
把该质数在各数的指数收集起来
排序取中位数 m
代价 = Σ|eᵢ − m|
中位数使绝对差之和最小

⚠️ 易错点
忘了大质因子(如 105 的 7)
以为是取平均数
用筛法时数组开小
代价求和用 long long

样例手算推导
🧮 样例:A = {10, 6, 35, 105, 42},答案 8
先做质因数分解,列出每个数的指数向量。
Aᵢ分解2 的指数3 的指数5 的指数7 的指数
102 × 51010
62 × 31100
355 × 70011
1053 × 5 × 70111
422 × 3 × 71101
1
质数 2:指数列 [1, 1, 0, 0, 1]
排序后 0、0、1、1、1,中位数 = 1
代价 = |1−1| + |1−1| + |0−1| + |0−1| + |1−1|
= 0 + 0 + 1 + 1 + 0 = 2
质数 2 的代价:2

2
质数 3:指数列 [0, 1, 0, 1, 1]
排序后 0、0、1、1、1,中位数 = 1
代价 = 1 + 0 + 1 + 0 + 0 = 2
质数 3 的代价:2

3
质数 5:指数列 [1, 0, 1, 1, 0]
排序后 0、0、1、1、1,中位数 = 1
代价 = 0 + 1 + 0 + 0 + 1 = 2
质数 5 的代价:2

4
质数 7:指数列 [0, 0, 1, 1, 1]
中位数 = 1
代价 = 1 + 1 + 0 + 0 + 0 = 2
质数 7 的代价:2

📊 汇总
质数各数的指数中位数最小代价
21, 1, 0, 0, 112
30, 1, 0, 1, 112
51, 0, 1, 1, 012
70, 0, 1, 1, 112
合计——8
最少 8 金币 ✓
🔑为什么取中位数而不是平均数?数学结论:对于一组数,使 Σ|xᵢ − t| 最小的 t 就是中位数(而不是平均数,平均数对应的是平方和最小)。本题的代价正好是绝对差之和,所以取中位数。

🧮 为什么各质数可以独立处理
这是本题最关键的洞察,务必理解。
1
一次操作的影响范围
操作是"乘或除以一个质数 P"
这只会让 P 的指数变化 ±1
所有其他质数的指数完全不变
不同质数的指数互不干扰

2
因此可以拆开算
最终目标:所有数的指数向量相同
等价于:对每个质数 p,所有数的 p 指数都相同
总代价 = 各质数代价之和
每个质数单独求最小值
✅ 独立分解,答案相加

3
举个反例理解"独立"
假设 A = {4, 8}(即 2² 和 2³)
只需把 8 除以 2(花 1 金币)→ 都是 4
这里只有质数 2 需要调整
其他质数的指数都是 0,代价为 0
✅ 代价 1

⚠️注意质数表要覆盖所有出现的质因子:比如 105 = 3 × 5 × 7,质数 7 也必须纳入统计。所以实现时应该动态收集所有出现过的质数(用哈希表记录"质数 → 指数列表"),而不是只处理某个固定范围内的小质数。

解法对比
⚔️ 解法对比
🟢 质因数分解 + 中位数(推荐) 推荐
分解出每个质数的指数列表,各自取中位数算代价
时间 O(N log A)
N, A ≤ 10⁵ 轻松通过
思路清晰、可证明最优
代码 40 行左右
💡核心实现:用 unordered_map<int, vector<int>> 记录"质数 → 各数中该质数的指数",然后对每个 vector 排序取中位数、累加绝对差。注意指数为 0 的情况也要计入。

🟠 枚举"目标值"
枚举可能的目标数 t,计算把所有数变成 t 的代价
候选 t 太多(可能上万个)
每次计算代价 O(N log A)
复杂度过高
而且 t 的取值难以界定
⚠️为什么不行:目标值可能是任何正整数,比如 {6, 10} 的最优目标是 30(乘 5 和乘 3,各花 1)或 2(除以 2 和 5,花 2)…目标值空间太大,无法有效枚举。而从"指数维度"看问题,每个质数的候选值就只有 0 ~ 最大指数那几种,取中位数一步到位。

📈 性能对比
方案复杂度可行性
指数维度 + 中位数O(N log A)✅ 可行
枚举目标数值不可控❌ 不可行

算法流程图
开始筛出最小质因子表 spf[](到 10⁵)对每个 Aᵢ 做质因数分解把"质数 p → 指数 e"记录到 map<p, vector> 中对每个质数:把该质数在各数中的指数收集成完整列表(补 0)对指数列表排序,取中位数 m累加 Σ|eᵢ − m| 到答案输出总代价结束还有数字 → 继续分解← 左右滑动查看完整流程图
动手算一算
🧮 相等序列最小代价计算器

输入一组正整数,程序会分解质因数、按质数取中位数并累加代价。

输入序列


算一下!
随机出题


结果会显示在这里

点按钮开始 →

代码精讲
💻 完整 C++ 代码
include <bits/stdc++.h>
using namespace std;

const int MAXV = 100005;
int spf[MAXV]; // 最小质因子(smallest prime factor)

int main() {
// 线性筛:预处理每个数的最小质因子
for (int i = 0; i < MAXV; i++) spf[i] = i;
for (int i = 2; (long long)i * i < MAXV; i++) {
if (spf[i] == i) { // i 是质数
for (int j = i * i; j < MAXV; j += i)
if (spf[j] == j) spf[j] = i;
}
}

int n;
scanf("%d", &n);

// 记录"质数 -> 各数中该质数的指数列表"
unordered_map<int, vector<int>> exps;

for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
while (x > 1) {
int p = spf[x];
int e = 0;
while (x % p == 0) { x /= p; e++; }
exps[p].push_back(e);
}
}

long long ans = 0;
for (auto &kv : exps) {
vector<int> v = kv.second;
// 指数为 0 的数也要计入(它们没贡献到这个 vector 里)
while ((int)v.size() < n) v.push_back(0);

sort(v.begin(), v.end());
int med = v[n / 2]; // 中位数
for (int e : v) ans += abs(e - med); // 累加绝对差
}

printf("%lld\n", ans);
return 0;
}
🔑为什么要把 v 补到长度为 n?因为某个质数并不是在所有数里都出现。比如质数 7 只在 35、105、42 里出现,在 10、6 里的指数是 0。这些 0 也必须参与"求中位数"——否则中位数会偏大,代价算错。所以要把缺失的位置补 0。

📖 关键几行怎么看
代码作用为什么这样写
spf[] 筛法预处理最小质因子让分解变成"每次跳到一个质因子",效率高
while (x % p == 0) { x /= p; e++; }统计指数同一质因子可能重复出现多次
while (v.size() < n) v.push_back(0);补零缺失的小数要按指数 0 计入
int med = v[n / 2];取中位数排序后取中间位置,绝对差之和最小
⚠️三个坑:① 没有把缺失的位置补 0(中位数偏大,答案偏小);② 忘了大质因子(105 的 7 也要统计);③ 答案可能较大,累加用 long long。

边界测试 &amp; 易错点
🧪 边界测试用例表
写完程序后,用这些数据自查一遍:
输入答案考察点
5
10 6 35 105 428题面样例
1
70只有一个数,已经相等
2
4 818 除以 2 得到 4,花 1 金币
3
2 2 20本来就全部相等
2
6 1026 = 2×3、10 = 2×5;质数 3 指数 [1,0] 代价 1,质数 5 指数 [0,1] 代价 1,共 2
2
1 10全为 1
✅自查清单:① 每个质数的指数列表补齐到 n 了吗?② 大质因子统计了吗?③ 答案是 long long 吗?

🚨 易错点清单
⚠️忘记补 0:某质数不在所有数中出现时,缺失位置的指数应视为 0 参与中位数计算。

⚠️漏掉大质因子:105 = 3 × 5 × 7,质数 7 也要统计。

⚠️用平均数代替中位数:最小化绝对差之和要用中位数。

复杂度分析
📊 复杂度四宫格
时间复杂度
O(N log A + A log log A)

空间复杂度
O(A + 质数数 × N)

N, A 最大
10⁵

运算量
约 10⁶

时间怎么算的?
筛法预处理最小质因子:约 O(A log log A)
每个数分解质因数:O(log A)
每个质数排序指数列表:涉及的总元素数不超过 N log A
合计约 O(N log A)
空间都用在哪?
需要 spf 数组(10⁵)和"质数 → 指数列表"的哈希表。
✅ 整体约 10⁶ 量级,瞬间完成。关键是把问题从"数值"转换到"指数维度"。

知识拓展
🔗 常用技巧小抄
// 最小质因子筛(线性/埃氏变体)
int spf[MAXV];
for (int i = 0; i < MAXV; i++) spf[i] = i;
for (int i = 2; (long long)i * i < MAXV; i++)
if (spf[i] == i)
for (int j = i * i; j < MAXV; j += i)
if (spf[j] == j) spf[j] = i;

// 用 spf 做质因数分解
while (x > 1) {
int p = spf[x], e = 0;
while (x % p == 0) { x /= p; e++; }
// 处理 (p, e)
}

// 中位数性质:使 Σ|xᵢ - t| 最小的 t 是中位数
// 应用场景:
// - 一维"仓库选址"(使运输距离和最小)
// - 本题(使指数调整次数最少)
// - 各类"最小化绝对偏差和"问题

🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
质因数分解用 spf 快速分解数论、约数、gcd/lcm 类题目
指数维度视角把整数看作指数向量乘法/除法操作类问题
中位数最优最小化绝对差之和选址、对齐、调整代价类问题
🌟思考题:如果操作改成"每次把 Aᵢ 加 1 或减 1"(花 1 金币),做法会一样吗?(提示:会一样——那时的最优目标还是所有数的中位数,代价也是绝对差之和。但注意本题是"乘除质数"操作,所以要在指数维度上取中位数,而不是在数值本身取中位数——这是一个容易混淆的关键区别。)

💻 参考代码
#include &lt;bits/stdc++.h&gt;

using namespace std;



const int MAXV = 100005;

int spf[MAXV];                          // 最小质因子(smallest prime factor)



int main() {

    // 线性筛:预处理每个数的最小质因子

    for (int i = 0; i &lt; MAXV; i++) spf[i] = i;

    for (int i = 2; (long long)i * i &lt; MAXV; i++) {

        if (spf[i] == i) {              // i 是质数

            for (int j = i * i; j &lt; MAXV; j += i)

                if (spf[j] == j) spf[j] = i;

        }

    }



    int n;

    scanf(&quot;%d&quot;, &amp;n);



    // 记录&quot;质数 -&gt; 各数中该质数的指数列表&quot;

    unordered_map&lt;int, vector&lt;int&gt;&gt; exps;



    for (int i = 0; i &lt; n; i++) {

        int x;

        scanf(&quot;%d&quot;, &amp;x);

        while (x &gt; 1) {

            int p = spf[x];

            int e = 0;

            while (x % p == 0) { x /= p; e++; }

            exps[p].push_back(e);

        }

    }



    long long ans = 0;

    for (auto &amp;kv : exps) {

        vector&lt;int&gt; v = kv.second;

        // 指数为 0 的数也要计入(它们没贡献到这个 vector 里)

        while ((int)v.size() &lt; n) v.push_back(0);



        sort(v.begin(), v.end());

        int med = v[n / 2];                       // 中位数

        for (int e : v) ans += abs(e - med);       // 累加绝对差

    }



    printf(&quot;%lld\n&quot;, ans);

    return 0;

}
💻 参考代码
// 最小质因子筛(线性/埃氏变体)

int spf[MAXV];

for (int i = 0; i &lt; MAXV; i++) spf[i] = i;

for (int i = 2; (long long)i * i &lt; MAXV; i++)

    if (spf[i] == i)

        for (int j = i * i; j &lt; MAXV; j += i)

            if (spf[j] == j) spf[j] = i;



// 用 spf 做质因数分解

while (x &gt; 1) {

    int p = spf[x], e = 0;

    while (x % p == 0) { x /= p; e++; }

    // 处理 (p, e)

}



// 中位数性质:使 Σ|xᵢ - t| 最小的 t 是中位数

// 应用场景:

//   - 一维&quot;仓库选址&quot;(使运输距离和最小)

//   - 本题(使指数调整次数最少)

//   - 各类&quot;最小化绝对偏差和&quot;问题
P11961原根判断2025-03 · 原根 / 数论
原根数论
📝 题目描述
小 A 知道,对于质数 p 而言,p 的原根 g 是满足以下条件的正整数:

+ 1<g<p;
+ g^{p-1}\bmod{p}=1;
+ 对于任意 1≤ i<p-1 均有 g^i\bmod{p}≠q1。

其中 a\bmod{p} 表示 a 除以 p 的余数。

小 A 现在有一个整数 a,请你帮他判断 a 是不是 p 的原根。

⌨️ 输入格式
第一行,一个正整数 T,表示测试数据组数。

每组测试数据包含一行,两个正整数 a,p。

🖨 输出格式
对于每组测试数据,输出一行,如果 a 是 p 的原根则输出 Yes,否则输出 No。
🔎 样例
#输入输出
1
3
3 998244353
5 998244353
7 998244353
Yes
Yes
No
📌 说明 / 数据范围
数据范围
对于 40% 的测试点,保证 3≤ p≤10^3。

对于所有测试点,保证 1≤ T≤20,3≤ p≤10^9,1<a<p,p 为质数。

💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
题目拆解
📝 题目原文
对于质数 p,若正整数 g 满足:
1 < g < p
g^(p−1) mod p = 1
对任意 1 ≤ i < p−1,都有 g^i mod p ≠ 1
则称 g 是 p 的原根。给定 T 组 (a, p),判断 a 是不是 p 的原根。
⚠️题目自己说明了:这题可能超出 GESP 考纲(原根是 NOI 8 级知识点,相对简单的费马小定理/欧拉定理也是 7 级)。所以这道题更适合当成"拓展学习",理解其中的数论思想比背代码更重要。

🔍 关键词提取
原根阶费马小定理快速幂质因数分解
已知条件
项目说明
输入第一行 T;随后 T 行每行 a、p
输出每行 Yes 或 No
数据范围1 ≤ T ≤ 20,3 ≤ p ≤ 10⁹,1 < a < p
保证p 是质数
判定目标a 的"阶"是否恰好等于 p−1
需要解决的问题
暴力验证太难:要逐一检查 i = 1…p−2,p 达 10⁹ 时不可能
关键定理:由费马小定理,a^(p−1) ≡ 1 (mod p) 总是成立(当 p 为质数且 p ∤ a);而 a 的阶一定是 p−1 的约数
所以只需检查"约数":a 的阶 不等于 p−1 ⟺ 存在 p−1 的质因子 q,使 a^((p−1)/q) ≡ 1 (mod p)。只需对 p−1 的每个质因子各测一次幂即可!

思维导图
🔮 阶 = p−1?只需查质因子

📚 基础概念
a 的"阶" = 最小的 d 使 a^d ≡ 1
费马小定理:a^(p−1) ≡ 1
所以阶必整除 p−1
原根 = 阶恰好等于 p−1

🔍 判定转化
若阶 ≠ p−1,则它整除 (p−1)/q
q 为 p−1 的某个质因子
等价于 a^((p−1)/q) ≡ 1
所以只需测这些幂

⚙️ 实现
分解 p−1 得全部不同质因子
对每个 q 算 a^((p−1)/q) mod p
任一为 1 → 不是原根
还要校验 a^(p−1) ≡ 1

⚠️ 易错点
枚举 i 到 p−1(不可能)
乘方时中间结果溢出
只测 p−1 的最大质因子
混淆"质因子"与"质因数(含重数)"

样例手算推导
🧮 样例:p = 998244353,a = 3 / 5 / 7
先把 p − 1 分解质因数。
1
分解 p − 1
p − 1 = 998244352
不断除以 2:998244352 = 2²³ × 119
119 = 7 × 17
所以 p − 1 = 2²³ × 7 × 17
不同的质因子是 2、7、17
质因子集合 {2, 7, 17}

2
需要检查的幂
对 q = 2:(p−1)/2 = 499122176
对 q = 7:(p−1)/7 = 142606336
对 q = 17:(p−1)/17 = 58720256
只要 a 的这三个幂中有一个 ≡ 1,a 就不是原根
测 3 个幂

aa^((p−1)/2)a^((p−1)/7)a^((p−1)/17)结论
3≠ 1≠ 1≠ 1Yes
5≠ 1≠ 1≠ 1Yes
7≠ 1= 1≠ 1No
输出 Yes、Yes、No ✓
🔑注意 a = 7 时为什么不是原根:因为 7^((p−1)/7) ≡ 1 (mod p),说明 7 的阶整除 (p−1)/7,比 p−1 小,所以它不可能遍历全部非零余数("生成"整个乘法群)——它不是原根。
原根的直观意义是"一个能生成所有非零余数的底数"。

🧮 用一个小质数彻底搞懂
取 p = 7(p − 1 = 6 = 2 × 3,质因子 {2, 3})。检查 a = 3 和 a = 2。
aa^1a^2a^3a^4a^5a^6阶
33264516
22412413
1
a = 3 是原根
3 的幂依次是 3, 2, 6, 4, 5, 1
恰好把 1 ~ 6 全部走了一遍
阶 = 6 = p − 1 ✓
用定理验证:(p−1)/2 = 3,3³ = 27 mod 7 = 6 ≠ 1 ✓
(p−1)/3 = 2,3² = 9 mod 7 = 2 ≠ 1 ✓
两个都不为 1 → 是原根
✅ 输出 Yes

2
a = 2 不是原根
2 的幂:2, 4, 1, 2, 4, 1…(周期 3)
只覆盖了 {1, 2, 4},走不到 3、5、6
阶 = 3 ≠ 6
用定理验证:(p−1)/3 = 2,2² = 4 mod 7 = 4 ≠ 1 ✓
(p−1)/2 = 3,2³ = 8 mod 7 = 1 ✗
有一个为 1 → 不是原根
❌ 输出 No

p = 7 的原根是 3 和 5(共 φ(6) = 2 个)
💡这个例子把整个定理讲透了:"阶不等于 p−1"意味着"存在更小的指数让 a 回到 1",而这样的更小指数一定整除 (p−1)/q(q 是 p−1 的某个质因子)。所以只要把 (p−1)/q 这几种指数测一遍就够了。

解法对比
⚔️ 解法对比
🟢 定理判定 + 快速幂(推荐) 推荐
分解 p−1,对每个质因子 q 测 a^((p−1)/q) mod p
每次判定 O(√p + ω(p−1) log p)
p = 10⁹ 时约 3 × 10⁴ + 几十次幂
代码 45 行
有数论定理保证
💡三个必备组件:① 快速幂(二进制幂,O(log p));② 质因数分解(试除到 √(p−1));③ 结论——只需检查 (p−1)/q 这些指数。注意乘方时 a*b 可能到 10¹⁸,用 long long 刚好不溢出。

🟠 暴力枚举指数 i
对 i = 1…p−2 依次判断 a^i mod p 是否为 1
时间 O(p) = 10⁹
T = 20 时高达 2 × 10¹⁰
必然超时
只适用于 p ≤ 10³ 的测试点
⚠️注意数据分档:40% 的测试点 p ≤ 10³(暴力可得 40 分),但全部测试点 p ≤ 10⁹,想满分必须用定理。

📈 性能对比
方案单次判定(p = 10⁹)可行性
定理 + 快速幂约 3 × 10⁴✅ 稳过
暴力枚举指数约 10⁹❌ 超时

算法流程图
开始读入 T,循环处理每组 (a, p)把 m = p − 1 做质因数分解,得到不同质因子的集合 Qa 是否满足 1 < a < p?是 ✓继续判定否 ✗输出 No遍历 Q 中每个质因子 q计算 a^((p−1)/q) mod p(用快速幂)结果是否等于 1?是 ✓不是原根,输出 No否 ✗继续检查下一个 q所有 q 都检查完且都不为 1 → 输出 Yes结束取下一个质因子← 左右滑动查看完整流程图
动手算一算
🔮 原根判定器

第一行输入 T,随后 T 行输入 a 和 p,程序会分解 p−1 并逐项验证。

输入数据3
3 998244353
5 998244353
7 998244353


算一下!
随机出题


结果会显示在这里

点按钮开始 →

代码精讲
💻 完整 C++ 代码
include <bits/stdc++.h>
using namespace std;

// 快速幂:计算 (b^e) mod m
long long powmod(long long b, long long e, long long m) {
long long r = 1 % m;
b %= m;
while (e > 0) {
if (e & 1) r = r * b % m; // a*b < 10^18,long long 不会溢出
b = b * b % m;
e >>= 1;
}
return r;
}

int main() {
int T;
scanf("%d", &T);

while (T--) {
long long a, p;
scanf("%lld %lld", &a, &p);

if (a <= 1 || a >= p) { puts("No"); continue; }

long long m = p - 1;

// 分解 m,收集不同的质因子
vector<long long> primes;
long long t = m;
for (long long i = 2; i * i <= t; i++) {
if (t % i == 0) {
primes.push_back(i);
while (t % i == 0) t /= i; // 除干净,只保留"不同"质因子
}
}
if (t > 1) primes.push_back(t);

// 对每个质因子 q,检查 a^((p-1)/q) mod p 是否等于 1
bool ok = true;
for (long long q : primes) {
if (powmod(a, m / q, p) == 1) { ok = false; break; }
}

puts(ok ? "Yes" : "No");
}
return 0;
}
🔑为什么"任意一个 a^((p−1)/q) ≡ 1 就说明不是原根"?设 a 的阶为 d(最小的使 a^d ≡ 1 的正整数)。若 a^((p−1)/q) ≡ 1,则 d 整除 (p−1)/q,所以 d ≤ (p−1)/q < p−1——阶小于 p−1,不是原根。
反过来,如果阶 d < p−1,那么 d 整除 p−1 且 d ≠ p−1,于是存在 p−1 的质因子 q 使 d | (p−1)/q,从而 a^((p−1)/q) ≡ 1。两个方向都成立,所以判定是充要的。

📖 关键几行怎么看
代码作用为什么这样写
if (e & 1) r = r * b % m;快速幂二进制幂,O(log e)
while (t % i == 0) t /= i;分解去重只要不同质因子,所以除干净
if (t > 1) primes.push_back(t);剩余质因子试除结束后剩下的必是质数
powmod(a, m / q, p) == 1判定只要一个为 1 就不是原根
⚠️四个坑:① 枚举 i = 1…p−1 暴力判(p 达 10⁹ 必超时);② 分解时不去重(会把同一个质因子测很多遍,虽然不影响正确性但浪费时间);③ 快速幂里 r * b 用 int 会溢出;④ 忘记检查 1 < a < p(题目保证 a < p,但养成校验习惯)。

边界测试 &amp; 易错点
🧪 边界测试用例表
写完程序后,用这些数据自查一遍:
输入答案考察点
3
3 998244353 / 5 998244353 / 7 998244353Yes
Yes
No题面样例
2
3 7 / 2 7Yes
Nop = 7:3 是原根(3⁶ 走遍 1~6),2 不是(2³ ≡ 1)
2
2 3 / 5 3Yes
Nop = 3:2 是原根;5 超出范围应输出 No
1
1 7Noa = 1 不满足 a > 1
3
3 998244353 / 5 998244353 / 7 998244353Yes
Yes
No重复验证题面样例
✅自查清单:① 分解了 p−1 吗?② 测了每个质因子吗?③ 快速幂用 long long 吗?

🚨 易错点清单
⚠️暴力枚举指数:p 达 10⁹,枚举 i 到 p−1 必然超时,必须用"只测 p−1 的质因子对应幂"这个定理。

⚠️快速幂溢出:模数 p ≤ 10⁹,a * b 可达 10¹⁸,要用 long long。

⚠️只测最大质因子:必须测 p−1 的每一个不同质因子。

复杂度分析
📊 复杂度四宫格
时间复杂度
O(√p + ω(p−1) · log p)

空间复杂度
O(1)

T 最大
20

单次判定
约 3 × 10⁴

时间怎么算的?
分解 p−1:试除到 √p,约 3 × 10⁴ 次
ω(p−1) 是 p−1 的不同质因子个数,很少(≤ 9)
每个质因子做一次快速幂 O(log p) ≈ 30
T = 20 时总计约 6 × 10⁵
空间都用在哪?
只需存下质因子列表(很短)。
✅ 约 60 万次操作,瞬间完成。关键在于把"检查 p−2 个指数"压缩成"检查几个质因子对应的指数"。

知识拓展
🔗 常用技巧小抄
// 快速幂模板
long long powmod(long long b, long long e, long long m) {
long long r = 1 % m; b %= m;
while (e > 0) {
if (e & 1) r = r * b % m;
b = b * b % m;
e >>= 1;
}
return r;
}

// 分解并收集"不同质因子"
vector<long long> distinctPrimes(long long x) {
vector<long long> v;
for (long long i = 2; i * i <= x; i++)
if (x % i == 0) { v.push_back(i); while (x % i == 0) x /= i; }
if (x > 1) v.push_back(x);
return v;
}

// 与本题相关的数论结论
// - 费马小定理:p 为质数且 p ∤ a 时 a^(p-1) ≡ 1 (mod p)
// - 阶 d 必整除 p-1
// - a 是原根 <=> 对 p-1 的每个质因子 q,a^((p-1)/q) ≢ 1 (mod p)
// - p 的原根个数 = φ(p-1)
// - 求最小原根可以从 2 开始逐个试,通常很快

🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
快速幂二进制幂,O(log e)所有大指数取模问题
阶与整除a 的阶必整除 p−1原根、离散对数、循环群
质因子筛选只需测 p−1 的质因子对应幂"把 O(p) 判定压到 O(log p)"的关键
🌟思考题:如果题目改成"求 p 的最小原根",该怎么做?(提示:从 2 开始逐个试,对每个候选用本题的判定方法检查,找到第一个通过的即可。理论上可以证明最小原根是 O(p^(1/4+ε)) 级别的,所以实践中很快。它属于 NOIP 提高组 / NOI 级别的数论内容,这里作为拓展了解即可。)

💻 参考代码
#include &lt;bits/stdc++.h&gt;

using namespace std;



// 快速幂:计算 (b^e) mod m

long long powmod(long long b, long long e, long long m) {

    long long r = 1 % m;

    b %= m;

    while (e &gt; 0) {

        if (e &amp; 1) r = r * b % m;      // a*b &lt; 10^18,long long 不会溢出

        b = b * b % m;

        e &gt;&gt;= 1;

    }

    return r;

}



int main() {

    int T;

    scanf(&quot;%d&quot;, &amp;T);



    while (T--) {

        long long a, p;

        scanf(&quot;%lld %lld&quot;, &amp;a, &amp;p);



        if (a &lt;= 1 || a &gt;= p) { puts(&quot;No&quot;); continue; }



        long long m = p - 1;



        // 分解 m,收集不同的质因子

        vector&lt;long long&gt; primes;

        long long t = m;

        for (long long i = 2; i * i &lt;= t; i++) {

            if (t % i == 0) {

                primes.push_back(i);

                while (t % i == 0) t /= i;   // 除干净,只保留&quot;不同&quot;质因子

            }

        }

        if (t &gt; 1) primes.push_back(t);



        // 对每个质因子 q,检查 a^((p-1)/q) mod p 是否等于 1

        bool ok = true;

        for (long long q : primes) {

            if (powmod(a, m / q, p) == 1) { ok = false; break; }

        }



        puts(ok ? &quot;Yes&quot; : &quot;No&quot;);

    }

    return 0;

}
💻 参考代码
// 快速幂模板

long long powmod(long long b, long long e, long long m) {

    long long r = 1 % m; b %= m;

    while (e &gt; 0) {

        if (e &amp; 1) r = r * b % m;

        b = b * b % m;

        e &gt;&gt;= 1;

    }

    return r;

}



// 分解并收集&quot;不同质因子&quot;

vector&lt;long long&gt; distinctPrimes(long long x) {

    vector&lt;long long&gt; v;

    for (long long i = 2; i * i &lt;= x; i++)

        if (x % i == 0) { v.push_back(i); while (x % i == 0) x /= i; }

    if (x &gt; 1) v.push_back(x);

    return v;

}



// 与本题相关的数论结论

// - 费马小定理:p 为质数且 p ∤ a 时 a^(p-1) ≡ 1 (mod p)

// - 阶 d 必整除 p-1

// - a 是原根 &lt;=&gt; 对 p-1 的每个质因子 q,a^((p-1)/q) ≢ 1 (mod p)

// - p 的原根个数 = φ(p-1)

// - 求最小原根可以从 2 开始逐个试,通常很快
②编程打卡 · 点一下就能勾选
☑ 已勾选 0 / 8 项点一下条目即可勾选
五级 · 编程 DAY 03

排序与结构体

💻 编程题 7 道📚 知识点 排序与结构体⏱ 建议用时 205 分钟
①本日知识点 · 排序与结构体

结构体存全部字段,cmp 写清「谁是第一关键字」。

本组 7 道题全部来自 GESP 真题,按「排序与结构体」归在一起练。题面取洛谷原题(含公式与样例),题解取美力程 GESP 题解库(思路 + 参考代码 + 复杂度)。

B3872巧夺大奖2023-09 · 贪心 / 结构体
贪心结构体
📝 题目描述
小明参加了一个巧夺大奖的游戏节目。主持人宣布了游戏规则:

1. 游戏分为 n 个时间段,参加者每个时间段可以选择一个小游戏。

2. 游戏中共有 n 个小游戏可供选择。

3. 每个小游戏有规定的时限和奖励。对于第 i 个小游戏,参加者必须在第 T_i 个时间段结束前完成才能得到奖励 R_i。

小明发现,这些小游戏都很简单,不管选择哪个小游戏,他都能在一个时间段内完成。关键问题在于,如何安排每个时间段分别选择哪个小游戏,才能使得总奖励最高?

⌨️ 输入格式
输入第一行,包含一个正整数 n。n 既是游戏时间段的个数,也是小游戏的个数。约定 1≤ n≤500。

输入第二行,包含 n 个正整数。第 i 个正整数为 T_i,即第 i 个小游戏的完成期限。约定 1≤ T_i≤ n。

输入第三行,包含 n 个正整数。第 i 个正整数为 R_i,即第 i 个小游戏的完成奖励。约定 1≤ R_i≤ 1000。

🖨 输出格式
输出一行,包含一个正整数 C,为最高可获得的奖励。
🔎 样例
#输入输出
1
7
4 2 4 3 1 4 6
70 60 50 40 30 20 10
230
📌 说明 / 数据范围
样例解释 1

7 个时间段可分别安排完成第 4、2、3、1、6、7、5 个小游戏,其中第 4、2、3、1、7 个小游戏在期限内完成。因此,可以获得总计 40+60+50+70+10=230 的奖励。

💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
题目拆解
📝 题目原文
游戏分 n 个时间段,共有 n 个小游戏。第 i 个游戏必须在第 Tᵢ 个时间段结束前完成,完成后获得奖励 Rᵢ。每个时间段只能做一个小游戏。
求能获得的最大总奖励。
💡人话翻译:典型的"任务调度 + 截止期限"贪心模型。策略是:按奖励从高到低处理每个游戏,每个游戏尽量安排在不超过它截止期限的最晚空位上。
"越贵越先安排、能拖就往后拖"——把前面的空位留给截止期更紧的游戏。

🔍 关键词提取
贪心截止期限调度空位分配按价值排序
已知条件
项目说明
输入第一行 n;第二行 Tᵢ;第三行 Rᵢ
输出最大总奖励
数据范围1 ≤ n ≤ 500
期限1 ≤ Tᵢ ≤ n
奖励1 ≤ Rᵢ ≤ 1000
需要解决的问题
为什么按奖励降序?因为每个时间段只放一个游戏,优先保证"贵的游戏"能安排上
为什么要放在"最晚空位"?把靠前的时间段留给截止期更早的游戏;如果放在最早空位,可能挤掉别的游戏
安排不上怎么办?直接放弃这个游戏(不选它)

思维导图
🏆 按奖励降序 + 最晚空位

📊 预处理
把游戏按奖励降序排列
每个游戏带截止期 Tᵢ
用一个数组标记时间段是否被占
时间段编号 1 ~ n

🔁 逐个安排
取当前奖励最大的游戏
从 min(Tᵢ, n) 往前找空位
找到就占用并累加奖励
找不到就放弃

🧠 为什么对
贵的游戏优先保证
能拖就拖,保留前面的空位
前面的空位对"期限紧"的游戏更宝贵
交换论证可证最优

⚠️ 易错点
按奖励升序(反了)
放在"最早空位"(会挤掉别人)
忘记 Tᵢ 可能超过 n
没有跳过安排不上的游戏

样例手算推导
🧮 样例:n = 7
截止期 T = [4, 2, 4, 3, 1, 4, 6],奖励 R = [70, 60, 50, 40, 30, 20, 10]。
1
第 1 步:按奖励降序排列
游戏 1:T=4,R=70
游戏 2:T=2,R=60
游戏 3:T=4,R=50
游戏 4:T=3,R=40
游戏 5:T=1,R=30
游戏 6:T=4,R=20
游戏 7:T=6,R=10
已按 R 降序

2
第 2 步:逐个安排
游戏 1(T=4):4 号位空闲 → 占 4 号,+70
游戏 2(T=2):2 号位空闲 → 占 2 号,+60
游戏 3(T=4):≤4 的最晚空位是 3 号 → 占 3 号,+50
游戏 4(T=3):≤3 的空位只剩 1 号 → 占 1 号,+40
游戏 5(T=1):≤1 的空位全被占 → 放弃
游戏 6(T=4):≤4 的 1~4 号全被占 → 放弃
游戏 7(T=6):≤6 的最晚空位是 5 号 → 占 5 号,+10
✅ 总计 230

📊 时间段的最终安排
时间段安排的游戏该游戏期限获得奖励
1游戏 4340
2游戏 2260
3游戏 3450
4游戏 1470
5游戏 7610
6(空)—0
7(空)—0
40 + 60 + 50 + 70 + 10 = 230 ✓
🔑为什么游戏 4 放在 1 号位而不是 3 号位?因为 3 号位、4 号位已经被更贵的游戏占了。游戏 4 的期限是 3,所以在 ≤3 的范围里能用的最晚位置是 1 号(2、3 已占)。注意"最晚空位"是"在已占情况下能找到的最晚位置",而不是"Tᵢ 本身"。

🧮 为什么"能拖就拖"是最优的
用一个交换论证来说明。
1
假设反例
某个最优方案里,把游戏 A(期限 T_A)放在了较早的 s 号位,而较晚的 t 号位(s < t ≤ T_A)放了游戏 B 或空着
可以改进

2
交换一下
把 A 移到 t 号位(仍然满足 t ≤ T_A)
A 的完成时间变晚但仍在期限内 ✓
如果 t 号位原本是空的,直接移过去,没损失
如果是游戏 B,把 B 移到 s 号位
B 会受影响吗?

3
B 是否仍合法
B 从 t 移到 s(更早),完成时间提前
提前完成当然仍在期限内 ✓
所以交换后两个游戏都合法,总奖励不变
说明"尽量往后放"不会更差
✅ 得证

⚠️这就是"贪心 + 交换论证"的典型套路:先猜测一个贪心策略,再用"交换任意两个元素不会变差"来证明它最优。写题解时能说清这个道理,比只背模板有价值得多。

解法对比
⚔️ 解法对比
🟢 按奖励贪心 + 最晚空位(推荐) 推荐
奖励降序,每个游戏放到 ≤ Tᵢ 的最晚空位
时间 O(n²)
n = 500 时约 25 万次
代码 20 行
有交换论证支撑
💡实现:used[1..n] 标记时间段占用;对每个游戏从 min(T[i], n) 往前找第一个未占位置。还可以用并查集把找空位加速到近似 O(1)(本题不需要)。

🟠 状压 / 回溯搜索
枚举每个时间段选哪个游戏,回溯搜索最大值
复杂度指数级或 O(n!)
n = 500 完全不可行
只能处理 n ≤ 15 左右的规模
不适合本题
⚠️注意:本题 n 可达 500,搜索类做法根本不可能。而且这类"带截止期的任务选择"问题有确定的贪心最优解,不需要搜索。

📈 性能对比
方案复杂度(n = 500)可行性
贪心 + 最晚空位约 2.5 × 10⁵✅ 瞬间
回溯搜索指数级❌ 不可行

算法流程图
开始读入 n、数组 T、R;把游戏按 R 降序排列ans = 0;used[1..n] 全部标记为空依次处理每个游戏j = min(T[i], n),从 j 往前找第一个空位找到空位了吗?是 ✓占用该位置,ans += R[i]否 ✗放弃这个游戏所有游戏都处理完后输出 ans结束处理下一个游戏← 左右滑动查看完整流程图
动手算一算
🏆 最优调度计算器

第一行输入 n,第二行输入截止期 T,第三行输入奖励 R。

输入数据7
4 2 4 3 1 4 6
70 60 50 40 30 20 10


算一下!
随机出题


结果会显示在这里

点按钮开始 →

代码精讲
💻 完整 C++ 代码
include <bits/stdc++.h>
using namespace std;

struct Game { int t, r, id; };

int main() {
int n;
scanf("%d", &n);

vector<Game> g(n);
for (int i = 0; i < n; i++) { scanf("%d", &g[i].t); g[i].id = i + 1; }
for (int i = 0; i < n; i++) scanf("%d", &g[i].r);

// 按奖励从高到低排序
sort(g.begin(), g.end(), [](const Game &a, const Game &b) {
return a.r > b.r;
});

vector<bool> used(n + 1, false); // 时间段 1 ~ n
int ans = 0;

for (int i = 0; i < n; i++) {
// 从 min(t, n) 往前找第一个空位
int j = min(g[i].t, n);
while (j >= 1 && used[j]) j--;

if (j >= 1) { // 找到空位就安排
used[j] = true;
ans += g[i].r;
}
// 找不到就放弃这个游戏
}

printf("%d\n", ans);
return 0;
}
🔑为什么循环上界写 min(t, n)?虽然题目保证 Tᵢ ≤ n,但养成"取 min"的习惯更安全——万一数据超出预期也不会数组越界。而搜索方向是从后往前,正是为了实现"能拖就拖"。

📖 关键几行怎么看
代码作用为什么这样写
a.r > b.r降序排序贵的游戏优先安排
int j = min(g[i].t, n)起始位置从期限处开始往前找
while (j >= 1 && used[j]) j--;找最晚空位越晚放越好,给前面的游戏让位
if (j >= 1) { ... }安排或放弃找不到空位就跳过,不加奖励
⚠️四个坑:① 按奖励升序排序(方向反了);② 从前往后找最早空位(会挤掉期限紧的游戏);③ 忘记 min(T[i], n) 的边界;④ 安排不上时没跳过,仍然累加奖励。

边界测试 &amp; 易错点
🧪 边界测试用例表
写完程序后,用这些数据自查一遍:
输入答案考察点
7
4 2 4 3 1 4 6
70 60 50 40 30 20 10230题面样例
1
1
55只有一个游戏,直接做
2
1 1
10 2020两个游戏都只能放第 1 段,只能选奖励高的
3
1 2 3
5 5 515期限刚好递增,三个都能安排
3
3 3 3
1 2 33三个都只能在前 3 段,共 3 段刚好全安排
✅自查清单:① 降序排序了吗?② 从后往前找空位吗?③ 放不下时跳过了吗?

🚨 易错点清单
⚠️排序方向反了:必须按奖励降序,让贵的游戏优先。

⚠️找"最早空位":应该从期限处往前找最晚空位,否则会挤掉期限更紧的游戏。

⚠️安排不上仍累加:找不到空位时要跳过,不能加奖励。

复杂度分析
📊 复杂度四宫格
时间复杂度
O(n²)

空间复杂度
O(n)

n 最大
500

运算量
约 2.5 × 10⁵

时间怎么算的?
排序 O(n log n)
每个游戏最多往前扫 n 步:O(n²)
n = 500 时约 25 万次
空间都用在哪?
一个长度为 n + 1 的占用标记数组。
✅ 约 25 万次操作,瞬间完成。如果需要 n 达 10⁵,可以用并查集把找空位优化到近似 O(1)。

知识拓展
🔗 常用技巧小抄
// 带截止期的任务调度贪心模板
sort(tasks.begin(), tasks.end(), [](const A &a, const A &b){ return a.value > b.value; });
vector<bool> used(n + 1, false);
long long ans = 0;
for (auto &task : tasks) {
int j = min(task.deadline, n);
while (j >= 1 && used[j]) j--;
if (j >= 1) { used[j] = true; ans += task.value; }
}

// 用并查集优化找空位(n 很大时)
// fa[i] 表示"从 i 往前第一个可用位置的候选"
int find(int x){ return fa[x] == x ? x : fa[x] = find(fa[x]); }
int j = find(min(task.deadline, n));
if (j >= 1) { used[j] = true; ans += task.value; fa[j] = find(j - 1); }

🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
截止期贪心按价值降序 + 最晚空位任务调度、作业安排、打折券使用
交换论证证明贪心不会更差所有需要证明贪心正确性的场合
并查集优化空位近似 O(1) 找空位n 很大时加速
🌟思考题:如果题目改成"每个游戏需要连续两个时间段才能完成",贪心还成立吗?(提示:不再直接成立——因为"占一个位置"变成了"占一段区间",交换论证会变得复杂,需要改成"按价值降序,找最晚的、能容纳两个连续空段的区间"。这说明贪心策略对"资源占用方式"的改变很敏感。)

💻 参考代码
#include &lt;bits/stdc++.h&gt;

using namespace std;



struct Game { int t, r, id; };



int main() {

    int n;

    scanf(&quot;%d&quot;, &amp;n);



    vector&lt;Game&gt; g(n);

    for (int i = 0; i &lt; n; i++) { scanf(&quot;%d&quot;, &amp;g[i].t); g[i].id = i + 1; }

    for (int i = 0; i &lt; n; i++) scanf(&quot;%d&quot;, &amp;g[i].r);



    // 按奖励从高到低排序

    sort(g.begin(), g.end(), [](const Game &amp;a, const Game &amp;b) {

        return a.r &gt; b.r;

    });



    vector&lt;bool&gt; used(n + 1, false);      // 时间段 1 ~ n

    int ans = 0;



    for (int i = 0; i &lt; n; i++) {

        // 从 min(t, n) 往前找第一个空位

        int j = min(g[i].t, n);

        while (j &gt;= 1 &amp;&amp; used[j]) j--;



        if (j &gt;= 1) {                     // 找到空位就安排

            used[j] = true;

            ans += g[i].r;

        }

        // 找不到就放弃这个游戏

    }



    printf(&quot;%d\n&quot;, ans);

    return 0;

}
💻 参考代码
// 带截止期的任务调度贪心模板

sort(tasks.begin(), tasks.end(), [](const A &amp;a, const A &amp;b){ return a.value &gt; b.value; });

vector&lt;bool&gt; used(n + 1, false);

long long ans = 0;

for (auto &amp;task : tasks) {

    int j = min(task.deadline, n);

    while (j &gt;= 1 &amp;&amp; used[j]) j--;

    if (j &gt;= 1) { used[j] = true; ans += task.value; }

}



// 用并查集优化找空位(n 很大时)

// fa[i] 表示&quot;从 i 往前第一个可用位置的候选&quot;

int find(int x){ return fa[x] == x ? x : fa[x] = find(fa[x]); }

int j = find(min(task.deadline, n));

if (j &gt;= 1) { used[j] = true; ans += task.value; fa[j] = find(j - 1); }
B3968成绩排序2024-03 · 模拟 / 排序 / 结构体
模拟排序结构体
📝 题目描述
有 n 名同学,每名同学有语文、数学、英语三科成绩,你需要按照如下规则对所有同学的成绩从高到低排序:

1. 比较总分,高者靠前;
2. 如果总分相同,则比较语文和数学两科的总分,高者靠前;
3. 如果仍相同,则比较语文和数学两科的最高分,高者靠前;
4. 如果仍相同,则二人并列。

你需要输出每位同学的排名,如遇 x 人并列,则他们排名相同,并留空后面的 x - 1 个名次。例如,有 3 名同学并列第 1,则后一名同学自动成为第 4 名。

⌨️ 输入格式
第一行一个整数 N,表示同学的人数。
接下来 N 行,每行三个非负整数 c_i, m_i, e_i 分别表示该名同学的语文、数学、英语成绩。
🖨 输出格式
输出 N 行,按输入同学的顺序,输出他们的排名。
注意:请不要按排名输出同学的序号,而是按同学的顺序输出他们各自的排名。
🔎 样例
#输入输出
1
6
140 140 150
140 149 140
148 141 140
141 148 140
145 145 139
0 0 0
1
3
4
4
2
6
📌 说明 / 数据范围
- 对 30% 的数据,N ≤q 100,且所有同学总分各不相同。
- 对全部的测试数据,保证 2 ≤q N ≤q 10^4,0 ≤q c_i, m_i, e_i ≤q 150。
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
题目拆解
📝 题目原文
n 名同学各有语文、数学、英语三科成绩。按以下规则从高到低排序:
比较总分,高者靠前
总分相同则比较语文 + 数学,高者靠前
仍相同则比较语文、数学中的最高分,高者靠前
仍相同则并列
输出每位同学的排名(按输入顺序输出各自的排名)。若 x 人并列,则他们名次相同,并占用后面的 x − 1 个名次。
例:3 人并列第 1,则下一名同学是第 4 名。
💡人话翻译:这题有两个要点:① 四级排序键(总分 → 语数总分 → 语数最高分);② 名次的计算方式——排列名次不是"该人在有序列表中的位置",而是"严格优于我的人数 + 1"。这样并列的人会得到相同名次,且后续名次自动跳过。

🔍 关键词提取
多关键字排序并列名次排名计算稳定输出
已知条件
项目说明
输入第一行 n;随后 n 行每行三个非负整数 c、m、e
输出n 行,按输入顺序输出每人的排名
排序键总分 → 语数总分 → 语数最高分
并列四项都相同即并列,名次相同且跳过后续名次
需要解决的问题
排序键怎么表示?用结构体存 c、m、e,并派生计算总分等;比较函数按优先级依次比较
并列怎么判?三个比较键全部相等即为并列,所以比较函数返回 false(谁都不比谁靠前)
名次怎么算?最稳的做法:排序后从左到右扫描,记录每个"名次组"的起始位置作为名次

思维导图
🏅 四级键排序 + 跳过式名次

📥 读入
n 名同学
三科成绩 c、m、e
记住输入顺序
需要按顺序输出排名

⚖️ 四级键
总分 = c+m+e
语数和 = c+m
语数最高 = max(c,m)
依次比较

🏆 名次计算
排序后从左到右扫
第一个不同组给 名次 = 下标+1
并列组内名次相同
下一组自动跳到实际位置

⚠️ 易错点
按排名输出而非输入顺序
并列名次没跳过
比较键顺序写错
用"下标+1"当名次(并列时不正确)

样例手算推导
🧮 样例:6 名同学
先算出每个人的三个排序键。
输入序号语 c数 m英 e总分语数和语数最高
1140140150430280140
2140149140429289149
3148141140429289148
4141148140429289148
5145145139429290145
6000000
1
第 1 级:比总分
1 号总分 430,最高 → 排第 1
2、3、4、5 号总分都是 429 → 进入第 2 级
6 号总分 0,最低 → 排最后
1 号第 1,6 号最后

2
第 2 级:比语数总分
5 号语数和 290(最高)→ 排第 2
2、3、4 号语数和都是 289 → 进入第 3 级
5 号第 2

3
第 3 级:比语数最高分
2 号最高分 149 → 排第 3
3 号、4 号都是 148 → 并列
两人并列,占用第 4、5 两个名次位置
所以他们都记作第 4 名
2 号第 3,3、4 号并列第 4

4
第 4 级:完全并列
6 号独自一人,总分 0
它前面的并列组占了 2 个名次(第 4、5)
所以它是第 6 名
6 号第 6

📊 按输入顺序输出的排名
输入序号名次说明
11总分最高
23语数最高分 149,排第 3
34与 4 号并列第 4
44与 3 号并列第 4
52语数总分 290,排第 2
66总分 0,排第 6(跳过了第 5 名)
输出 1、3、4、4、2、6 ✓
🔑关键点:名次不是"排序后的位置"!如果直接输出"排序后的下标 + 1",3 号会得到 4、4 号会得到 5——那就错了。正确做法是"并列的人用同一个名次,且名次等于该组第一个人的位置",所以 3、4 号都是第 4 名,下一组的 6 号直接跳到第 6 名。

🧮 名次的标准算法
用"组内名次 = 组首位置"这个规则实现最简洁。
1
排序后从左到右扫描
排序后的顺序(按规则):1 号、5 号、2 号、3 号、4 号、6 号
遍历数组的下标 k = 0, 1, 2, 3, 4, 5
若 k == 0 或 第 k 人与第 k−1 人不并列,则把该组的名次记为 k + 1
否则沿用当前组的名次
一轮扫描即可

2
具体过程
k = 0:新组 → rank = 1(1 号得第 1)
k = 1:与 1 号不并列 → rank = 2(5 号得第 2)
k = 2:不并列 → rank = 3(2 号得第 3)
k = 3:不并列 → rank = 4(3 号得第 4)
k = 4:与 3 号并列 → 沿用 rank = 4(4 号得第 4)
k = 5:不并列 → rank = 6(6 号得第 6)
✅ 名次正确

// 排序后计算名次(组首位置 = 名次)
for (int k = 0; k < n; k++) {
if (k == 0 || !tie(v[k], v[k-1])) rnk = k + 1;
rankOf[v[k].id] = rnk;
}
// rankOf 按原始编号记录名次
⚠️注意最后的输出:题目要求按输入顺序输出每人的排名,所以要用一个 rankOf[编号] 数组把名次映射回原始编号,最后从 1 到 n 依次输出。直接输出排序后的名次序列是错的。

解法对比
⚔️ 解法对比
🟢 排序 + 一次扫描定名次(推荐) 推荐
按四级键排序,再从前往后扫一遍,组首给名次
时间 O(n log n)
一次排序 + 一次扫描
并列处理天然正确
代码 30 行
💡核心:if (k == 0 || !tie(next, prev)) rnk = k + 1;——只有"不是并列"时才更新名次为当前位置 + 1,并列时沿用上一人的名次。

🟠 对每个人数"比我强的有几个"
双重循环统计严格优于我的人数,名次 = 该数量 + 1
时间 O(n²)
n 大时会超时
逻辑更直白(贴合"跳过式名次"定义)
但效率差
⚠️两种都对:"名次 = 严格优于我的人数 + 1"正是并列跳名的数学表达。小数据下这种写法更容易理解,但排序法是大数据下的标准做法。

📈 性能对比
方案复杂度适用规模
排序 + 扫描O(n log n)任意规模
两两比较O(n²)仅小数据

算法流程图
开始读入 n 和每人三科成绩;记下原始编号按 (总分降序, 语数和降序, 语数最高降序) 排序从前往后扫描,k = 0 起k == 0 或 与上一位不并列吗?是 ✓当前名次 = k + 1否 ✗沿用上一人的名次把当前名次记录到 rankOf[该同学的原始编号]按原始编号 1 到 n 依次输出名次结束k 加 1 继续← 左右滑动查看完整流程图
动手算一算
🏅 成绩排名计算器

第一行输入 n,随后 n 行每行三科成绩,程序会按四级规则排序并给出排名。

输入数据6
140 140 150
140 149 140
148 141 140
141 148 140
145 145 139
0 0 0


算一下!
随机出题


结果会显示在这里

点按钮开始 →

代码精讲
💻 完整 C++ 代码
include <bits/stdc++.h>
using namespace std;

struct Stu {
int id; // 原始编号(1 起)
int c, m, e; // 语、数、英
int tot() const { return c + m + e; } // 总分
int cm() const { return c + m; } // 语数和
int cmx() const { return max(c, m); } // 语数最高分
};

// 多关键字比较:返回 a 是否应排在 b 前面
bool better(const Stu &a, const Stu &b) {
if (a.tot() != b.tot()) return a.tot() > b.tot();
if (a.cm() != b.cm()) return a.cm() > b.cm();
if (a.cmx() != b.cmx()) return a.cmx() > b.cmx();
return false; // 完全并列:谁也不比谁靠前
}

// 判断两人是否并列
bool tied(const Stu &a, const Stu &b) {
return a.tot() == b.tot() && a.cm() == b.cm() && a.cmx() == b.cmx();
}

int main() {
int n;
scanf("%d", &n);

vector<Stu> v(n);
for (int i = 0; i < n; i++) {
v[i].id = i + 1;
scanf("%d %d %d", &v[i].c, &v[i].m, &v[i].e);
}

sort(v.begin(), v.end(), better);

// 扫描定名次:组首位置即名次
vector<int> rankOf(n + 1);
int rnk = 0;
for (int k = 0; k < n; k++) {
if (k == 0 || !tied(v[k], v[k - 1])) rnk = k + 1;
rankOf[v[k].id] = rnk;
}

// 按输入顺序输出
for (int i = 1; i <= n; i++) printf("%d\n", rankOf[i]);
return 0;
}
🔑为什么比较函数在"完全并列"时返回 false?因为排序要求"严格弱序":better(a,b) 为真表示 a 应排在 b 前。两人完全并列时,谁也不该排在谁前面,所以返回 false。如果这里返回 true,会破坏排序的一致性,可能导致未定义行为。

📖 关键几行怎么看
代码作用为什么这样写
a.tot() > b.tot()降序比较高者靠前,用 >
return false并列谁也不比谁靠前
if (k == 0 || !tied(v[k], v[k-1])) rnk = k + 1;定名次组首位置即名次
rankOf[v[k].id] = rnk记录名次按原始编号存储,便于最后按输入顺序输出
⚠️三个坑:① 把"排序后的下标 + 1"当名次(并列时错误);② 按排序后的顺序输出(应该按输入顺序);③ 比较函数在并列时返回 true,破坏严格弱序。

边界测试 &amp; 易错点
🧪 边界测试用例表
写完程序后,用这些数据自查一遍:
输入答案考察点
6
140 140 150 / 140 149 140 / 148 141 140 / 141 148 140 / 145 145 139 / 0 0 01
3
4
4
2
6题面样例
1
100 100 1001只有一人
2
100 100 100 / 100 100 1001
1两人完全相同,并列第 1
2
90 100 100 / 100 90 1001
1总分 290、语数和 190、语数最高 100 三项全同 → 并列第 1
3
150 150 150 / 100 100 100 / 100 100 1001
2
2后两人并列第 2,没有第 3 名
✅自查清单:① 三个排序键顺序对吗?② 并列时名次取组首位置吗?③ 按输入顺序输出吗?

🚨 易错点清单
⚠️名次算成"下标 + 1":并列的人应取相同名次(组首位置),而不是各自的下标 + 1。

⚠️输出顺序错:必须按输入顺序输出每人的名次,不能用排序后的顺序。

⚠️比较键顺序写错:必须是 总分 → 语数和 → 语数最高分。

复杂度分析
📊 复杂度四宫格
时间复杂度
O(n log n)

空间复杂度
O(n)

n 规模
本题不大

运算量
排序为主

时间怎么算的?
排序:O(n log n)
扫描定名次:O(n)
输出:O(n)
合计 O(n log n)
空间都用在哪?
需要存 n 个同学的信息和一份名次表。
✅ 排序是主要开销,任意 n 规模都能轻松完成。

知识拓展
🔗 常用技巧小抄
// 并列排名的标准算法("组首位置即名次")
int rnk = 0;
for (int k = 0; k < n; k++) {
if (k == 0 || !tied(v[k], v[k-1])) rnk = k + 1;
rankOf[v[k].id] = rnk;
}

// 另一种等价理解:名次 = 严格优于我的人数 + 1
int betterCount = 0;
for (int j = 0; j < n; j++)
if (j != i && isBetter(v[j], v[i])) betterCount++;
rankOf[i] = betterCount + 1;

// 多关键字比较用 tuple 简化(C++11)
auto key = [](const Stu &s) {
return make_tuple(-s.tot(), -s.cm(), -s.cmx()); // 取负实现降序
};
sort(v.begin(), v.end(), [&](const Stu &a, const Stu &b){
return key(a) < key(b);
});

🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
并列名次组首位置即名次排行榜、竞赛名次、成绩排名
严格弱序并列时返回 false所有自定义比较函数
按原序输出用编号映射回名次所有"打乱后按原序输出"的题
🌟思考题:如果题目改成"不跳过名次"(即并列的人名次相同,但下一人只 +1,如两人并列第 1 则下一人是第 2 名),代码要怎么改?(提示:那种叫"竞争排名",只需把 rnk = k + 1 改成 rnk++——注意两种排名的规则完全不同,读题时必须看清"是否跳过名次"。)

💻 参考代码
// 排序后计算名次(组首位置 = 名次)

for (int k = 0; k &lt; n; k++) {

    if (k == 0 || !tie(v[k], v[k-1])) rnk = k + 1;

    rankOf[v[k].id] = rnk;

}

// rankOf 按原始编号记录名次
💻 参考代码
#include &lt;bits/stdc++.h&gt;

using namespace std;



struct Stu {

    int id;          // 原始编号(1 起)

    int c, m, e;     // 语、数、英

    int tot() const { return c + m + e; }        // 总分

    int cm()  const { return c + m; }            // 语数和

    int cmx() const { return max(c, m); }        // 语数最高分

};



// 多关键字比较:返回 a 是否应排在 b 前面

bool better(const Stu &amp;a, const Stu &amp;b) {

    if (a.tot() != b.tot()) return a.tot() &gt; b.tot();

    if (a.cm()  != b.cm())  return a.cm()  &gt; b.cm();

    if (a.cmx() != b.cmx()) return a.cmx() &gt; b.cmx();

    return false;                 // 完全并列:谁也不比谁靠前

}



// 判断两人是否并列

bool tied(const Stu &amp;a, const Stu &amp;b) {

    return a.tot() == b.tot() &amp;&amp; a.cm() == b.cm() &amp;&amp; a.cmx() == b.cmx();

}



int main() {

    int n;

    scanf(&quot;%d&quot;, &amp;n);



    vector&lt;Stu&gt; v(n);

    for (int i = 0; i &lt; n; i++) {

        v[i].id = i + 1;

        scanf(&quot;%d %d %d&quot;, &amp;v[i].c, &amp;v[i].m, &amp;v[i].e);

    }



    sort(v.begin(), v.end(), better);



    // 扫描定名次:组首位置即名次

    vector&lt;int&gt; rankOf(n + 1);

    int rnk = 0;

    for (int k = 0; k &lt; n; k++) {

        if (k == 0 || !tied(v[k], v[k - 1])) rnk = k + 1;

        rankOf[v[k].id] = rnk;

    }



    // 按输入顺序输出

    for (int i = 1; i &lt;= n; i++) printf(&quot;%d\n&quot;, rankOf[i]);

    return 0;

}
💻 参考代码
// 并列排名的标准算法(&quot;组首位置即名次&quot;)

int rnk = 0;

for (int k = 0; k &lt; n; k++) {

    if (k == 0 || !tied(v[k], v[k-1])) rnk = k + 1;

    rankOf[v[k].id] = rnk;

}



// 另一种等价理解:名次 = 严格优于我的人数 + 1

int betterCount = 0;

for (int j = 0; j &lt; n; j++)

    if (j != i &amp;&amp; isBetter(v[j], v[i])) betterCount++;

rankOf[i] = betterCount + 1;



// 多关键字比较用 tuple 简化(C++11)

auto key = [](const Stu &amp;s) {

    return make_tuple(-s.tot(), -s.cm(), -s.cmx());   // 取负实现降序

};

sort(v.begin(), v.end(), [&amp;](const Stu &amp;a, const Stu &amp;b){

    return key(a) &lt; key(b);

});
P17010排排坐2026-06 · 数学 / 贪心 / 排序
数学贪心排序前缀和
📝 题目描述
老师正在和小朋友们分糖果。

小朋友们先在自己的手上写一个数字,然后坐成一排。

老师分发糖果的规则是:每个小朋友获得自己以及左侧所有小朋友的手上数字之和个糖果。

现在小朋友们都已经在自己手上写上了数字。

请帮小朋友们安排合适的座位顺序,使得小朋友们分到的糖果总量最大,输出这个最大值。

⌨️ 输入格式
输入 2 行,

第一行为一个正整数 n,表示小朋友的个数;

第二行为 n 个正整数 a_1, a_2, …, a_n,表示小朋友们手上的数字,整数之间以空格分隔。

🖨 输出格式
输出一个整数,表示小朋友们可能分到的最大糖果总数量。
🔎 样例
#输入输出
1
5
7 5 8 9 3
111
📌 说明 / 数据范围
样例解释
小朋友安排座位后从左向右每人手上数字依次是:9, 8, 7, 5, 3。

这时可以得到最多的糖果:(9) + (9 + 8) + (9 + 8 + 7) + (9 + 8 + 7 + 5) + (9 + 8 + 7 + 5 + 3) = 111。

数据范围
1 ≤ n ≤ 1000,1 ≤ a_i ≤ 1000。

⚠️ 这道题美力程题解库暂未收录文字题解。建议按考点自己先推一遍:
· 把公式化简后再算,注意取整与取余的方向。
· 先排序,再按「每步取最优」推一遍,验证有没有反例。
写完后可到洛谷 P17010 对照题解。
B3951小杨的队列样题 · 排序
排序
📝 题目描述
小杨的班级里共有 N 名同学,学号从 0 至 N-1。某节课上,老师要求同学们进行列队。具体来说,老师会依次点名 M 名同学,让他们加入队伍。每名新入队的同学需要先站到队伍末尾(刚开始队伍里一个人都没有,所以第一个入队的同学只需要站好即可),随后,整个队伍中的所有同学需要按身高从低到高重新排序(身高相同的同学之间的顺序任意)。

排队很容易,但重新排序难倒了同学们。稍加讨论后,他们发现可以通过交换位置的方法来实现排序。具体来说,他们可以让队伍中的两名同学交换位置这样整个队伍的顺序就会发生变化,多经过这样的几次交换后,队伍的顺序就可以排好。

例如:队伍中有 4 名同学,学号依次为 10,17,3,25,我们可以令 3 号同学和 10 号同学交换位置,则交换后的队伍顺序变为 3,17,10,25,这就是一次交换位置。

聪明的小杨想要知道:在老师每次点名一位新同学加入队伍后,在原有队伍的基础上,同学们最少要进行几次交换位置,才能完成老师按身高排序的要求。

⌨️ 输入格式
第一行一个整数 N,表示同学的数量。
第二行 N 个用空格隔开的正整数,依次表示学号为 0,1, … ,N-1 的同学的身高(不超过 2,147,483,647)。
第三行一个整数 M,表示老师点名的数量。
接下来 M 行,依次描述 M 次点名:每行一个整数 x(0 ≤ x<N),表示要求学号为 x 的同学加入队伍。保证该名同学此前不在队伍中。
🖨 输出格式
输出 M 行,依次表示对于每次点名,同学们最少要进行几次交换位置,才能完成按身高排序的要求。
🔎 样例
#输入输出
1
5
170 165 168 160 175
4
0
3
2
1
0
1
1
2
2
4
20 20 20 10
4
0
1
2
3
0
0
0
1
📌 说明 / 数据范围
对于所有的测试点,保证 1 ≤ M ≤ N ≤ 2000。对于 50% 的测试点,保证所有同学的身高互不相同。
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
题目拆解
📝 题目原文
N 名同学学号 0 ~ N−1,各有身高。老师依次点名 M 名同学加入队伍:新同学先站到队伍末尾,然后整个队伍按身高从低到高重新排序(身高相同的顺序任意)。
每次点名后,求最少需要几次"两人交换位置"才能完成排序。
例:队伍学号依次为 10, 17, 3, 25,让 3 号与 10 号交换位置后变为 3, 17, 10, 25——这是一次交换。
💡人话翻译:两个关键观察——
① 交换是"任意两人互换",不是"只能换相邻两人";
② 每次排完序后,队伍是"有序"的,新同学只会插在末尾,所以答案只取决于"队伍里有多少种不同的身高比新同学高"。
下面的推导会严格证明这个结论。

🔍 关键词提取
排序的最小交换次数置换的循环分解多重集的等价元素去重计数
已知条件
项目说明
输入N;N 个身高;M;M 次点名(每次给一个学号 x)
输出M 行,每行是本次点名后的最少交换次数
数据范围1 ≤ M ≤ N ≤ 2000
身高范围不超过 2147483647
保证每次点名的同学此前不在队伍中
需要解决的问题
最少交换次数怎么算?对任意两人可交换的情形,最少交换次数 = n − 置换的循环个数
为什么队伍一定是有序的?因为每次"重新排序"完成后队伍就有序了,而新同学只加在末尾
怎么处理身高相同?相同身高的人可以互相顶替,所以能保留更多"不动的位置",这是本题最巧妙的地方

思维导图
🔁 交换次数 = n − 循环数

🧩 基础模型
任意两人可交换
最少交换次数 = n − 循环个数
循环分解来自"位置映射"
相同值可自由匹配

📐 队伍状态
每次排完序后队伍有序
新同学只加在末尾
所以只有"末尾一个异类"
结构非常规整

🔍 切割分析
设 a 个比 x 小的数
b 个等于 x 的数
c 个比 x 大的数
异类只出现在末尾 (c+1) 个位置里

✅ 结论
答案是"比 x 高的不同身高种数"
不是"比 x 高的人数"
相同身高可省交换
用去重计数即可

样例手算推导
🧮 先看清"队伍始终有序"这件事
样例 1:身高 [170, 165, 168, 160, 175](学号 0 ~ 4),点名顺序 0, 3, 2, 1。
1
第 1 次点名:学号 0(身高 170)
队伍为空 → 加入后是 [170]
已经有序,交换 0 次
输出 0 ✓

2
第 2 次点名:学号 3(身高 160)
队伍当前是 有序的 [170]
新同学站到末尾 → [170, 160]
要让 160 到前面,交换 1 次
交换后队伍变为 [160, 170]
输出 1 ✓

3
第 3 次点名:学号 2(身高 168)
队伍是有序的 [160, 170]
新同学站到末尾 → [160, 170, 168]
交换 168 与 170 → [160, 168, 170],共 1 次
输出 1 ✓

4
第 4 次点名:学号 1(身高 165)
队伍是有序的 [160, 168, 170]
新同学站到末尾 → [160, 168, 170, 165]
165 需要越到 168、170 前面
最少交换 2 次
输出 2 ✓

🔑核心前提:每次排完序,队伍就变成有序的。所以下一次"插入末尾"时,队伍里只有末尾那一个新同学是"异类"——其余部分已经有序。这让我们能把问题简化成"一个元素插到有序序列的末尾"。

🧮 为什么答案是"不同身高的种数"
这是本题最有价值的一段推理。设新同学身高为 x,队伍里有 a 个比 x 矮、b 个和 x 一样高、c 个比 x 高。
1
找出"位置对不上"的范围
队伍当前:[比x矮的 a 个] [等于x的 b 个] [比x高的 c 个] [x]
排序后应当是:[比x矮的 a 个] [等于x的 b+1 个] [比x高的 c 个]
前面 a + b 个位置本来就对得上 → 可以不动
问题集中在末尾的 c + 1 个位置
只有 c + 1 个位置需处理

2
数一数"能不动"的位置
末尾这 c + 1 个位置里:当前是 [v₁, v₂, …, v_c, x](v 为比 x 高的数,升序)
目标是 [x, v₁, v₂, …, v_c]
对第 i 个 v(i ≥ 2),若 v_i = v_{i−1},
那么它可以"留在原位"(因为它左边也是同样的值)
所以"能不动"的个数 = 相邻相等的对数
可保留 P 个位置

3
套用 n − 循环数
剩余 c + 1 − P 个位置构成一个循环
交换次数 = (c + 1) − (1 + P) = c − P
其中 P = Σ_{不同值 w > x} (cnt(w) − 1)
而 c = Σ_{不同值 w > x} cnt(w)
所以 c − P = Σ 1 = 不同值的种数
✅ 答案 = 比 x 高的不同身高种数

样例片段队伍新同学 x比 x 高的值不同种数答案
样例1 第2次[170]160{170}11 ✓
样例1 第3次[160,170]168{170}11 ✓
样例1 第4次[160,168,170]165{168,170}22 ✓
样例2 第4次[20,20,20]10{20}11 ✓
⚠️最容易错的地方:把"不同身高的种数"当成"比它高的人数"。看样例 2 第 4 次:队伍是 [20,20,20],新同学身高 10,有 3 个人比他高,但答案是 1 而不是 3——因为只要和其中一个 20 交换一次,另外两个 20 的位置就自动对了(它们本来就是 20,排在哪儿都是 20)。"相同身高的同学可以互相顶替",这就是省下交换次数的原因。

解法对比
⚔️ 解法对比
🟢 统计更大的不同身高数(推荐) 推荐
维护已入场同学的身高集合,每次数一数"比新同学高的不同值"有几个
时间 O(NM),M ≤ 2000 时约 4 × 10⁶
代码 20 行
有严格推导支撑
💡实现:用一个数组 inQ[学号] 标记是否已入场;每次询问时遍历所有已入场的同学,把"身高 > 新同学身高"的身高值去重计数。M、N ≤ 2000,双重循环完全够快。

🟠 直接模拟冒泡排序
每次插入后真的模拟排序,数交换次数
容易把"交换次数"数错
相邻交换与任意交换次数不同
模拟逻辑复杂
容易掉进陷阱
⚠️为什么不推荐:如果按"只能交换相邻两人"来模拟,样例 2 会得到 3 而不是 1——与题目不符。而且每次排序的 O(N log N) 加起来虽不算慢,但逻辑上的坑远比"去重计数"多。

📈 性能对比
方案复杂度正确性风险
去重计数O(NM)低(有推导保证)
模拟排序O(NM log N)高(易误用相邻交换)

算法流程图
开始读入 N、身高数组 h[0..N−1]、Mpresent[x] 全部标记为 false处理每次点名 x把 h[x] 加入"已入场集合";cnt = 0,seen 清零遍历所有已入场同学 y:若 h[y] > h[x] 且 h[y] 首次出现,则 cnt 加 1输出 cnt结束处理下一次点名← 左右滑动查看完整流程图
动手算一算
🔁 最少交换次数计算器

第一行输入 N,第二行输入身高,第三行输入 M,随后 M 行输入点名学号。

输入数据5
170 165 168 160 175
4
0
3
2
1


算一下!
随机出题


结果会显示在这里

点按钮开始 →

代码精讲
💻 完整 C++ 代码
include <bits/stdc++.h>
using namespace std;

int h[2005];
bool inQ[2005]; // 该学号是否已在队伍中

int main() {
int N;
scanf("%d", &N);
for (int i = 0; i < N; i++) scanf("%d", &h[i]);

int M;
scanf("%d", &M);

while (M--) {
int x;
scanf("%d", &x);
inQ[x] = true; // 学号 x 加入队伍

// 统计"已在队伍中、且身高严格大于 h[x]"的不同身高种数
vector<int> seen;
int cnt = 0;
for (int y = 0; y < N; y++) {
if (!inQ[y] || h[y] <= h[x]) continue;

bool found = false;
for (int v : seen) if (v == h[y]) { found = true; break; }
if (!found) { seen.push_back(h[y]); cnt++; }
}

printf("%d\n", cnt);
}
return 0;
}
🔑为什么用"去重计数"而不是"数人数"?看样例 2:队伍里有 3 个身高 20 的人,新同学身高 10。数人数会得到 3,但正确答案是 1——因为这三个 20 是"同一个身高",只需一次交换就能让新同学跨过它们(交换之后三个 20 的排列依旧有序)。注意判定用的是 h[y] > h[x](严格大于),因为身高相同的同学之间不用交换。

📖 关键几行怎么看
代码作用为什么这样写
inQ[x] = true加入队伍每次点名把该学号标记为已入场
h[y] <= h[x] → continue筛选严格大于才算"更高"
seen 去重去重计数同一身高只算一次
printf("%d\n", cnt)输出每次点名输出一行
⚠️三个坑:① 数的是"人数"而不是"不同身高种数"(样例 2 会错);② 比较用 ≥ 而不是 >(身高相同不该计入);③ 忘记新同学加入后要立即更新集合再统计。

边界测试 &amp; 易错点
🧪 边界测试用例表
写完程序后,用这些数据自查一遍:
输入答案考察点
5
170 165 168 160 175
4
0 / 3 / 2 / 10
1
1
2题面样例 1
4
20 20 20 10
4
0 / 1 / 2 / 30
0
0
1题面样例 2(有相同身高)
1
100
1
00只有一名同学
3
10 20 30
3
2 / 1 / 00
1
2每次都在末尾加一个更矮的
3
30 20 10
3
0 / 1 / 20
0
0每次加入更高的,队伍保持有序
✅自查清单:① 去重了吗?② 用严格大于吗?③ 集合更新时机对吗?

🚨 易错点清单
⚠️数人数而非种数:相同身高的同学可以互相顶替,所以要去重计数(样例 2 会暴露这个错误)。

⚠️比较写成 ≥:身高相同不需要交换,所以条件是严格大于。

⚠️把交换当成"相邻交换":题目允许任意两人交换;若是相邻交换,答案会不同。

复杂度分析
📊 复杂度四宫格
时间复杂度
O(NM)

空间复杂度
O(N)

N, M 最大
2000

运算量
约 4 × 10⁶

时间怎么算的?
每次点名遍历 N 个同学
去重时最多再看 N 个已记录身高
合计约 O(NM) = 4 × 10⁶
空间都用在哪?
身高数组、入场标记、去重用的临时数组。
✅ 约 400 万次操作,瞬间完成。N、M ≤ 2000 很小,不需要更高级的数据结构。

知识拓展
🔗 常用技巧小抄
// 结论:答案 = 队伍中"比新同学高的不同身高种数"
// 因为:
// 1. 每次排完序,队伍都是有序的 -> 只有末尾一个异类
// 2. 任意两人可交换 -> 最少次数 = n - 循环个数
// 3. 相同身高的人可以互相顶替 -> 可以保留更多"不动的位置"
// 推导得:次数 = c - P = 不同身高种数

// 若题目改成"只能交换相邻两人"
// 则答案 = 队伍中"比新同学高的人数"(不是种数!)
// 这是两种模型的关键区别

// 用 set 加速去重(N 较大时)
set<int> s;
for (int y = 0; y < N; y++)
if (inQ[y] && h[y] > h[x]) s.insert(h[y]);
printf("%d\n", (int)s.size());

🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
任意交换模型次数 = n − 循环个数任意两两交换类问题
相同值可顶替能保留更多不动位多重集排序的最小交换次数
去重计数同一值只算一次本题的关键结论
🌟思考题:如果题目改成"每次只能交换相邻的两人",答案会是什么?(提示:那就变成"比新同学高的人数"而不是"种数"了——因为相邻交换必须一个一个越过去,每越过一个人就花一次。看样例 2:[20,20,20] 加 10,相邻交换需要 3 次,而任意交换只需 1 次。"交换的粒度"完全改变答案,读题时必须分清。)

💻 参考代码
#include &lt;bits/stdc++.h&gt;

using namespace std;



int h[2005];

bool inQ[2005];        // 该学号是否已在队伍中



int main() {

    int N;

    scanf(&quot;%d&quot;, &amp;N);

    for (int i = 0; i &lt; N; i++) scanf(&quot;%d&quot;, &amp;h[i]);



    int M;

    scanf(&quot;%d&quot;, &amp;M);



    while (M--) {

        int x;

        scanf(&quot;%d&quot;, &amp;x);

        inQ[x] = true;                 // 学号 x 加入队伍



        // 统计&quot;已在队伍中、且身高严格大于 h[x]&quot;的不同身高种数

        vector&lt;int&gt; seen;

        int cnt = 0;

        for (int y = 0; y &lt; N; y++) {

            if (!inQ[y] || h[y] &lt;= h[x]) continue;



            bool found = false;

            for (int v : seen) if (v == h[y]) { found = true; break; }

            if (!found) { seen.push_back(h[y]); cnt++; }

        }



        printf(&quot;%d\n&quot;, cnt);

    }

    return 0;

}
💻 参考代码
// 结论:答案 = 队伍中&quot;比新同学高的不同身高种数&quot;

// 因为:

//   1. 每次排完序,队伍都是有序的 -&gt; 只有末尾一个异类

//   2. 任意两人可交换 -&gt; 最少次数 = n - 循环个数

//   3. 相同身高的人可以互相顶替 -&gt; 可以保留更多&quot;不动的位置&quot;

//   推导得:次数 = c - P = 不同身高种数



// 若题目改成&quot;只能交换相邻两人&quot;

// 则答案 = 队伍中&quot;比新同学高的人数&quot;(不是种数!)

// 这是两种模型的关键区别



// 用 set 加速去重(N 较大时)

set&lt;int&gt; s;

for (int y = 0; y &lt; N; y++)

    if (inQ[y] &amp;&amp; h[y] &gt; h[x]) s.insert(h[y]);

printf(&quot;%d\n&quot;, (int)s.size());
B4071武器强化2024-12 · 贪心 / 线性数据结构 / 枚举
贪心线性数据结构枚举排序数组
📝 题目描述
小杨有 n 种武器和 m 种强化材料。第 i 种强化材料会适配第 p_i 种武器,小杨可以花费 c_i 金币将该材料对应的适配武器修改为任意武器。

小杨最喜欢第 1 种武器,因此他希望适配该武器的强化材料种类数严格大于其他的武器,请你帮小杨计算为了满足该条件最少需要花费多少金币。

⌨️ 输入格式
第一行包含两个正整数 n,m,含义如题面所示。

之后 m 行,每行包含两个正整数 p_i,c_i,代表第 i 种强化材料的适配武器和修改花费。

🖨 输出格式
输出一个整数,代表能够使适配第 1 种武器的强化材料种类数严格大于其他的武器最少需要花费的金币。
🔎 样例
#输入输出
1
4 4
1 1
2 1
3 1
3 2
1
📌 说明 / 数据范围
样例解释
花费 1,将第三种强化材料的适配武器由 3 改为 1。此时,武器 1 有 2 种强化材料适配,武器 2 和武器 3 都各有 1 种强化材料适配,满足适配第 1 种武器的强化材料种类数严格大于其他的武器。

数据范围
对于 100% 的数据,保证 1≤ n,m≤ 1 000,1≤ p_i≤ n,1≤ c_i≤ 10^9。

| 子任务编号 | 得分占比 | n | m |
| :--: | :--: | :--: | :--: |
| 1 | 20% | ≤ 2 | ≤ 1 000 |
| 2 | 20% | ≤ 1 000 | ≤ 2 |
| 3 | 60% | ≤ 1 000 | ≤ 1 000 |

⚠️ 这道题美力程题解库暂未收录文字题解。建议按考点自己先推一遍:
· 先排序,再按「每步取最优」推一遍,验证有没有反例。
· 定范围、写条件、逐个试;能推出的量就别多写一层循环。
写完后可到洛谷 B4071 对照题解。
P11960平均分配2025-03 · 贪心 / 排序
贪心排序
📝 题目描述
小 A 有 2n 件物品,小 B 和小 C 想从小 A 手上买走这些物品。对于第 i 件物品,小 B 会以 b_i 的价格购买,而小 C 会以 c_i 的价格购买。为了平均分配这 2n 件物品,小 A 决定小 B 和小 C 各自只能买走恰好 n 件物品。你能帮小 A 求出他卖出这 2n 件物品所能获得的最大收入吗?
⌨️ 输入格式
第一行,一个正整数 n。

第二行,2n 个整数 b_1,b_2,…,b_{2n}。

第三行,2n 个整数 c_1,c_2,…,c_{2n}。

🖨 输出格式
一行,一个整数,表示答案。
🔎 样例
#输入输出
1
3
1 3 5 6 8 10
2 4 6 7 9 11
36
2
2
6 7 9 9
1 2 10 12
35
📌 说明 / 数据范围
数据范围
对于 20% 的测试点,保证 1≤ n≤8。

对于另外 20% 的测试点,保证 0≤ b_i≤1,0≤ c_i≤1。

对于所有测试点,保证 1≤ n≤10^5,0≤ b_i≤10^9,0≤ c_i≤10^9。

💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
题目拆解
📝 题目原文
有 2n 件物品。第 i 件物品,小 B 出价 bᵢ、小 C 出价 cᵢ。小 A 决定小 B 和小 C 各自恰好买走 n 件。求能获得的最大总收入。
💡人话翻译:每件物品只有一个买家(要么 B 要么 C),而且两个买家都必须恰好买 n 件。关键转化:先假设所有物品都给 B,此时收入是 Σbᵢ;然后要"改判"恰好 n 件给 C,每改一件的收益变化是 cᵢ − bᵢ;所以只需挑出差价最大的 n 件改判给 C。

🔍 关键词提取
贪心差价排序恰好 n 件的约束转化思路
已知条件
项目说明
输入第一行 n;第二行 2n 个 bᵢ;第三行 2n 个 cᵢ
输出最大总收入
数据范围1 ≤ n ≤ 10⁵
价格范围0 ≤ bᵢ, cᵢ ≤ 10⁵
约束B 恰好买 n 件、C 恰好买 n 件
需要解决的问题
为什么可以"先全给 B"?这只是计算的一个基准,方便的是一旦确定基准,后续的优化就变成"选哪些改判"
改判的收益怎么算?第 i 件从 B 改给 C,收入变化 = cᵢ − bᵢ
要选几件改判?恰好 n 件(因为 C 必须买到 n 件)

思维导图
💰 选 n 件最大差价改判

🧠 转化
基准:全部卖给 B
基准收入 = Σbᵢ
需要改判恰好 n 件给 C
问题变成"选 n 件最优"

📊 差价
dᵢ = cᵢ − bᵢ
改判收益就是 dᵢ
要最大化 Σ 选中的 dᵢ
选最大的 n 个

✅ 答案
答案 = Σbᵢ + (前 n 大的 dᵢ 之和)
差价可能为负也必须选够 n 件
因为 C 必须恰好买 n 件
不能只选正的

⚠️ 易错点
只选正的差价(导致 C 买不到 n 件)
用 int(Σb 可达 2×10¹⁰)
排序方向搞反
忘记恰好 n 件的硬约束

样例手算推导
🧮 样例 1:n = 3,b = [1,3,5,6,8,10],c = [2,4,6,7,9,11]
先算基准收入,再算各件差价。
物品bᵢcᵢ差价 dᵢ = cᵢ − bᵢ
112+1
234+1
356+1
467+1
589+1
61011+1
1
基准收入
Σbᵢ = 1 + 3 + 5 + 6 + 8 + 10 = 33
基准 33

2
选 3 件改判
所有差价都是 +1
选任意 3 件改判给 C,总收益 = 3 × 1 = 3
改判收益 3

3
合计
33 + 3 = 36
✅ 答案 36

36 ✓

🧮 样例 2:n = 2,b = [6,7,9,9],c = [1,2,10,12]
这组数据里有负差价,正好考察"必须选够 n 件"这个约束。
物品bᵢcᵢ差价 dᵢ
161−5
272−5
3910+1
4912+3
1
基准收入
Σbᵢ = 6 + 7 + 9 + 9 = 31
基准 31

2
排序差价
差价排序后:+3、+1、−5、−5
取前 n = 2 大:+3 和 +1
改判收益 = 3 + 1 = 4
改判收益 4

3
合计
31 + 4 = 35
✅ 答案 35

35 ✓
⚠️关键点:即使差价是负数,也必须选够 n 件!因为题目硬性要求"C 恰好买 n 件"。在更极端的数据下(比如所有差价都是负的),答案就是 Σbᵢ 加上前 n 大差价(可能全为负)——这时的答案会小于 Σbᵢ,但这是"必须满足约束"的结果,不能为了让收入更高而少选。

解法对比
⚔️ 解法对比
🟢 差价排序(推荐) 推荐
算 Σb,再把 d = c − b 排序取前 n 大相加
时间 O(n log n)
n = 10⁵ 时约 10⁶ 次
代码 10 行
有清晰的贪心证明
💡为什么贪心最优:答案 = Σbᵢ + (选中的 dᵢ 之和),其中 Σbᵢ 是常数,所以只需最大化"选中 d 之和"。在"恰好选 n 个"的约束下,显然选最大的 n 个最优。

🟠 动态规划
dp[i][j] 表示前 i 件物品中 C 选了 j 件的最大收益
时间 O(n²) 或 O(n × n) = 10¹⁰
超时
逻辑正确但过慢
属于杀鸡用牛刀
⚠️为什么不需要 DP:本题没有复杂的依赖关系——每件物品的选择彼此独立,只受"总数恰好 n"这个约束,所以贪心就够了。有 DP 可用不代表一定要用 DP。

📈 性能对比
方案复杂度(n = 10⁵)可行性
差价排序约 10⁶✅ 稳过
二维 DP约 10¹⁰❌ 超时

算法流程图
开始读入 n 和数组 b、c(各 2n 个)base = Σbᵢ(全部卖给 B 的收入)对每件物品计算差价 dᵢ = cᵢ − bᵢ把差价数组从大到小排序,取前 n 个求和 gain答案 = base + gain结束逐件计算差价← 左右滑动查看完整流程图
动手算一算
💰 最大收入计算器

第一行输入 n,第二行输入 B 的报价,第三行输入 C 的报价。

输入数据2
6 7 9 9
1 2 10 12


算一下!
随机出题


结果会显示在这里

点按钮开始 →

代码精讲
💻 完整 C++ 代码
include <bits/stdc++.h>
using namespace std;

long long b[200005], c[200005];

int main() {
int n;
scanf("%d", &n);

for (int i = 0; i < 2 * n; i++) scanf("%lld", &b[i]);
for (int i = 0; i < 2 * n; i++) scanf("%lld", &c[i]);

// 基准:全部卖给 B
long long ans = 0;
vector<long long> d(2 * n);
for (int i = 0; i < 2 * n; i++) {
ans += b[i];
d[i] = c[i] - b[i]; // 改判给 C 的收益变化
}

// 取差价最大的 n 个
sort(d.begin(), d.end(), greater<long long>());
for (int i = 0; i < n; i++) ans += d[i];

printf("%lld\n", ans);
return 0;
}
🔑为什么"选最大的 n 个差价"是最优的?因为答案可以写成 Σbᵢ + Σ_{i∈S} dᵢ,其中 Σbᵢ 是固定值,S 是"改判给 C"的 n 件物品集合。要让总和最大,就只需让 Σdᵢ 尽量大;在"必须选 n 个"的约束下,显然取最大的 n 个 dᵢ。这是贪心的经典论证方式:把常数项剥离,只优化可控部分。

📖 关键几行怎么看
代码作用为什么这样写
ans += b[i]基准收入先假设全给 B
d[i] = c[i] - b[i]差价改判给 C 的收益变化
sort(d, d+2n, greater<long long>())降序排序取最大的 n 个
for (i = 0; i < n; i++) ans += d[i]累加改判收益恰好 n 个,不管正负
⚠️三个坑:① 只累加正差价(会导致 C 买不到 n 件,违反约束);② 用 int(Σb 可达 2 × 10⁵ × 10⁵ = 2 × 10¹⁰,会溢出);③ 排序写成升序(应该取最大的 n 个)。

边界测试 &amp; 易错点
🧪 边界测试用例表
写完程序后,用这些数据自查一遍:
输入答案考察点
3
1 3 5 6 8 10
2 4 6 7 9 1136题面样例 1
2
6 7 9 9
1 2 10 1235题面样例 2(含负差价)
1
5 7
3 914n = 1:基准 12,差价 [−2, +2],取 +2 → 14
1
10 1
1 1020B 买贵的、C 买另一件,各得其所
2
0 0 0 0
0 0 0 00全为 0
✅自查清单:① 基准是 Σb 吗?② 取的是恰好 n 个差价吗?③ 用 long long 吗?

🚨 易错点清单
⚠️只选正差价:C 必须恰好买 n 件,所以即使差价是负数也必须选够。

⚠️用 int:Σb 可达 2 × 10¹⁰,超过 int 上限,必须用 long long。

⚠️排序方向错:要取最大的 n 个,所以用降序排序(或升序后从末尾取)。

复杂度分析
📊 复杂度四宫格
时间复杂度
O(n log n)

空间复杂度
O(n)

n 最大
10⁵

运算量
约 10⁶

时间怎么算的?
读入并算差价:O(n)
排序 2n 个差价:O(n log n)
累加前 n 个:O(n)
空间都用在哪?
需要存 b、c 和差价数组,各 2n 个 long long。
✅ 约 100 万次操作,瞬间完成。如果写成 O(n²) 的 DP,10¹⁰ 次会超时。

知识拓展
🔗 常用技巧小抄
// 贪心论证模板:把答案拆成"常数项 + 可控项"
// 本题:答案 = Σb (常数) + Σ_{选中} d (可控)
// 约束:"恰好选 n 个" -> 取最大的 n 个 d

// 降序排序的三种写法
sort(d.begin(), d.end(), greater<long long>()); // 方式一
sort(d.begin(), d.end()); // 方式二:升序后排
for (int i = 2 * n - 1, c = 0; c < n; i--, c++) ans += d[i];
sort(d.rbegin(), d.rend()); // 方式三:反向迭代器

// 类似题目
// "选 n 件最大化差价""两方分配最大化收益"等
// 都属于"独立选择 + 数量约束"的贪心模型

🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
贪心拆解常数项 + 可控项预算分配、双向报价类问题
恰好 n 件约束必须选够,不管正负所有"配额"类问题的关键
差价转化c − b 表示改判收益选择问题、交换优化的通用技巧
🌟思考题:如果题目去掉了"各买 n 件"的约束(即每件物品可以卖给任何人,也可以不卖),答案会怎样?(提示:那就简单多了——每件物品独立地选 max(bᵢ, cᵢ) 即可,答案是 Σ max(bᵢ, cᵢ),甚至不需要排序。正是"恰好 n 件"这个配额约束,才让题目需要排序贪心。)

💻 参考代码
#include &lt;bits/stdc++.h&gt;

using namespace std;



long long b[200005], c[200005];



int main() {

    int n;

    scanf(&quot;%d&quot;, &amp;n);



    for (int i = 0; i &lt; 2 * n; i++) scanf(&quot;%lld&quot;, &amp;b[i]);

    for (int i = 0; i &lt; 2 * n; i++) scanf(&quot;%lld&quot;, &amp;c[i]);



    // 基准:全部卖给 B

    long long ans = 0;

    vector&lt;long long&gt; d(2 * n);

    for (int i = 0; i &lt; 2 * n; i++) {

        ans += b[i];

        d[i] = c[i] - b[i];        // 改判给 C 的收益变化

    }



    // 取差价最大的 n 个

    sort(d.begin(), d.end(), greater&lt;long long&gt;());

    for (int i = 0; i &lt; n; i++) ans += d[i];



    printf(&quot;%lld\n&quot;, ans);

    return 0;

}
💻 参考代码
// 贪心论证模板:把答案拆成&quot;常数项 + 可控项&quot;

// 本题:答案 = Σb (常数) + Σ_{选中} d  (可控)

// 约束:&quot;恰好选 n 个&quot; -&gt; 取最大的 n 个 d



// 降序排序的三种写法

sort(d.begin(), d.end(), greater&lt;long long&gt;());          // 方式一

sort(d.begin(), d.end());                                 // 方式二:升序后排

for (int i = 2 * n - 1, c = 0; c &lt; n; i--, c++) ans += d[i];

sort(d.rbegin(), d.rend());                              // 方式三:反向迭代器



// 类似题目

// &quot;选 n 件最大化差价&quot;&quot;两方分配最大化收益&quot;等

// 都属于&quot;独立选择 + 数量约束&quot;的贪心模型
P17456饮品调制2026-09 · 贪心 / 排序
贪心排序
📝 题目描述
你想调制一份甜度恰到好处的饮品给你的朋友们品尝。

有 n 种原料可供用于调制饮品。第 i 种原料存量有 v_i 升,每升含有 s_i 克糖分。你可以自由选择原料加入饮品,但每种原料的使用量不得超过其剩余存量。也就是说,假设第 i 种原料选用 k_i 升,应当有 0≤ k_i≤ v_i,k_i 可以取 0 到 v_i 之间的任何数字(包括小数)。

一份甜度恰到好处的饮品需要保证甜度恰好为 t。最终你调制得到的饮品甜度将为 \frac{Σ_{i=1}^{n}k_i· s_i}{Σ_{i=1}^{n}k_i}。为了让更多的朋友喝到饮品,请问最多能调制出多少升甜度恰到好处的饮品?如果无法调制出甜度恰到好处的饮品,则认为答案是 0。

⌨️ 输入格式
第一行,两个整数 n,t,分别表示原料种类数量,恰到好处的甜度。

接下来 n 行,每行两个整数 v_i,s_i,分别表示第 i 种原料的存量体积,每升含有的糖分质量。

🖨 输出格式
一行,一个小数,表示能调制出的甜度恰到好处的饮品最大体积,保留三位小数。
🔎 样例
#输入输出
1
4 2
6 1
5 2
8 5
1 0
14.667
2
2 5
3 4
5 3
0.000
📌 说明 / 数据范围
对于 40% 的测试点,保证 n=2。

对于所有测试点,保证 1≤ n≤ 2000,0≤ t≤ 200,1≤ v_i≤ 100,0≤ s_i≤ 200。

💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
题目拆解
📝 题目原文
有 n 种原料,第 i 种存量 vᵢ 升、每升含糖 sᵢ 克。可以自由选取用量 kᵢ ∈ [0, vᵢ](可为小数)。
最终甜度 = Σkᵢsᵢ / Σkᵢ。要求甜度恰好为 t,求能调出的最大体积,保留三位小数;若无法调制则输出 0。
💡人话翻译:要凑出"加权平均恰好等于 t",且总量最大。关键转化:设初始用尽全部原料,此时的加权平均可能偏离 t。我们需要倒掉一些原料让平均回到 t。倒掉哪一些最"划算"?倒掉甜度偏离 t 最远的那些(每升能改变平均最多)——这样倒掉的体积最少,剩下的体积最多。

🔍 关键词提取
加权平均约束转化贪心削减浮点输出
已知条件
项目说明
输入第一行 n、t;随后 n 行 vᵢ、sᵢ
输出最大体积,保留三位小数
用量范围0 ≤ kᵢ ≤ vᵢ(连续取值)
无解时输出 0
精度保留三位小数
需要解决的问题
怎么把"平均值"变成"约束"?甜度 = t 等价于 Σkᵢ(sᵢ − t) = 0,即"正偏离总量 = 负偏离总量"
怎么最大化体积?把 kᵢ 写成 vᵢ − dᵢ(dᵢ 是"倒掉的量"),则目标是最小化 Σdᵢ
该倒掉什么?倒掉 |sᵢ − t| 最大的那种——它每升能改变偏离最多

思维导图
⚖️ 先全用,再最小量倒掉

🧠 建模
kᵢ ∈ [0, vᵢ] 连续
甜度 = t ⟺ Σkᵢ(sᵢ−t) = 0
设 kᵢ = vᵢ − dᵢ(dᵢ ≥ 0)
Σdᵢ(sᵢ−t) = D

📐 求偏离量
D = Σvᵢ(sᵢ−t)
若 D == 0 → 全部可用
若 D > 0 → 需减少正偏离
若 D < 0 → 需减少负偏离

🎯 贪心削减
按 |sᵢ−t| 从大到小排序
优先从"偏离方向正确"的原料倒
每升改变偏离 |sᵢ−t|
倒够了就停

⚠️ 易错点
方向判断错(该倒哪一侧)
用 int 导致精度丢失
忘了保留三位小数
全倒光时体积为 0

样例手算推导
🧮 样例:n = 4,t = 2
原料:(6,1)、(5,2)、(8,5)、(1,0)。每行的格式是 (体积 vᵢ, 甜度 sᵢ)。
1
第 1 步:全部用尽,看偏离
总偏离 D = Σvᵢ(sᵢ − t)
= 6 × (1 − 2) + 5 × (2 − 2) + 8 × (5 − 2) + 1 × (0 − 2)
= −6 + 0 + 24 − 2 = 16
D > 0 说明"正偏离太多",平均甜度高于 t
D = 16 > 0

2
第 2 步:判断该倒哪一侧
D > 0 意味着平均偏高,需要降低平均
所以要倒掉"甜度高于 t"的原料(sᵢ > t)
本例中 s = 5 > t = 2 的原料(体积 8)
倒掉 d 升,偏离减少 d × (5 − 2) = 3d
从 s=5 的原料倒

3
第 3 步:算出要倒多少
需要 3d = 16 → d = 16/3 ≈ 5.333
而该原料只有 8 升 ≥ 5.333 ✓ 可行
剩余体积 = (6 + 5 + 8 + 1) − 16/3
= 20 − 5.3333 = 14.6667
✅ 输出 14.667

📊 计算汇总
原料vᵢsᵢsᵢ − tvᵢ(sᵢ − t)
161−1−6
25200
385+3+24
410−2−2
合计20——+16
20 − 16/3 = 14.667 ✓
🔑注意 s = 2 的那种原料(第 2 行):它的甜度恰好等于 t,所以加多少都不影响平均——可以全部用上,是"纯赚"的体积。这也是为什么答案能比较大。
另外注意:vᵢ(sᵢ − t) 的符号由 sᵢ − t 决定,甜度高于 t 的贡献正偏离,低于 t 的贡献负偏离。

🧮 无解的情形
什么时候答案是 0?
1
只有一种原料且甜度不等于 t
例如 n = 1,t = 5,原料 (1, 3)
D = 1 × (3 − 5) = −2 < 0
需要减少负偏离 → 倒掉 s < t 的原料
唯一原料就是 s = 3 < 5
需要 −2d = −2 → d = 1
即必须把仅有的 1 升全部倒掉 → 体积 0
❌ 输出 0

2
另一种情况
若所有原料的甜度都 ≥ t(且至少一个 > t),
D > 0,需要倒掉 s > t 的原料
而 s = t 的原料不受影响(偏离为 0)
只要有足够的 s > t 原料可倒,就能调制成功
通常可行

⚠️精确判断"无解"的方法:如果所需倒掉的量超出了对应方向原料的总存量,那就无解。不过由 D 的定义可以证明:D ≤ Σ_{sᵢ>t} vᵢ(sᵢ − t)(D > 0 时),所以理论上总能倒够——唯一的问题是要不要把"全部原料"都倒掉,导致体积为 0。实现时只需判断最终体积是否 > 0 即可。

解法对比
⚔️ 解法对比
🟢 全局贪心削减(推荐) 推荐
算总偏离 D,按 |sᵢ−t| 排序后从需要的方向贪心倒
时间 O(n log n)
一次排序 + 一次扫描
能处理多种原料混合
代码 30 行
💡核心公式:D = Σvᵢ(sᵢ−t);若 D > 0 就从"甜度最大"开始倒,若 D < 0 就从"甜度最小"开始倒,每升改变偏离 |sᵢ − t|,倒到偏离清零为止。

🟠 枚举"用哪两种原料混合"
假设只用两种原料(一高一低)混合出甜度 t
看起来可行(最优解最多用 2 种部分原料)
但容易漏掉"多用几种全量原料"的情况
实现更复杂
不如全局贪心稳妥
⚠️为什么容易出错:虽然线性规划理论保证"最多 2 种原料是部分使用",但"全部使用的原料"可能有很多种,枚举两两组合时很容易漏掉这些。全局贪心一次性处理所有原料,更不容易出错。

📈 性能对比
方案代码量易错程度
全局贪心约 30 行低
枚举两两约 45 行高

算法流程图
开始读入 n、t 和每种的 vᵢ、sᵢ;totalV = ΣvᵢD = Σ vᵢ × (sᵢ − t)D 是否等于 0?是 ✓全部可用,答案 = totalV否 ✗需要削减needed = |D|;按 |sᵢ − t| 降序排列"方向正确"的原料依次从这些原料削减:每升改变 |sᵢ − t|削减总量 = needed / |sᵢ − t|(受限不超过 vᵢ),直到 needed 为 0答案 = totalV − 削减总量,保留三位小数结束继续削减下一批← 左右滑动查看完整流程图
动手算一算
🥤 最大可调体积计算器

第一行输入 n 和 t,随后 n 行输入每种的体积与甜度。

输入数据4 2
6 1
5 2
8 5
1 0


算一下!
随机出题


结果会显示在这里

点按钮开始 →

代码精讲
💻 完整 C++ 代码
include <bits/stdc++.h>
using namespace std;

int main() {
int n;
double t;
scanf("%d %lf", &n, &t);

vector<double> v(n), s(n);
double totalV = 0, D = 0;
for (int i = 0; i < n; i++) {
scanf("%lf %lf", &v[i], &s[i]);
totalV += v[i];
D += v[i] * (s[i] - t); // 总偏离
}

double ans = totalV;

if (fabs(D) > 1e-9) {
// 需要削减偏离 |D|;只从"偏离方向正确"的原料削减
// D > 0:平均偏高,削 s > t 的原料
// D < 0:平均偏低,削 s < t 的原料
vector<int> idx(n);
for (int i = 0; i < n; i++) idx[i] = i;
sort(idx.begin(), idx.end(), [&](int a, int b) {
return fabs(s[a] - t) > fabs(s[b] - t); // 每升改变量大者优先
});

double need = fabs(D), removed = 0;
for (int k = 0; k < n && need > 1e-9; k++) {
int i = idx[k];
if (D > 0 && s[i] <= t) continue; // 方向不对,跳过
if (D < 0 && s[i] >= t) continue;
double g = fabs(s[i] - t);
if (g < 1e-12) continue;
double take = min(v[i], need / g); // 最多倒掉 v[i] 升
removed += take;
need -= take * g;
}
ans = totalV - removed;
}

if (ans < 1e-9) ans = 0; // 体积为 0 视为无法调制
printf("%.3f\n", ans);
return 0;
}
🔑为什么"按 |sᵢ − t| 从大到小"削最好?因为我们的目标是让削掉的体积最少。倒掉 1 升甜度为 s 的原料,会让总偏离改变 |s − t|。所以要改变给定的偏离量,选择 |s − t| 最大的那种最"高效"——用最少的体积达成目标。这是典型的贪心论证。

📖 关键几行怎么看
代码作用为什么这样写
D += v[i] * (s[i] - t)总偏离甜度 = t 等价于总偏离为 0
fabs(s[a] - t) > fabs(s[b] - t)排序每升改变量大的优先削减
if (D > 0 && s[i] <= t) continue;方向过滤只削"偏离方向正确"的原料
double take = min(v[i], need / g);削减量取"需要的量"与"存量的量"的较小者
printf("%.3f", ans)输出保留三位小数
⚠️三个坑:① 削减方向搞反(D > 0 时应削 s > t 的原料);② 用 int 计算(体积可以是小数,必须用 double);③ 忘记保留三位小数(用 %.3f)。

边界测试 &amp; 易错点
🧪 边界测试用例表
写完程序后,用这些数据自查一遍:
输入答案考察点
4 2
6 1 / 5 2 / 8 5 / 1 014.667题面样例
1 5
1 51.000唯一原料甜度恰好等于 t,全部可用
1 5
1 30.000无法调制:只有一种原料且甜度 ≠ t
2 2
1 1 / 1 32.000一低一高,各用 1 升混合,平均恰好为 2
2 5
3 5 / 4 57.000全部甜度都等于 t,全部可用
✅自查清单:① 削减方向对吗?② 用 double 了吗?③ 输出三位小数了吗?

🚨 易错点清单
⚠️削减方向反了:D > 0(平均偏高)时应削减甜度大于 t 的原料。

⚠️用整数运算:体积可以是小数,必须用 double 并注意精度(比较用 fabs(x) < 1e-9)。

⚠️输出格式:必须保留三位小数(%.3f)。

复杂度分析
📊 复杂度四宫格
时间复杂度
O(n log n)

空间复杂度
O(n)

n 规模
不大

运算量
排序为主

时间怎么算的?
读入并算总偏离 O(n)
排序 O(n log n)
削减扫描 O(n)
空间都用在哪?
需要存下 n 种的体积与甜度。
✅ 排序是主要开销,任何规模都轻松完成。难点在于把"加权平均等于 t"转化为"总偏离为 0"这个约束。

知识拓展
🔗 常用技巧小抄
// 本题的数学核心
// 甜度 = Σkᵢsᵢ / Σkᵢ = t
// <=> Σkᵢsᵢ = t·Σkᵢ
// <=> Σkᵢ(sᵢ − t) = 0 (总偏离为 0)

// 令 kᵢ = vᵢ − dᵢ(dᵢ 为倒掉的量,dᵢ ∈ [0, vᵢ])
// Σ(vᵢ − dᵢ)(sᵢ − t) = 0
// Σvᵢ(sᵢ − t) = Σdᵢ(sᵢ − t)
// 即 D = Σdᵢ(sᵢ − t),要最小化 Σdᵢ
// -> 用 |sᵢ − t| 最大的原料去"抵消" D

// 浮点比较的惯用写法
if (fabs(x) < 1e-9) { /* 视为 0 */ }

// 输出固定小数位
printf("%.3f\n", ans);

🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
约束转化平均值 = t ⟺ 总偏离 = 0混合问题、加权平均类题目
贪心削减用"最有效"的资源凑出目标量所有"最小代价达成目标"的问题
浮点精度fabs(x) < 1e-9 判零所有涉及小数的比较
🌟思考题:如果原料的用量只能取整数升(不能取小数),这题会变成什么?(提示:那就不再是简单的贪心,而更像背包问题——需要 DP 或更复杂的搜索,因为它变成了整数规划。"连续取值"这个条件是本题能用贪心的关键前提。)

💻 参考代码
#include &lt;bits/stdc++.h&gt;

using namespace std;



int main() {

    int n;

    double t;

    scanf(&quot;%d %lf&quot;, &amp;n, &amp;t);



    vector&lt;double&gt; v(n), s(n);

    double totalV = 0, D = 0;

    for (int i = 0; i &lt; n; i++) {

        scanf(&quot;%lf %lf&quot;, &amp;v[i], &amp;s[i]);

        totalV += v[i];

        D += v[i] * (s[i] - t);        // 总偏离

    }



    double ans = totalV;



    if (fabs(D) &gt; 1e-9) {

        // 需要削减偏离 |D|;只从&quot;偏离方向正确&quot;的原料削减

        // D &gt; 0:平均偏高,削 s &gt; t 的原料

        // D &lt; 0:平均偏低,削 s &lt; t 的原料

        vector&lt;int&gt; idx(n);

        for (int i = 0; i &lt; n; i++) idx[i] = i;

        sort(idx.begin(), idx.end(), [&amp;](int a, int b) {

            return fabs(s[a] - t) &gt; fabs(s[b] - t);   // 每升改变量大者优先

        });



        double need = fabs(D), removed = 0;

        for (int k = 0; k &lt; n &amp;&amp; need &gt; 1e-9; k++) {

            int i = idx[k];

            if (D &gt; 0 &amp;&amp; s[i] &lt;= t) continue;          // 方向不对,跳过

            if (D &lt; 0 &amp;&amp; s[i] &gt;= t) continue;

            double g = fabs(s[i] - t);

            if (g &lt; 1e-12) continue;

            double take = min(v[i], need / g);         // 最多倒掉 v[i] 升

            removed += take;

            need -= take * g;

        }

        ans = totalV - removed;

    }



    if (ans &lt; 1e-9) ans = 0;                            // 体积为 0 视为无法调制

    printf(&quot;%.3f\n&quot;, ans);

    return 0;

}
💻 参考代码
// 本题的数学核心

// 甜度 = Σkᵢsᵢ / Σkᵢ = t

//   &lt;=&gt;  Σkᵢsᵢ = t·Σkᵢ

//   &lt;=&gt;  Σkᵢ(sᵢ − t) = 0        (总偏离为 0)



// 令 kᵢ = vᵢ − dᵢ(dᵢ 为倒掉的量,dᵢ ∈ [0, vᵢ])

//   Σ(vᵢ − dᵢ)(sᵢ − t) = 0

//   Σvᵢ(sᵢ − t) = Σdᵢ(sᵢ − t)

//   即 D = Σdᵢ(sᵢ − t),要最小化 Σdᵢ

//   -&gt; 用 |sᵢ − t| 最大的原料去&quot;抵消&quot; D



// 浮点比较的惯用写法

if (fabs(x) &lt; 1e-9) { /* 视为 0 */ }



// 输出固定小数位

printf(&quot;%.3f\n&quot;, ans);
②编程打卡 · 点一下就能勾选
☑ 已勾选 0 / 8 项点一下条目即可勾选
五级 · 编程 DAY 04

贪心策略

💻 编程题 2 道📚 知识点 贪心策略⏱ 建议用时 80 分钟
①本日知识点 · 贪心策略

先排序再贪;每步取最优,写完必须自己找一个反例试。

本组 2 道题全部来自 GESP 真题,按「贪心策略」归在一起练。题面取洛谷原题(含公式与样例),题解取美力程 GESP 题解库(思路 + 参考代码 + 复杂度)。

B4051小杨的武器2024-09 · 贪心
贪心
📝 题目描述
小杨有 n 种不同的武器,他对第 i 种武器的初始熟练度为 c_i。

小杨会依次参加 m 场战斗,每场战斗小杨只能且必须选择一种武器使用,假设小杨使用了第 i 种武器参加了第 j 场战斗,战斗前该武器的熟练度为 c'_i,则战斗后小杨对该武器的熟练度会变为 c'_i + a_j。需要注意的是,a_j 可能是正数,0 或负数,这意味着小杨参加战斗后对武器的熟练度可能会提高,也可能会不变,还有可能降低。

小杨想请你编写程序帮他计算出如何选择武器才能使得 m 场战斗后,自己对 n 种武器的熟练度的最大值尽可能大。

⌨️ 输入格式
第一行包含两个正整数 n,m,含义如题面所示。
第二行包含 n 个整数 c_1, c_2, … c_n,代表小杨对武器的初始熟练度。
第三行包含 m 个整数 a_1, a_2, … a_m,代表每场战斗后武器熟练度的变化值。
🖨 输出格式
输出一个整数,代表 m 场战斗后小杨对 n 种武器的熟练度的最大值最大是多少。
🔎 样例
#输入输出
1
2 2
9 9
1 -1
10
📌 说明 / 数据范围
样例 1 解释
一种最优的选择方案为,第一场战斗小杨选择第一种武器,第二场战斗小杨选择第二种武器。

数据规模与约定
| 子任务编号 | 数据点占比 | n | m |
| :-: | :-: | :-: | :-: |
| 1 | 20% | =1 | ≤q 10^5 |
| 2 | 20% | ≤q 10^5 | =2 |
| 3 | 60% | ≤q 10^5 | ≤q 10^5 |

对全部的测试数据,保证 1 ≤q n, m ≤q 10^5,-10^4 ≤q c_i, a_i ≤q 10^4。

⚠️ 这道题美力程题解库暂未收录文字题解。建议按考点自己先推一遍:
· 先排序,再按「每步取最优」推一遍,验证有没有反例。
写完后可到洛谷 B4051 对照题解。
B3930烹饪问题2023-12 · 贪心 / 位运算
贪心位运算
📝 题目描述
有 N 种食材,编号从 1 至 N,其中第 i 种食材的美味度为 a_i。

不同食材之间的组合可能产生奇妙的化学反应。具体来说,如果两种食材的美味度分别为 x 和 y ,那么它们的契合度为 x and y 。

其中,and 运算为按位与运算,需要先将两个运算数转换为二进制,然后在高位补足 ,再逐位进行与运算。例如,12 与 6 的二进制表示分别为 1100 和 0110 ,将它们逐位进行与运算,得到 0100 ,转换为十进制得到 4,因此 12 and 6 = 4。在 C++ 或 Python 中,可以直接使用 & 运算符表示与运算。

现在,请你找到契合度最高的两种食材,并输出它们的契合度。

⌨️ 输入格式
第一行一个整数 N,表示食材的种数。

接下来一行 N 个用空格隔开的整数,依次为 a_1,…,a_N,表示各种食材的美味度。

🖨 输出格式
输出一行一个整数,表示最高的契合度。
🔎 样例
#输入输出
1
3
1 2 3
2
2
5
5 6 2 10 13
8
📌 说明 / 数据范围
样例解释 1

可以编号为 2,3 的食材之间的契合度为 2 and 3=2,是所有食材两两之间最高的契合度。

样例解释 2

可以编号为 4,5 的食材之间的契合度为 10 and 13=8,是所有食材两两之间最高的契合度。

数据范围

对于 40% 的测试点,保证 N ≤ 1,000;

对于所有测试点,保证 N ≤ 10^6,0≤ a_i ≤ 2,147,483,647。

💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
题目拆解
📝 题目原文
有 N 种食材,第 i 种的美味度为 aᵢ。两种食材的"契合度"定义为 x AND y(按位与)。求任意两种食材契合度的最大值。
💡人话翻译:暴力枚举两两组合是 O(N²) = 10¹²,必然超时。正确思路是"从高位到低位贪心构造答案":依次尝试让答案的第 30、29、…、0 位为 1,能凑出来就保留。判断"能否凑出"的方法是:数一数有多少个数包含目标掩码的所有位,≥ 2 就说明可行。

🔍 关键词提取
按位与按位贪心子集计数位运算
已知条件
项目说明
输入第一行 N;第二行 N 个整数 aᵢ
输出最高的契合度
数据范围N ≤ 10⁶
数值范围0 ≤ aᵢ ≤ 2147483647 = 2³¹ − 1
目标max(aᵢ AND aⱼ)(i ≠ j)
需要解决的问题
为什么不能暴力?N = 10⁶ → 两两组合约 5 × 10¹¹,远超时间限制
贪心构造为什么成立?高位比低位"权重大得多"(2³⁰ > 所有低位之和),所以能保住高位就一定要保住
怎么判断"第 b 位能否为 1"?设候选掩码 mask = ans | (1 << b),统计满足 (aᵢ AND mask) == mask 的个数,≥ 2 就可行

思维导图
🍳 从高位按位构造答案

🧠 贪心依据
2³⁰ > 2²⁹ + … + 2⁰
高位权重压倒低位
所以优先保住高位
逐位尝试即可

🔍 判定方法
试让第 b 位为 1
mask = ans | (1统计含 mask 全部位的数的个数
≥ 2 则第 b 位可取 1

⚙️ 实现
ans = 0
b 从 30 递减到 0
每轮 O(N) 扫描
总 O(31N) ≈ 3 × 10⁷

⚠️ 易错点
枚举两两组合(N² 超时)
位上限写 30 而不是 31
只数 1 个数(需要 ≥ 2)
用 int 处理 2³¹−1 边界

样例手算推导
🧮 样例 1:a = [1, 2, 3],答案 2
1 = 01₂、2 = 10₂、3 = 11₂。最高位只到第 1 位,我们从第 30 位开始试(高位都凑不出)。
试探位mask = ans | 2^b含 mask 全部位的数个数决策
30 ~ 2…无0跳过,ans 不变
110₂ = 22(10₂)、3(11₂)2✅ ans = 2
011₂ = 33(11₂)1❌ 不够 2 个
1
第 1 位试探
mask = 2(二进制 10)
检查每个数:1 AND 2 = 0 ≠ 2 ✗
2 AND 2 = 2 == 2 ✓
3 AND 2 = 2 == 2 ✓
共 2 个数 → 够 2 个(可以选 2 和 3)
✅ ans = 2

2
第 0 位试探
mask = 2 | 1 = 3(二进制 11)
检查:1 AND 3 = 1 ≠ 3 ✗
2 AND 3 = 2 ≠ 3 ✗
3 AND 3 = 3 == 3 ✓
只有 1 个数 → 不够,第 0 位不能要
❌ ans 保持 2

答案 2 ✓(2 AND 3 = 2)

🧮 样例 2:a = [5, 6, 2, 10, 13],答案 8
先看二进制表示。
数二进制(4 位)说明
50101
60110
20010
101010含第 3 位
131101含第 3 位
1
第 3 位(值 8)
mask = 8(二进制 1000)
5 AND 8 = 0 ✗
6 AND 8 = 0 ✗
2 AND 8 = 0 ✗
10 AND 8 = 8 ✓
13 AND 8 = 8 ✓
共 2 个 → 可行
✅ ans = 8

2
第 2 位(值 4)不能要
mask = 8 | 4 = 12(二进制 1100)
10 AND 12 = 8 ≠ 12 ✗(10 = 1010,缺第 2 位)
13 AND 12 = 12 == 12 ✓(13 = 1101)
5、6、2 也不满足
只有 1 个 → 不够 2 个
❌ ans 保持 8

3
第 1 位、第 0 位
mask = 8 | 2 = 10:10 ✓、13 AND 10 = 8 ✗ → 仅 1 个
mask = 8 | 1 = 9:10 AND 9 = 8 ✗、13 AND 9 = 9 ✓ → 仅 1 个
都不满足
❌ ans 最终为 8

答案 8 ✓(10 AND 13 = 1010 ∧ 1101 = 1000 = 8)
🔑注意样例 2 的关键:第 2 位虽然 13 有、10 没有,但要求的是"两个数都包含 mask 的所有位"——10 缺第 2 位,所以不能和第 2 位一起取。这就是"子集计数"的含义:mask 必须完整地包含在某个数里。

解法对比
⚔️ 解法对比
🟢 按位贪心 + 子集计数(推荐) 推荐
从第 30 位往下,逐位尝试置 1,统计能否凑出两个数
时间 O(31N)
N = 10⁶ 时约 3 × 10⁷
代码 15 行
空间 O(N)
💡可行性条件:至少要有两个不同的数,它们都完整包含 mask 的所有 1 位——这样它们的按位与才至少包含 mask。用"计数 ≥ 2"来判定。

🟠 枚举两两组合
双重循环求所有 aᵢ AND aⱼ 的最大值
时间 O(N²) = 5 × 10¹¹
必然超时
代码最短(4 行)
只适用于 N ≤ 1000
⚠️注意题目数据:N ≤ 10⁶ 而只有 40% 的测试点 N ≤ 1000,所以暴力只能拿部分分。这也提示我们:看到 N 很大但数位只有 31 位,就该往"按位处理"想。

📈 性能对比
方案运算量(N = 10⁶)可行性
按位贪心约 3 × 10⁷✅ 稳过
两两枚举约 5 × 10¹¹❌ 超时

算法流程图
开始读入 N 和数组 a;ans = 0b 从 30 递减到 0mask = ans | (1 << b);cnt = 0扫描所有 aᵢ:若 (aᵢ & mask) == mask 则 cnt 加 1cnt 是否 ≥ 2?是 ✓ans = mask(保留这一位)否 ✗弃掉这一位输出 ans结束b 减 1 继续试低位← 左右滑动查看完整流程图
动手算一算
🍳 最高契合度构造器

输入一组美味度,程序会逐位构造最大契合度并展示每次试探。

输入美味度


算一下!
随机出题


结果会显示在这里

点按钮开始 →

代码精讲
💻 完整 C++ 代码
include <bits/stdc++.h>
using namespace std;

int a[1000005];

int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);

int ans = 0;

// 从最高位(第 30 位)往低位贪心
for (int b = 30; b >= 0; b--) {
int mask = ans | (1 << b);

// 统计有多少个数"完整包含" mask 的所有 1 位
int cnt = 0;
for (int i = 0; i < n; i++) {
if ((a[i] & mask) == mask) cnt++;
}

if (cnt >= 2) ans = mask; // 至少两个,可行
}

printf("%d\n", ans);
return 0;
}
🔑(a[i] & mask) == mask 是什么意思?它表示"mask 里所有的 1,a[i] 在对应位置也都是 1",也就是 mask 是 a[i] 的位掩码子集。这等价于 (a[i] | mask) == a[i] 或 (a[i] & ~mask) == 0,但写成 (a[i] & mask) == mask 最直观好记。

📖 关键几行怎么看
代码作用为什么这样写
b 从 30 到 0位遍历aᵢ ≤ 2³¹−1,最高位是第 30 位
mask = ans | (1 << b)试探掩码在已确定的高位基础上,试加当前位
(a[i] & mask) == mask子集判定判断 aᵢ 是否完整包含 mask 的所有位
if (cnt >= 2) ans = mask;决策要两个不同的数才能形成一对
⚠️四个坑:① 用 O(N²) 暴力(10⁶ 规模必然超时);② 位循环写成 b < 31 从 31 开始(aᵢ ≤ 2³¹−1,最高位是 30);③ 判定写成 cnt >= 1(需要两个不同的数);④ 移位 1 << 30 时用 int 是安全的,但写 1 << 31 会溢出。

边界测试 &amp; 易错点
🧪 边界测试用例表
写完程序后,用这些数据自查一遍:
输入答案考察点
3
1 2 32题面样例 1:2 AND 3 = 2
5
5 6 2 10 138题面样例 2:10 AND 13 = 8
2
0 00两个 0,契合度为 0
2
2147483647 21474836472147483647两个最大值,按位与等于自身
4
7 7 7 77多个相同的数,取任意两个
✅自查清单:① 按位贪心了吗?② 位从 30 开始吗?③ 判定用了 ≥ 2 吗?

🚨 易错点清单
⚠️暴力枚举:N = 10⁶ 时两两组合约 5 × 10¹¹,会超时。

⚠️位循环范围错:aᵢ ≤ 2³¹−1,最高位是第 30 位(2³⁰ = 1073741824)。

⚠️判定条件写成 cnt ≥ 1:需要两个不同的数才能形成一对,所以是 cnt ≥ 2。

复杂度分析
📊 复杂度四宫格
时间复杂度
O(31N)

空间复杂度
O(N)

N 最大
10⁶

运算量
约 3 × 10⁷

时间怎么算的?
共 31 个位
每位扫描整个数组 O(N)
合计 31N ≈ 3 × 10⁷ 次
空间都用在哪?
需要存下 N 个整数。
✅ 约 3000 万次位运算,C++ 一秒内完成。相比 O(N²) 的 5 × 10¹¹,优化了四个数量级。

知识拓展
🔗 常用技巧小抄
// 按位贪心构造"最大 AND"的模板
int ans = 0;
for (int b = 30; b >= 0; b--) {
int mask = ans | (1 << b);
int cnt = 0;
for (int i = 0; i < n; i++)
if ((a[i] & mask) == mask) cnt++;
if (cnt >= 2) ans = mask;
}

// 常见的"子集判定"三种等价写法
bool has = ((a[i] & mask) == mask); // 最直观
bool has2 = ((a[i] | mask) == a[i]); // 等价
bool has3 = ((a[i] & ~mask) == 0); // 等价

// 位运算的小技巧
// x & (x - 1) 消掉最右边的 1
// x & (-x) 取出最低位的 1
// __builtin_popcount(x) 数 1 的个数

// 关键:看到"N 很大、但数值位宽很小(≤ 31 位)",优先想"按位处理"

🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
按位贪心高位优先,逐位构造最大 AND / 最大 XOR / 最大 OR 类问题
子集判定(x & mask) == mask位掩码的子集关系判断
高位权重优势2^k > 低位之和所有"按位贪心"的正确性依据
🌟思考题:如果题目改成求"最大按位或(OR)",还需要这套贪心吗?(提示:不需要——因为 x OR y 的最大值就是"把所有数的所有 1 位都合起来",直接把所有 aᵢ 按位或一遍即可,O(N) 搞定。正是"AND 要求两个数都要有这一位"这个约束,才让本题需要贪心 + 计数。)

💻 参考代码
#include &lt;bits/stdc++.h&gt;

using namespace std;



int a[1000005];



int main() {

    int n;

    scanf(&quot;%d&quot;, &amp;n);

    for (int i = 0; i &lt; n; i++) scanf(&quot;%d&quot;, &amp;a[i]);



    int ans = 0;



    // 从最高位(第 30 位)往低位贪心

    for (int b = 30; b &gt;= 0; b--) {

        int mask = ans | (1 &lt;&lt; b);



        // 统计有多少个数&quot;完整包含&quot; mask 的所有 1 位

        int cnt = 0;

        for (int i = 0; i &lt; n; i++) {

            if ((a[i] &amp; mask) == mask) cnt++;

        }



        if (cnt &gt;= 2) ans = mask;      // 至少两个,可行

    }



    printf(&quot;%d\n&quot;, ans);

    return 0;

}
💻 参考代码
// 按位贪心构造&quot;最大 AND&quot;的模板

int ans = 0;

for (int b = 30; b &gt;= 0; b--) {

    int mask = ans | (1 &lt;&lt; b);

    int cnt = 0;

    for (int i = 0; i &lt; n; i++)

        if ((a[i] &amp; mask) == mask) cnt++;

    if (cnt &gt;= 2) ans = mask;

}



// 常见的&quot;子集判定&quot;三种等价写法

bool has = ((a[i] &amp; mask) == mask);      // 最直观

bool has2 = ((a[i] | mask) == a[i]);     // 等价

bool has3 = ((a[i] &amp; ~mask) == 0);       // 等价



// 位运算的小技巧

// x &amp; (x - 1)         消掉最右边的 1

// x &amp; (-x)            取出最低位的 1

// __builtin_popcount(x)  数 1 的个数



// 关键:看到&quot;N 很大、但数值位宽很小(≤ 31 位)&quot;,优先想&quot;按位处理&quot;
②编程打卡 · 点一下就能勾选
☑ 已勾选 0 / 3 项点一下条目即可勾选
五级 · 编程 DAY 05

二分答案与查找

💻 编程题 4 道📚 知识点 二分答案与查找⏱ 建议用时 130 分钟
①本日知识点 · 二分答案与查找

先想清「答案的单调性」,再写 check;区间开闭不要混。

本组 4 道题全部来自 GESP 真题,按「二分答案与查找」归在一起练。题面取洛谷原题(含公式与样例),题解取美力程 GESP 题解库(思路 + 参考代码 + 复杂度)。

P15799找数2026-03 · 二分 / 离散化 / 队列
二分离散化队列双指针 two-pointerbitset哈希表STL
📝 题目描述

给定一个包含 n 个互不相同的正整数的数组 A 与一个包含 m 个互不相同的正整数的数组 B,请你帮忙计算有多少个数在数组 A 与数组 B 中均出现。
⌨️ 输入格式

第一行包含两个整数 n,m。

第二行包含 n 个正整数 a_1,a_2,…,a_n 表示数组 A。

第三行包含 m 个正整数 b_1,b_2,…,b_m 表示数组 B。

🖨 输出格式

输出一个整数,表示在数组 A 与数组 B 中均出现的数的个数。
🔎 样例
#输入输出
1
3 5
4 2 3
3 1 5 4 6
2
📌 说明 / 数据范围

样例解释
样例 1 中,4、3 在数组 A 与 B 中均出现。

数据范围
对于 40% 的数据,保证 1 ≤q n,m ≤q 1000。

对于 100% 的数据,保证 1 ≤q n,m ≤q 10^5,1 ≤q a_i,b_i ≤q 10^9。

💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
题目拆解
📝 题目原文
给定两个数组 A(n 个互不相同的正整数)与 B(m 个互不相同的正整数),请计算有多少个数在 A 与 B 中均出现。
💡人话翻译:这就是求两个集合的交集大小。最直接的做法:把 A 的所有元素放进一个"哈希集合",然后遍历 B,看每个元素是否在集合里。"互不相同"这个条件很关键——它意味着不存在重复计数的问题,所以答案就是"同时出现在两边"的元素个数。

🔍 关键词提取
集合哈希表交集快速查找
已知条件
项目说明
输入第一行 n、m;第二行 A 的 n 个数;第三行 B 的 m 个数
输出同时在 A 和 B 中出现的数的个数
数据范围1 ≤ n, m ≤ 10⁵
数值范围1 ≤ aᵢ, bᵢ ≤ 10⁹
重要前提A 内部元素互不相同,B 内部也互不相同
需要解决的问题
为什么不能开数组当桶?因为 aᵢ 可达 10⁹,数组开不下——需要哈希集合或先排序
怎么快速判断"是否在 A 中"?把 A 放进 unordered_set,查询平均 O(1)
要不要考虑重复?不用!题目保证两边各自互不相同,所以"在 B 中且出现在 A 里"直接计数即可

思维导图
🔍 集合求交

📥 读入
n、m ≤ 10⁵
A 内部互不相同
B 内部互不相同
值可达 10⁹

🗂️ 建集合
把 A 的元素插入哈希集合
unordered_set<int>
平均插入 O(1)
占用 O(n) 空间

🔁 遍历 B
对每个 b 查询是否在集合中
在 → 计数加 1
avg O(1) 查询
总共 O(m)

⚠️ 易错点
用数组当桶(10⁹ 开不下)
忘记"互不相同"这个前提
用 multiset 导致重复计数
读入用 int 但值可能较大

样例手算推导
🧮 样例:A = {4, 2, 3},B = {3, 1, 5, 4, 6}
按"先建集合、再查 B"的顺序走一遍。
1
第 1 步:把 A 放进集合
集合 S = {4, 2, 3}
用哈希集合存储,查询时间是 O(1)
集合建好

2
第 2 步:逐个检查 B 的元素
b = 3:在 S 中 ✅ → 计数 1
b = 1:不在 S 中 ❌
b = 5:不在 S 中 ❌
b = 4:在 S 中 ✅ → 计数 2
b = 6:不在 S 中 ❌
✅ 最终计数 2

B 的元素是否在 A 中累计计数
3✅ 是1
1❌ 否1
5❌ 否1
4✅ 是2
6❌ 否2
共同出现的数:3、4,共 2 个 ✓
🔑为什么"互不相同"这个条件让题目变简单了?如果允许重复,就变成"有多少对 (a, b) 相等"这样的多集问题,需要额外统计每个值在两边的出现次数。而本题保证两边各自无重复,所以"是否同时出现"就是 0/1 判断,直接计数即可。

🧮 两种思路的对比
除了哈希集合,还可以排序后双指针。我们比较一下。
方案做法复杂度
哈希集合A 入集合,遍历 B 查询O(n + m) 平均
排序 + 双指针A、B 都排序,两个指针同步推进O(n log n + m log m)
两重循环暴力对每个 b 扫一遍 AO(nm),10¹⁰ 必然超时
// 排序 + 双指针的写法(不用哈希也能做)
sort(a, a + n); sort(b, b + m);
int i = 0, j = 0, cnt = 0;
while (i < n && j < m) {
if (a[i] == b[j]) { cnt++; i++; j++; }
else if (a[i] < b[j]) i++;
else j++;
}
⚠️暴力法的代价:n、m 都达到 10⁵ 时,两重循环需要 10¹⁰ 次比较,远超时间限制。看到 10⁵ 这个量级,就要想到用集合或排序把复杂度降到近线性。

解法对比
⚔️ 解法对比
🟢 哈希集合(推荐) 推荐
A 存入 unordered_set,遍历 B 查询
平均时间 O(n + m)
代码 6 行
不需要排序
最直观
💡实现:unordered_set<int> s(a.begin(), a.end()); 然后 for (int x : b) if (s.count(x)) ans++;——两行搞定。

🟠 排序 + 双指针
两数组分别排序,用两个指针同步推进找相等
时间 O((n+m) log(n+m))
代码 12 行
需要额外排序开销
不使用哈希(某些环境更稳)
⚠️什么时候选它:如果题目还要求"按升序输出交集元素",那么排序法天然满足要求,而哈希法还要额外排序。本题只问个数,哈希法更省事。

📈 性能对比
方案时间复杂度代码量
哈希集合O(n + m) 平均约 6 行
排序双指针O((n+m) log(n+m))约 12 行

算法流程图
开始读入 n、m 和数组 A、B把 A 的所有元素插入哈希集合 Si 从 0 到 m−1,逐个取 B[i]B[i] 在集合 S 中吗?是 ✓答案加 1否 ✗跳过B 的元素都检查完了吗?输出答案结束i 加 1 继续← 左右滑动查看完整流程图
动手算一算
🔍 交集查找器

第一行输入数组 A,第二行输入数组 B,程序会找出共同出现的数。

输入两行数组4 2 3
3 1 5 4 6


算一下!
随机出题


结果会显示在这里

点按钮开始 →

代码精讲
💻 完整 C++ 代码
include <bits/stdc++.h>
using namespace std;

int main() {
int n, m;
scanf("%d %d", &n, &m);

unordered_set<int> s; // 存放数组 A 的元素
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
s.insert(x);
}

int ans = 0;
for (int i = 0; i < m; i++) {
int x;
scanf("%d", &x); // 边读边查,连 B 都不用存
if (s.count(x)) ans++; // 在 A 中出现过就计数
}

printf("%d\n", ans);
return 0;
}
🔑为什么 B 的元素不用存下来?因为题目只要求"总数",读到一个就查一次、立刻计数即可——这叫"流式处理",能省掉一个数组。在数据量很大时,这种写法能显著降低内存占用。

📖 关键几行怎么看
代码作用为什么这样写
unordered_set<int> s哈希集合值可达 10⁹,数组开不下,必须用哈希
s.insert(x)插入把 A 的元素全放进去
s.count(x)查询返回 0 或 1(集合内不重复)
if (s.count(x)) ans++;计数题目保证互不相同,直接计数不会重复
⚠️两个坑:① 用数组当桶(bool vis[1000000001] 开不下);② 用 multiset 或列表存 A 并逐个查找,会把复杂度退化成 O(nm) 而超时。

边界测试 &amp; 易错点
🧪 边界测试用例表
写完程序后,用这些数据自查一遍:
输入答案考察点
3 5
4 2 3
3 1 5 4 62题面样例
1 1
5
51单元素且相同
1 1
5
70单元素且不同
3 3
1 2 3
4 5 60完全无交集
3 3
1 2 3
1 2 33完全相同的两个数组
2 3
1000000000 1
1 1000000000 9992大数值,考察哈希(数组开不下)
✅自查清单:① 用的是哈希集合吗?② 查询用的是 count/find 吗?③ 时间复杂度是线性吗?

🚨 易错点清单
⚠️用数组当桶:aᵢ 可达 10⁹,开 10⁹ 大小的数组会内存溢出。

⚠️逐个查找代替集合:对 B 的每个元素都扫一遍 A,复杂度 O(nm) 会超时。

⚠️担心重复计数:题目保证两边各自互不相同,所以不需要额外处理重复。

复杂度分析
📊 复杂度四宫格
时间复杂度
O(n + m)

空间复杂度
O(n)

n, m 最大
10⁵

运算量
约 2 × 10⁵

时间怎么算的?
把 A 插入集合:n 次,平均 O(1) 每次
遍历 B 查询:m 次,平均 O(1) 每次
合计 O(n + m)
最坏 2 × 10⁵ 次操作
空间都用在哪?
需要为数组 A 建一个哈希集合,占用 O(n) 空间。
✅ 20 万次操作,瞬间完成。如果写成 O(nm),10¹⁰ 次会严重超时。

知识拓展
🔗 常用技巧小抄
// 集合求交的两种写法
// 写法一:哈希集合(推荐,近线性)
unordered_set<int> s(a.begin(), a.end());
int ans = 0;
for (int x : b) if (s.count(x)) ans++;

// 写法二:排序 + 双指针(要求输出有序交集时更方便)
sort(a.begin(), a.end());
sort(b.begin(), b.end());
vector<int> inter;
int i = 0, j = 0;
while (i < (int)a.size() && j < (int)b.size()) {
if (a[i] == b[j]) { inter.push_back(a[i]); i++; j++; }
else if (a[i] < b[j]) i++;
else j++;
}

// 如果数据范围较小(如 aᵢ ≤ 10⁷),也可以用位图/布尔数组
// bool vis[10000001];

🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
哈希集合平均 O(1) 查询判重、求交、两数之和、去重
排序 + 双指针O(n log n) 预处理求有序交集、合并有序数组
集合运算交/并/差集合论类题目
🌟思考题:如果题目改成"统计有多少个数在 A 和 B 中出现次数相同"(允许重复),该怎么改?(提示:用 unordered_map<int,int> 分别统计两边每个值的出现次数,然后遍历其中一个 map,比较两边计数是否相等。这就从"集合求交"变成了"频次比对"。)

💻 参考代码
// 排序 + 双指针的写法(不用哈希也能做)

sort(a, a + n); sort(b, b + m);

int i = 0, j = 0, cnt = 0;

while (i &lt; n &amp;&amp; j &lt; m) {

    if (a[i] == b[j]) { cnt++; i++; j++; }

    else if (a[i] &lt; b[j]) i++;

    else j++;

}
💻 参考代码
#include &lt;bits/stdc++.h&gt;

using namespace std;



int main() {

    int n, m;

    scanf(&quot;%d %d&quot;, &amp;n, &amp;m);



    unordered_set&lt;int&gt; s;          // 存放数组 A 的元素

    for (int i = 0; i &lt; n; i++) {

        int x;

        scanf(&quot;%d&quot;, &amp;x);

        s.insert(x);

    }



    int ans = 0;

    for (int i = 0; i &lt; m; i++) {

        int x;

        scanf(&quot;%d&quot;, &amp;x);           // 边读边查,连 B 都不用存

        if (s.count(x)) ans++;     // 在 A 中出现过就计数

    }



    printf(&quot;%d\n&quot;, ans);

    return 0;

}
💻 参考代码
// 集合求交的两种写法

// 写法一:哈希集合(推荐,近线性)

unordered_set&lt;int&gt; s(a.begin(), a.end());

int ans = 0;

for (int x : b) if (s.count(x)) ans++;



// 写法二:排序 + 双指针(要求输出有序交集时更方便)

sort(a.begin(), a.end());

sort(b.begin(), b.end());

vector&lt;int&gt; inter;

int i = 0, j = 0;

while (i &lt; (int)a.size() &amp;&amp; j &lt; (int)b.size()) {

    if (a[i] == b[j]) { inter.push_back(a[i]); i++; j++; }

    else if (a[i] &lt; b[j]) i++;

    else j++;

}



// 如果数据范围较小(如 aᵢ ≤ 10⁷),也可以用位图/布尔数组

// bool vis[10000001];
P10719黑白格2024-06 · 数学 / 二分 / 前缀和
数学二分前缀和
📝 题目描述
小杨有一个 n 行 m 列的网格图,其中每个格子要么是白色,要么是黑色。

小杨想知道至少包含 k 个黑色格子的最小子矩形包含了多少个格子。

⌨️ 输入格式
第一行包含三个正整数 n,m,k,含义如题面所示。

之后 n 行,每行⼀个长度为 m 的 \texttt{01} 串,代表网格图第 i 行格子的颜色,如果为 \texttt{0},则对应格子为白色,否则为黑色。

🖨 输出格式
输出一个整数,代表至少包含 k 个黑色格子的最小子矩形包含格子的数量,如果不存在则输出 0。
🔎 样例
#输入输出
1
4 5 5
00000
01111
00011
00011
6
📌 说明 / 数据范围
样例解释
对于样例 1,假设 (i,j) 代表第 i 行第 j 列,至少包含 5 个黑色格子的最小子矩形的四个顶点为 (2,4),(2,5),(4,4),(4,5),共包含 6 个格子。

数据范围
对于全部数据,保证有 1≤ n,m≤ 100,1≤ k≤ n× m。

| 子任务编号 | 得分 | n,m |
| :--: | :--: | :--: |
| 1 | 20 | ≤ 10 |
| 2 | 40 | n=1,1≤ m≤ 100 |
| 3 | 40 | ≤ 100|

Update on 2024/7/9:添加了若干组 hack 数据,感谢 @cff_0102 的贡献。

💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
题目拆解
📝 题目原文
给定 n 行 m 列的 01 网格(0 白、1 黑)。求至少包含 k 个黑色格子的子矩形中,包含格子总数的最小值;若不存在则输出 0。
例:4 × 5 网格、k = 5 时,最小子矩形是第 2~4 行、第 4~5 列,共 6 个格子(其中 6 个黑格)。
💡人话翻译:枚举所有子矩形,挑出"黑格数 ≥ k"的那些,取其中面积最小的。关键工具是二维前缀和——它能让"某个子矩形里有几个黑格"这个查询变成 O(1)。

🔍 关键词提取
二维前缀和枚举矩形边界最小面积可行性
已知条件
项目说明
输入第一行 n、m、k;随后 n 行 01 串
输出最小子矩形的格子数,无解输出 0
数据范围1 ≤ n, m ≤ 100
k 的范围1 ≤ k ≤ n × m
目标黑格数 ≥ k 且面积最小
需要解决的问题
要枚举多少矩形?约 (n(n+1)/2) × (m(m+1)/2) 个,n = m = 100 时约 2500 万个
怎么快速数黑格?用二维前缀和,O(1) 求出任意矩形的黑格数
怎么剪枝?如果当前面积已经 ≥ 已知最优答案,可以直接跳过

思维导图
⬛ 枚举边界 + 前缀和

📊 预处理
把 01 网格转成数值
建二维前缀和 pre[][]
矩形黑格数 O(1)
下标从 1 开始省特判

🔍 枚举矩形
上边界 r1、下边界 r2
左边界 c1、右边界 c2
面积 = 行数 × 列数
共约 2500 万个候选

✅ 判定与更新
黑格数 = 矩形和
若 ≥ k 且面积更小
更新答案
否则跳过

⚠️ 易错点
忘记无解输出 0
面积与和混淆
前缀和四个角写错
剪枝条件写反

样例手算推导
🧮 样例:4 × 5 网格,k = 5,答案 6
00000
01111
00011
00011
1
先看能否用 5 个格子达成
面积 5 的矩形只有两种形状:
1 × 5(一行五列)或 5 × 1(五行一列)
但网格只有 4 行,所以 5 × 1 不可能
1 × 5 要求某一行全是黑格:
第 1 行 0 个、第 2 行 4 个、第 3 行 2 个、第 4 行 2 个
都不到 5 → 面积 5 不行
❌ 面积 5 不可行

2
再看面积 6 的形状
面积 6 可能是 2 × 3 或 3 × 2(或 1 × 6、6 × 1,网格放不下)
试 3 × 2:第 2~4 行、第 4~5 列
第 2 行后两格:1 1
第 3 行后两格:1 1
第 4 行后两格:1 1
共 6 个黑格 ≥ 5 ✅,面积 6
✅ 面积 6 可行,答案 ≤ 6

3
还有更小的吗?
面积已经试过 1 ~ 5 都不可行(面积 5 不可行,更小的当然也不行)
所以 6 就是最小值
✅ 答案 6

📊 候选汇总
面积可能的形状黑格数能达到 k = 5 吗
1 ~ 4更小的矩形否(黑格数 < 5)
51 × 5 / 5 × 1否(行内最多 4 个黑格)
62 × 3 / 3 × 2✅ 是(第 2~4 行第 4~5 列)
答案 6 ✓
🔑注意"无解"的情况:如果整个网格的黑格总数都不到 k,那就不存在这样的子矩形,按要求输出 0。实现时可以先把答案初始化为 0,找到可行解再更新即可自然处理。

🧮 二维前缀和怎么用
二维前缀和 pre[i][j] 表示从 (1,1) 到 (i,j) 这个矩形内黑格的个数。
步骤公式说明
建表pre[i][j] = pre[i-1][j] + pre[i][j-1] − pre[i-1][j-1] + a[i][j]容斥原理:上 + 左 − 左上 + 自己
查询矩形 (r1,c1)~(r2,c2)pre[r2][c2] − pre[r1-1][c2] − pre[r2][c1-1] + pre[r1-1][c1-1]四个角做容斥
面积(r2 − r1 + 1) × (c2 − c1 + 1)行数 × 列数
⚠️注意 pre 的下标从 1 开始:这样 pre[r1-1][...] 在 r1 = 1 时自然是 0,pre[0][] 和 pre[][0] 全为 0,不需要任何边界特判。这是二维前缀和的标准技巧。

解法对比
⚔️ 解法对比
🟢 四重循环 + 前缀和(推荐) 推荐
枚举四条边界,用前缀和 O(1) 查黑格数
时间 O(n²m²)
n = m = 100 时约 2500 万
每次查询 O(1)
代码 25 行
💡量级可行性:2500 万次循环,每次只做几次加法和比较,C++ 大约 0.1 ~ 0.3 秒,完全在时限内。

🟠 双指针滑动窗口
固定上下边界,让左右边界单调移动
理论复杂度更低
需要"黑格数单调"这个性质
实现复杂、易错
本题没必要
⚠️为什么不容易做:固定上下边界后,随着右边界扩展黑格数确实单调增,但我们要的是"面积最小",需要枚举所有右边界再收缩左边界,虽然可行但实现繁琐。本题数据小,四重循环足够。

📈 性能对比
方案运算量(100 × 100)代码量
四重循环约 2.5 × 10⁷约 25 行
滑动窗口约 10⁴约 40 行

算法流程图
开始读入 n、m、k 和网格;建立二维前缀和 preans = 0(无解时输出 0)枚举上边界 r1 和下边界 r2枚举左边界 c1 和右边界 c2黑格数 = 矩形和;面积 = 行数 × 列数黑格数 ≥ k,且面积比已知答案更小(或答案还是 0)吗?是 ✓ans = 面积否 ✗跳过输出 ans结束继续枚举边界组合← 左右滑动查看完整流程图
动手算一算
⬛ 最小黑格子矩形查找器

第一行输入 n、m、k,随后 n 行 01 串,程序会找出满足条件的最小矩形。

输入数据4 5 5
00000
01111
00011
00011


算一下!
随机出题


结果会显示在这里

点按钮开始 →

代码精讲
💻 完整 C++ 代码
include <bits/stdc++.h>
using namespace std;

int pre[105][105];

int main() {
int n, m, k;
scanf("%d %d %d", &n, &m, &k);

// 建二维前缀和(下标从 1 开始)
for (int i = 1; i <= n; i++) {
string s;
cin >> s;
for (int j = 1; j <= m; j++) {
int v = s[j - 1] - '0';
pre[i][j] = pre[i-1][j] + pre[i][j-1] - pre[i-1][j-1] + v;
}
}

int ans = 0; // 0 表示暂无可行解

for (int r1 = 1; r1 <= n; r1++)
for (int r2 = r1; r2 <= n; r2++)
for (int c1 = 1; c1 <= m; c1++)
for (int c2 = c1; c2 <= m; c2++) {
// O(1) 求出矩形内黑格数
int ones = pre[r2][c2] - pre[r1-1][c2]
- pre[r2][c1-1] + pre[r1-1][c1-1];
if (ones < k) continue;

int area = (r2 - r1 + 1) * (c2 - c1 + 1);
if (ans == 0 || area < ans) ans = area;
}

printf("%d\n", ans); // 无解时自然输出 0
return 0;
}
🔑为什么用 ans == 0 表示"暂无解"?因为题目规定"无解输出 0",而面积至少是 1,所以 0 可以安全地当作"尚未找到"的标记。这样更新条件写成 if (ans == 0 || area < ans),最后直接输出 ans 就同时满足了"有解输出最小值、无解输出 0"。

📖 关键几行怎么看
代码作用为什么这样写
pre[i][j] = pre[i-1][j] + pre[i][j-1] - pre[i-1][j-1] + v前缀和递推容斥原理
ones = pre[r2][c2] - pre[r1-1][c2] - pre[r2][c1-1] + pre[r1-1][c1-1]矩形内黑格数四个角的容斥,O(1) 完成
if (ones < k) continue;筛选黑格数不够直接跳过
if (ans == 0 || area < ans)更新最小值ans == 0 兼顾"首次找到"和"无解"两种情况
⚠️三个坑:① 前缀和公式漏掉 + pre[r1-1][c1-1];② 把"黑格数"和"面积"混淆(黑格数 ≥ k 是条件,面积是目标);③ 忘记"无解输出 0"(用 ans 初值 0 可自然处理)。

边界测试 &amp; 易错点
🧪 边界测试用例表
写完程序后,用这些数据自查一遍:
输入答案考察点
4 5 5
00000 / 01111 / 00011 / 000116题面样例
1 1 1
11单格黑格
1 1 1
00无解(没有黑格)
2 2 4
11 / 114k 等于总黑格数,必须取整个网格
3 3 3
111 / 000 / 0003第一行三个黑格,取 1 × 3
2 3 5
111 / 0115共 5 个黑格,整个 2 × 3 网格是唯一选择
✅自查清单:① 前缀和四个角对吗?② 区分了黑格数和面积吗?③ 无解输出了 0 吗?

🚨 易错点清单
⚠️前缀和公式错:必须是"上 + 左 − 左上",查询时是"右下 − 上 − 左 + 左上"。

⚠️混淆黑格数与面积:条件是黑格数 ≥ k,要最小化的是面积。

⚠️忘记无解输出 0:ans 初值取 0 可以自然处理。

复杂度分析
📊 复杂度四宫格
时间复杂度
O(n²m²)

空间复杂度
O(nm)

n, m 最大
100

最坏运算
约 2.5 × 10⁷

时间怎么算的?
前缀和预处理 O(nm)
枚举四条边界:约 (n(n+1)/2) × (m(m+1)/2) 个
n = m = 100 时约 2500 万个矩形
每个用 O(1) 查询
空间都用在哪?
一个 (n+1) × (m+1) 的前缀和数组。
✅ 约 2500 万次操作,C++ 约 0.1 ~ 0.3 秒,可通过。

知识拓展
🔗 常用技巧小抄
// 二维前缀和模板(下标从 1 开始)
int pre[N][M], a[N][M];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
pre[i][j] = pre[i-1][j] + pre[i][j-1] - pre[i-1][j-1] + a[i][j];

// 查询矩形和
int rectSum(int r1, int c1, int r2, int c2) {
return pre[r2][c2] - pre[r1-1][c2] - pre[r2][c1-1] + pre[r1-1][c1-1];
}

// 剪枝思路(可以加,但本题不加也够快)
// 如果当前面积已经 >= 已知最优答案,就没必要继续(内层循环可提前 break)
// 因为固定 r1、c1 时,随 r2、c2 增大面积单调增

// "无解输出 0"的巧妙处理:把答案初值设为 0,更新条件加 ans == 0

🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
二维前缀和O(1) 矩形查询子矩阵统计、区域计数、图像处理
枚举四条边界小规模网格的通用解法求最优子矩形类问题
用 0 当"无解标记"面积恒 ≥ 1所有"无解输出特定值"的题
🌟思考题:如果 n、m 放大到 1000,四重循环的 10¹² 就超时了。该怎么优化?(提示:可以二分答案"边长"或"面积"——但更常用的思路是"固定上下边界 + 双指针左右边界",利用"右边界右移时黑格数单调增"这个性质把内层降到 O(m),整体 O(n²m)。这类"固定两维 + 单调性优化另外两维"是二维问题的常用降维套路。)

💻 参考代码
00000

01111

00011

00011
💻 参考代码
#include &lt;bits/stdc++.h&gt;

using namespace std;



int pre[105][105];



int main() {

    int n, m, k;

    scanf(&quot;%d %d %d&quot;, &amp;n, &amp;m, &amp;k);



    // 建二维前缀和(下标从 1 开始)

    for (int i = 1; i &lt;= n; i++) {

        string s;

        cin &gt;&gt; s;

        for (int j = 1; j &lt;= m; j++) {

            int v = s[j - 1] - &#x27;0&#x27;;

            pre[i][j] = pre[i-1][j] + pre[i][j-1] - pre[i-1][j-1] + v;

        }

    }



    int ans = 0;                       // 0 表示暂无可行解



    for (int r1 = 1; r1 &lt;= n; r1++)

        for (int r2 = r1; r2 &lt;= n; r2++)

            for (int c1 = 1; c1 &lt;= m; c1++)

                for (int c2 = c1; c2 &lt;= m; c2++) {

                    // O(1) 求出矩形内黑格数

                    int ones = pre[r2][c2] - pre[r1-1][c2]

                             - pre[r2][c1-1] + pre[r1-1][c1-1];

                    if (ones &lt; k) continue;



                    int area = (r2 - r1 + 1) * (c2 - c1 + 1);

                    if (ans == 0 || area &lt; ans) ans = area;

                }



    printf(&quot;%d\n&quot;, ans);               // 无解时自然输出 0

    return 0;

}
💻 参考代码
// 二维前缀和模板(下标从 1 开始)

int pre[N][M], a[N][M];

for (int i = 1; i &lt;= n; i++)

    for (int j = 1; j &lt;= m; j++)

        pre[i][j] = pre[i-1][j] + pre[i][j-1] - pre[i-1][j-1] + a[i][j];



// 查询矩形和

int rectSum(int r1, int c1, int r2, int c2) {

    return pre[r2][c2] - pre[r1-1][c2] - pre[r2][c1-1] + pre[r1-1][c1-1];

}



// 剪枝思路(可以加,但本题不加也够快)

// 如果当前面积已经 &gt;= 已知最优答案,就没必要继续(内层循环可提前 break)

// 因为固定 r1、c1 时,随 r2、c2 增大面积单调增



// &quot;无解输出 0&quot;的巧妙处理:把答案初值设为 0,更新条件加 ans == 0
P13013奖品兑换2025-06 · 二分 / 整数规划
二分整数规划
📝 题目描述
班主任给上课专心听讲、认真完成作业的同学们分别发放了若干张课堂优秀券和作业优秀券。同学们可以使用这两种券找班主任兑换奖品。具体来说,可以使用 a 张课堂优秀券和 b 张作业优秀券兑换一份奖品,或者使用 b 张课堂优秀券和 a 张作业优秀券兑换一份奖品。

现在小 A 有 n 张课堂优秀券和 m 张作业优秀券,他最多能兑换多少份奖品呢?

⌨️ 输入格式
第一行,两个正整数 n,m,分别表示小 A 持有的课堂优秀券和作业优秀券的数量。

第二行,两个正整数 a,b,表示兑换一份奖品所需的两种券的数量。

🖨 输出格式
输出共一行,一个整数,表示最多能兑换的奖品份数。
🔎 样例
#输入输出
1
8 8
2 1
5
2
314159 2653589
27 1828
1599
📌 说明 / 数据范围
对于 60% 的测试点,保证 1 ≤ a,b ≤ 100,1 ≤ n,m ≤ 500。

对于所有测试点,保证 1 ≤ a,b ≤ 10^4,1 ≤ n,m ≤ 10^9。

💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
题目拆解
📝 题目原文
可用 a 张课堂券 + b 张作业券 兑换一份奖品,或 b 张课堂券 + a 张作业券 兑换一份奖品。
现在有 n 张课堂券和 m 张作业券,求最多能兑换多少份奖品。
💡人话翻译:每份奖品的"券配方"有两种:(a, b) 或 (b, a)。设用第一种配方兑换 x 份、第二种兑换 y 份,则要满足两个不等式;我们要最大化 x + y。这是一个"二分答案 + 检验可行性"的典型题。

🔍 关键词提取
二分答案可行性检验线性约束整数解
已知条件
项目说明
输入第一行 n、m(课堂券、作业券数量);第二行 a、b
输出最多兑换的奖品份数
数据范围1 ≤ a, b ≤ 10⁴,1 ≤ n, m ≤ 10⁹
两种配方(a, b) 或 (b, a)
目标最大化奖品份数
需要解决的问题
怎么设变量?设用配方 (a,b) 兑换 x 份,配方 (b,a) 兑换 y 份
约束是什么?x·a + y·b ≤ n 且 x·b + y·a ≤ m
怎么快速判断"能否兑换 k 份"?令 y = k − x,则两个不等式都变成关于 x 的线性约束,解出 x 的允许区间,看区间是否有整数

思维导图
📐 二分答案 + 解线性区间

🎯 二分什么
二分答案 k(奖品份数)
检验"能否兑换 k 份"
k 越大越难,有单调性
上界取 (n+m)/(a+b) 量级

🧮 检验方法
设配方 (a,b) 用 x 份
配方 (b,a) 用 k−x 份
代入两个不等式
化成 x 的取值范围

📊 解不等式
x·a + (k−x)·b ≤ n
x·b + (k−x)·a ≤ m
整理成 L ≤ x ≤ R
L ≤ R 且区间含整数 → 可行

⚠️ 易错点
用 int 溢出(n 可达 10⁹)
不等式方向搞反
忘记 x 要在 [0, k] 内
区间判空时忽略整数性

样例手算推导
🧮 样例 1:n = 8,m = 8,a = 2,b = 1
每份奖品需要 2 + 1 = 3 张券(两种配方合计都是 3 张),总券数 16,所以最多不可能超过 ⌊16 / 3⌋ = 5 份。
1
检验 k = 5
设配方 (2,1) 用 x 份,配方 (1,2) 用 5 − x 份
课堂券:2x + 1×(5−x) = x + 5 ≤ 8 → x ≤ 3
作业券:1×x + 2×(5−x) = 10 − x ≤ 8 → x ≥ 2
所以 x ∈ [2, 3],有整数解 ✅
✅ k = 5 可行

2
检验 k = 6
课堂券:2x + (6−x) = x + 6 ≤ 8 → x ≤ 2
作业券:x + 2(6−x) = 12 − x ≤ 8 → x ≥ 4
要求 x ≤ 2 且 x ≥ 4 → 无解
所以 k = 6 不可行
❌ k = 6 不可行

kx 的下界x 的上界是否有整数解
52(来自作业券)3(来自课堂券)✅ 有
642❌ 无(下界 > 上界)
答案 5 ✓
🔑检验的核心是把"二元一次不等式组"化成一元区间。因为 y = k − x,两个不等式都只含 x,整理后得到 L ≤ x ≤ R;只要 L ≤ R 且 [L, R] 与 [0, k] 有整数交集,就可行。这一步判断是 O(1) 的,所以整体可以二分。

🧮 样例 2:大数据的验算
n = 314159,m = 2653589,a = 27,b = 1828,答案 1599。
1
上界估算
每份奖品两种配方合计都是 a + b = 1855 张券
总券数 = 314159 + 2653589 = 2967748
⌊2967748 / 1855⌋ = 1599.86… → 上界 1599
所以答案不超过 1599
上界 1599

2
检验 k = 1599 是否可行
课堂券约束:27x + 1828(1599−x) ≤ 314159
1828×1599 = 2922972,所以 2922972 − 1801x ≤ 314159
→ 1801x ≥ 2608813 → x ≥ 1448.5 → x ≥ 1449
作业券约束:1828x + 27(1599−x) ≤ 2653589
27×1599 = 43173,所以 43173 + 1801x ≤ 2653589
→ 1801x ≤ 2610416 → x ≤ 1449.4 → x ≤ 1449
两者合起来:x = 1449,唯一解 ✅
✅ k = 1599 可行,且它等于上界,所以是答案

答案 1599 ✓
⚠️注意变量的数量级:n 和 m 可达 10⁹,k × b 这类乘积会达到 10⁹ × 10⁴ = 10¹³,远超 int 范围,必须用 long long。这也是本题一个常见失分点。

解法对比
⚔️ 解法对比
🟢 二分答案 + O(1) 检验(推荐) 推荐
二分 k,每次用一元区间判断可行性
时间 O(log(n+m))
约 60 次检验
检验是 O(1)
代码 20 行
💡为什么可以二分:如果 k 份可行,那么少于 k 份也一定可行(少兑换几份总不会更难),所以可行性关于 k 单调,可以二分。

🟠 枚举 x 的取值
枚举配方 (a,b) 用多少份,再算配方 (b,a) 最多用多少份
枚举量可能达 10⁹
超时
但若 a、b 较小则可行
不如二分稳妥
⚠️注意:本题 n、m 可达 10⁹,而 a、b ≤ 10⁴,所以 x 的取值可能达到 10⁹ 量级,枚举会超时。(题目特意说明"时限下降为 400 毫秒",就是在提示需要 O(log) 的做法。)

📈 性能对比
方案复杂度可行性
二分答案O(log(n+m))✅ 稳过
枚举 xO(n / a)❌ 可能超时

算法流程图
开始读入 n、m、a、b;设二分区间 lo = 0,hi = (n + m) / (a + b)当 lo <= hi 时取 mid = (lo + hi) / 2令 y = mid − x,把两个不等式整理成 x 的区间 [L, R]区间内存在满足 0 ≤ x ≤ mid 的整数吗?是 ✓可行:记录答案,lo = mid + 1否 ✗不可行:hi = mid − 1输出记录的最大可行份数结束二分区间还有效 → 继续← 左右滑动查看完整流程图
动手算一算
🎁 奖品兑换计算器

输入 n、m 和 a、b,程序会用二分法求出最多能兑换的份数。

输入:第一行 n m,第二行 a b8 8
2 1


算一下!
随机出题


结果会显示在这里

点按钮开始 →

代码精讲
💻 完整 C++ 代码
include <bits/stdc++.h>
using namespace std;

long long n, m, a, b;

// 判断能否兑换 k 份
bool can(long long k) {
// 设用配方 (a,b) 兑换 x 份,则配方 (b,a) 兑换 k-x 份
// 约束1:ax + b(k-x) <= n -> (a-b)x <= n - bk
// 约束2:bx + a(k-x) <= m -> (b-a)x <= m - ak
long long L = 0, R = k;

// 处理约束1
long long c1 = a - b, r1 = n - b * k;
if (c1 > 0) R = min(R, r1 / c1);
else if (c1 < 0) L = max(L, (r1 + c1 + 1) / c1); // 注意负数向上取整
else if (r1 < 0) return false;

// 处理约束2
long long c2 = b - a, r2 = m - a * k;
if (c2 > 0) R = min(R, r2 / c2);
else if (c2 < 0) L = max(L, (r2 + c2 + 1) / c2);
else if (r2 < 0) return false;

return L <= R; // 区间非空即可行
}

int main() {
scanf("%lld %lld", &n, &m);
scanf("%lld %lld", &a, &b);

long long lo = 0, hi = (n + m) / (a + b) + 1, ans = 0;
while (lo <= hi) {
long long mid = (lo + hi) / 2;
if (can(mid)) { ans = mid; lo = mid + 1; }
else hi = mid - 1;
}

printf("%lld\n", ans);
return 0;
}
🔑为什么二分上界取 (n+m)/(a+b)?因为每兑换一份奖品,不论用哪种配方,都要消耗 a + b 张券(只是课堂券和作业券的分配不同)。所以份数不可能超过 ⌊(n+m)/(a+b)⌋。这个上界非常紧,能减少二分次数。

📖 关键几行怎么看
代码作用为什么这样写
(a-b)x <= n - bk整理约束把 y = k − x 代入消去一个变量
if (c1 > 0) R = min(R, r1/c1)上界正系数时解出 x ≤ r1/c1
L = max(L, (r1+c1+1)/c1)下界(负数除法的向上取整)C++ 整数除法向零取整,负数要手动调整
return L <= R;可行性区间非空说明存在整数 x
⚠️三个坑:① 用 int(k × b 可达 10¹³,必须 long long);② 负系数的"向上取整"处理错(C++ 除法向零取整);③ 忘记 x 还要满足 0 ≤ x ≤ k(初始化 L、R 时已包含)。

边界测试 &amp; 易错点
🧪 边界测试用例表
写完程序后,用这些数据自查一遍:
输入答案考察点
8 8
2 15题面样例 1
314159 2653589
27 18281599题面样例 2(大规模)
3 3
1 13两种配方相同,每份只需 2 张券
1 100
1 1001配方 (1,100) 用一次
1000000000 1000000000
1 11000000000每份 2 张券,共 2 × 10⁹ 张,可兑 10⁹ 份
✅自查清单:① 用 long long 吗?② 区间非空的判断对吗?③ 二分的单调性用对了吗?

🚨 易错点清单
⚠️用 int:k × b 可达 10⁹ × 10⁴ = 10¹³,必须用 long long。

⚠️负系数取整错误:C++ 整数除法向零取整,负系数解不等式时要手动实现"向上取整"。

⚠️忘记二分:枚举 x 的取值可能达 10⁹,会超时。

复杂度分析
📊 复杂度四宫格
时间复杂度
O(log(n+m))

空间复杂度
O(1)

n, m 最大
10⁹

二分次数
约 60 次

时间怎么算的?
每次检验做常数次算术运算
二分范围是 [0, (n+m)/(a+b)],不超过 10⁹
二分次数约 log₂(10⁹) ≈ 30 ~ 60 次
空间都用在哪?
只用几个变量。
✅ 几十次检验,瞬间完成。题目提示"时限下降为 400 毫秒",正是在提示要用 O(log) 的做法。

知识拓展
🔗 常用技巧小抄
// 二分答案的通用模板(求最大可行值)
long long lo = 0, hi = 上界, ans = 0;
while (lo <= hi) {
long long mid = (lo + hi) / 2;
if (判断可行(mid)) { ans = mid; lo = mid + 1; } // 可行 -> 试试更大
else hi = mid - 1; // 不可行 -> 调小
}

// 本题的可行性判断本质是"一元线性不等式组是否有整数解"
// (a-b)x <= n - bk
// (b-a)x <= m - ak
// 这类问题可以推广到更多约束的线性规划(小规模)

// 整数除法的取整方向
// C++: 7 / 2 = 3, -7 / 2 = -3 (向零取整)
// 向上取整的写法: (x + d - 1) / d (当 x >= 0, d > 0)
// 负数的向上取整: (x + d + 1) / d 需要仔细验证

🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
二分答案单调性 + O(1) 检验最大值最小、最小值最大类问题
线性约束化简代入消元变成区间二元一次不等式组、小规模线性规划
取整方向C++ 除法向零取整所有涉及"最多/最少整数"的题
🌟思考题:如果题目改成"有三种兑换配方"(比如还有 (a, c) 等),二分的框架还成立吗?(提示:成立——可行性仍然关于 k 单调。但每次检验就从"一元不等式组"变成二元或多元,O(1) 检验不再容易,可能需要枚举其中一个变量(如果能枚举)或者做小规模线性规划。这说明二分只是"外层框架",难点在于内层的可行性检验。)

💻 参考代码
#include &lt;bits/stdc++.h&gt;

using namespace std;



long long n, m, a, b;



// 判断能否兑换 k 份

bool can(long long k) {

    // 设用配方 (a,b) 兑换 x 份,则配方 (b,a) 兑换 k-x 份

    // 约束1:a*x + b*(k-x) &lt;= n   -&gt;   (a-b)*x &lt;= n - b*k

    // 约束2:b*x + a*(k-x) &lt;= m   -&gt;   (b-a)*x &lt;= m - a*k

    long long L = 0, R = k;



    // 处理约束1

    long long c1 = a - b, r1 = n - b * k;

    if (c1 &gt; 0) R = min(R, r1 / c1);

    else if (c1 &lt; 0) L = max(L, (r1 + c1 + 1) / c1);   // 注意负数向上取整

    else if (r1 &lt; 0) return false;



    // 处理约束2

    long long c2 = b - a, r2 = m - a * k;

    if (c2 &gt; 0) R = min(R, r2 / c2);

    else if (c2 &lt; 0) L = max(L, (r2 + c2 + 1) / c2);

    else if (r2 &lt; 0) return false;



    return L &lt;= R;                 // 区间非空即可行

}



int main() {

    scanf(&quot;%lld %lld&quot;, &amp;n, &amp;m);

    scanf(&quot;%lld %lld&quot;, &amp;a, &amp;b);



    long long lo = 0, hi = (n + m) / (a + b) + 1, ans = 0;

    while (lo &lt;= hi) {

        long long mid = (lo + hi) / 2;

        if (can(mid)) { ans = mid; lo = mid + 1; }

        else hi = mid - 1;

    }



    printf(&quot;%lld\n&quot;, ans);

    return 0;

}
💻 参考代码
// 二分答案的通用模板(求最大可行值)

long long lo = 0, hi = 上界, ans = 0;

while (lo &lt;= hi) {

    long long mid = (lo + hi) / 2;

    if (判断可行(mid)) { ans = mid; lo = mid + 1; }   // 可行 -&gt; 试试更大

    else hi = mid - 1;                                 // 不可行 -&gt; 调小

}



// 本题的可行性判断本质是&quot;一元线性不等式组是否有整数解&quot;

// (a-b)*x &lt;= n - b*k

// (b-a)*x &lt;= m - a*k

// 这类问题可以推广到更多约束的线性规划(小规模)



// 整数除法的取整方向

// C++: 7 / 2 = 3,  -7 / 2 = -3   (向零取整)

// 向上取整的写法: (x + d - 1) / d   (当 x &gt;= 0, d &gt; 0)

// 负数的向上取整: (x + d + 1) / d 需要仔细验证
P14917数字移动2025-12 · 二分
二分
📝 题目描述
小 A 有一个包含 N 个正整数的序列 A={A_1,A_2,…,A_N},序列 A 恰好包含 \frac{N}{2} 对不同的正整数。形式化地,对于任意 1 ≤ i ≤ N,存在唯一一个 j 满足 1≤ j ≤ N, i≠q j, A_i=A_j。

小 A 希望每对相同的数字在序列中相邻,为了实现这一目的,小 A 每次操作会选择任意 i(1≤ i≤ N),将当前序列的第 i 个数字移动到任意位置,并花费对应数字的体力。

例如,假设序列 A={1,2,1,3,2,3},小 A 可以选择 i=2,将 A_2=2 移动到 A_3=1 的后面,此时序列变为 {1,1,2,3,2,3},耗费 2 点体力。小 A 也可以选择 i=3,将 A_3=1 移动到 A_2=2 的前面,此时序列变为 {1,1,2,3,2,3},花费 1 点体力。

小 A 可以执行任意次操作,但他希望自己每次花费的体力尽可能小。小 A 希望你能帮他计算出一个最小的 x,使得他能够在每次花费的体力均不超过 x 的情况下令每对相同的数字在序列中相邻。

⌨️ 输入格式
第一行一个正整数 N,代表序列长度,保证 N 为偶数。

第二行包含 N 个正整数 A_1,A_2,…,A_N,代表序列 A。且对于任意 1≤ i≤ N,存在唯一一个 j 满足 1≤ j≤ N,i≠q j,A_i=A_j。

数据保证小 A 至少需要执行一次操作。

🖨 输出格式
输出一行,代表满足要求的 x 的最小值。
🔎 样例
#输入输出
1
6
1 2 1 3 2 3
2
📌 说明 / 数据范围
对于 40% 的测试点,保证 1≤ N,A_i≤ 100。

对于所有测试点,保证 1≤ N,A_i≤ 10^5。

💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
题目拆解
📝 题目原文
序列 A 恰好包含 N/2 对不同的正整数(每个数都恰好出现两次)。每次操作可以选一个位置 i,把该位置的数字移动到任意位置,并花费该数字的值点体力。
求最小的 x,使得在每次花费都不超过 x 的前提下,能让每对相同的数字在序列中相邻。
例:A = 1 2 1 3 2 3 → 答案是 2。
💡人话翻译:"每次花费不超过 x"意味着值大于 x 的数字完全不能动,只有值 ≤ x 的数字才能被移动。所以这题是"二分答案 x + 检验可行性"。而检验的关键在于:不能动的数字(值 > x)之间的相对顺序永远不变。

🔍 关键词提取
二分答案相对顺序不变可行性检验成对相邻
已知条件
项目说明
输入第一行 N(偶数);第二行 N 个数
输出最小的 x
数据范围1 ≤ N, Aᵢ ≤ 10⁵
序列性质每个数恰好出现两次
操作代价移动一个值为 v 的数花费 v
需要解决的问题
x 的含义是什么?只有值 ≤ x 的数字可以移动;值 > x 的数字完全固定
检验条件是什么?把所有"不能动的数字"按原顺序抽出来,它们必须恰好构成 v v w w … 的形式(每个值的两次出现紧挨着)
为什么这样就行?夹在某一对之间、可以动的数字,可以被搬到别处去;而夹着的那对若中间有不能动的数字,就永远挪不开

思维导图
🔍 二分 x + 抽出不动的数检验

🎯 二分什么
二分答案 x
x 越大越容易(能动的数更多)
有单调性
在 [0, max(A)] 内二分

🧲 检验方法
把值 > x 的数按原序抽出
看它们是否形如 v v w w…
即每个值的两次出现相邻
是 → 可行

🧠 为什么对
不能动的数保持相对顺序
能动的数可搬到任意位置
所以只有"不动数之间是否夹着另一个不动数"要紧
能动的数总能配对好

⚠️ 易错点
以为检验条件与具体位置有关
二分上界取错
忘记 x 必须是某个出现过的值
没注意"至少需要一次操作"

样例手算推导
🧮 样例:A = 1 2 1 3 2 3,答案 2
值有 1、2、3,各出现两次。我们分别检验 x = 1 和 x = 2。
1
检验 x = 1
可以移动的:值为 1 的数(出现 2 次)
不能移动的:值为 2、3 的数
按原顺序抽出不能动的数:
位置 2 是 2、位置 4 是 3、位置 5 是 2、位置 6 是 3
所以抽出序列是 2, 3, 2, 3
检查:值为 2 的两次出现在第 1、3 位 → 不相邻 ✗
❌ x = 1 不可行

2
检验 x = 2
可以移动的:值为 1、2 的数
不能移动的:只有值为 3 的数
按原顺序抽出:位置 4 的 3、位置 6 的 3
所以抽出序列是 3, 3
检查:相邻 ✅
✅ x = 2 可行

📊 汇总
x不能动的数抽出的序列每对相邻?可行
01,2,3(全部)1,2,1,3,2,3❌否
12,32,3,2,3❌否
233,3✅是
3(无)(空)✅(空序列视为可行)是
最小的可行 x = 2 ✓
🔑注意 x = 3 时"不能动的数"是空集,此时检验总是通过——因为所有数都能动,总能排成 1 1 2 2 3 3 的形式。所以二分上界取最大值一定可行,保证二分会收敛。

🧮 手工验证 x = 2 确实能做到
检验通过只说明"理论上可行",我们实际动手排一遍。
1
原始序列
1 2 1 3 2 3
不能动的 3 在位置 4 和 6
3 的位置 4、6

2
把夹在中间的数搬走
位置 5 的 2 夹在两个 3 之间
把它移到开头(花费 2 ≤ x = 2 ✓)
得到 2 1 2 1 3 3
3 现在相邻了 ✓

3
整理剩下可动的数
剩下的 1、2、1、2 可以任意重排
搬成 1 1 2 2 的形式
最终 1 1 2 2 3 3
✅ 全部相邻

所有移动花费都不超过 2 ✓
💡 一个理解要点
可动的数之所以总能配对好,是因为每个值恰好出现两次——所以可动的数一定由"完整的对"组成,我们可以把它们成对地摆在一起。如果某个可动的值只出现一次,那就无法配对了,幸好题目保证了"每个数恰好两次"这个前提。

解法对比
⚔️ 解法对比
🟢 二分答案 + 抽取检验(推荐) 推荐
二分 x,每次 O(N) 抽出不能动的数检查相邻性
时间 O(N log V)
约 17 轮 × N
逻辑清晰
代码 30 行
💡可行性单调:x 越大,能动的数越多、不能动的数越少,检验就越容易通过。所以可行域是"从某个值往上全部可行",可以二分求最小可行值。

🟠 直接找"必须保留"的冲突
分析哪些数之间必然冲突,直接推出答案
需要细致的分类讨论
容易漏情况
但可以做到 O(N) 一次扫描
实现难度反而更高
⚠️结论:本题的"二分 + 检验"框架虽然多一个 log 因子,但胜在思路清晰、不容易写错。而且 N ≤ 10⁵,log 因子完全可以接受。

📈 性能对比
方案复杂度实现难度
二分答案O(N log V)低
直接推导O(N)高(易漏情况)

算法流程图
开始读入 N 和序列 A;记录每个值出现的位置二分区间 lo = 0,hi = max(A)当 lo <= hi:取 mid = (lo + hi) / 2按原顺序抽出所有值 > mid 的数,得到序列 BB 中每个值的两次出现都相邻吗?是 ✓记录答案,hi = mid − 1否 ✗lo = mid + 1输出记录的最小可行 x结束二分区间还有效 → 继续← 左右滑动查看完整流程图
动手算一算
🔍 最小移动花费上限

输入一个"每数恰好两次"的序列,程序会二分求出最小的 x。

输入序列


算一下!
随机出题


结果会显示在这里

点按钮开始 →

代码精讲
💻 完整 C++ 代码
include <bits/stdc++.h>
using namespace std;

int n;
int a[100005];

// 检验:当"花费上限为 x"时,能否让每对相邻
bool can(int x) {
vector<int> b;
for (int i = 0; i < n; i++)
if (a[i] > x) b.push_back(a[i]); // 抽出不能动的数(保持原顺序)

// b 必须恰好是 v v w w ... 的形式
if (b.size() % 2 != 0) return false;
for (size_t k = 0; k + 1 < b.size(); k += 2)
if (b[k] != b[k + 1]) return false;

return true;
}

int main() {
scanf("%d", &n);
int mx = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
mx = max(mx, a[i]);
}

// 二分最小的可行 x
int lo = 0, hi = mx, ans = mx;
while (lo <= hi) {
int mid = (lo + hi) / 2;
if (can(mid)) { ans = mid; hi = mid - 1; }
else lo = mid + 1;
}

printf("%d\n", ans);
return 0;
}
🔑为什么"抽出的序列必须是 v v w w …"?因为不能动的数之间相对顺序绝对不变,而它们最终必须两两相邻。如果抽出的序列是 2, 3, 2, 3,那么两个 2 之间永远夹着一个 3(3 也不能动),2 和 2 永远无法相邻。反之如果是 2, 2, 3, 3 就刚好成对 ✓。

📖 关键几行怎么看
代码作用为什么这样写
if (a[i] > x) b.push_back(a[i])抽取不动数按原顺序抽出,顺序信息很重要
if (b.size() % 2 != 0) return false长度检查成对出现,长度必须是偶数
if (b[k] != b[k+1]) return false相邻检查每两位必须相等
hi = mid - 1 / lo = mid + 1二分可行就试着更小,不可行就增大
⚠️三个坑:① 把检验写成"看原序列里是否相邻"(应该看抽取后的序列);② 二分写反(可行时应往小的一侧收缩);③ 忘记"可动的数一定能配对好"这个前提来自"每数恰好两次"。

边界测试 &amp; 易错点
🧪 边界测试用例表
写完程序后,用这些数据自查一遍:
输入答案考察点
6
1 2 1 3 2 32题面样例
2
5 50已经相邻,不需要操作
4
2 2 1 10每对都已相邻
4
1 2 1 21x = 0 时抽出 1,2,1,2 不合;x = 1 时抽出 2,2 ✅
6
3 1 3 1 3 3运行验证含重复超过两次,超出题意
✅自查清单:① 抽出的是值 > x 的数吗?② 检查了 v v w w 形式吗?③ 二分方向对吗?

🚨 易错点清单
⚠️检验用错对象:必须把不能动的数抽出来再检查相邻性,不能直接看原序列。

⚠️二分方向反:可行时应尝试更小的 x(hi = mid - 1)。

⚠️忽略"每数恰好两次":这是"可动的数一定能配好对"的保证。

复杂度分析
📊 复杂度四宫格
时间复杂度
O(N log V)

空间复杂度
O(N)

N 最大
10⁵

V = max(A)
10⁵

时间怎么算的?
每轮检验 O(N)
二分约 log₂(10⁵) ≈ 17 轮
合计约 1.7 × 10⁶ 次操作
空间都用在哪?
检验时需要临时数组存放抽出的数,O(N)。
✅ 约 170 万次操作,瞬间完成。关键洞察是"不能动的数相对顺序不变"。

知识拓展
🔗 常用技巧小抄
// 二分答案求"最小可行值"的模板
int lo = 0, hi = 上界, ans = 上界;
while (lo <= hi) {
int mid = (lo + hi) / 2;
if (can(mid)) { ans = mid; hi = mid - 1; } // 可行 -> 试更小
else lo = mid + 1; // 不可行 -> 增大
}

// "相对顺序不变"是很多题的突破口
// 例如:只允许交换相邻元素 -> 逆序对
// 只允许删除元素 -> 子序列问题
// 部分元素不可移动 -> 本题

// 判断"某序列是否形如 v v w w ..."
for (size_t k = 0; k + 1 < b.size(); k += 2)
if (b[k] != b[k + 1]) return false;

🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
二分答案单调性 + O(N) 检验最大化最小值、最小化最大值
相对顺序不变保留顺序的子序列删除/移动类问题的核心观察
可行性判定把约束化简为局部检查所有构造类问题
🌟思考题:如果操作改成"移动一个数为 v 的数需要花费 v²",算法的框架变吗?(提示:框架不变——仍然是"二分上限 x",只是判断"某个数能否移动"时,条件变成 v² ≤ x 而不是 v ≤ x。这说明二分答案的框架对"代价函数"的具体形式不敏感。)

💻 参考代码
#include &lt;bits/stdc++.h&gt;

using namespace std;



int n;

int a[100005];



// 检验:当&quot;花费上限为 x&quot;时,能否让每对相邻

bool can(int x) {

    vector&lt;int&gt; b;

    for (int i = 0; i &lt; n; i++)

        if (a[i] &gt; x) b.push_back(a[i]);   // 抽出不能动的数(保持原顺序)



    // b 必须恰好是 v v w w ... 的形式

    if (b.size() % 2 != 0) return false;

    for (size_t k = 0; k + 1 &lt; b.size(); k += 2)

        if (b[k] != b[k + 1]) return false;



    return true;

}



int main() {

    scanf(&quot;%d&quot;, &amp;n);

    int mx = 0;

    for (int i = 0; i &lt; n; i++) {

        scanf(&quot;%d&quot;, &amp;a[i]);

        mx = max(mx, a[i]);

    }



    // 二分最小的可行 x

    int lo = 0, hi = mx, ans = mx;

    while (lo &lt;= hi) {

        int mid = (lo + hi) / 2;

        if (can(mid)) { ans = mid; hi = mid - 1; }

        else lo = mid + 1;

    }



    printf(&quot;%d\n&quot;, ans);

    return 0;

}
💻 参考代码
// 二分答案求&quot;最小可行值&quot;的模板

int lo = 0, hi = 上界, ans = 上界;

while (lo &lt;= hi) {

    int mid = (lo + hi) / 2;

    if (can(mid)) { ans = mid; hi = mid - 1; }   // 可行 -&gt; 试更小

    else lo = mid + 1;                            // 不可行 -&gt; 增大

}



// &quot;相对顺序不变&quot;是很多题的突破口

// 例如:只允许交换相邻元素 -&gt; 逆序对

//       只允许删除元素   -&gt; 子序列问题

//       部分元素不可移动 -&gt; 本题



// 判断&quot;某序列是否形如 v v w w ...&quot;

for (size_t k = 0; k + 1 &lt; b.size(); k += 2)

    if (b[k] != b[k + 1]) return false;
②编程打卡 · 点一下就能勾选
☑ 已勾选 0 / 5 项点一下条目即可勾选
五级 · 编程 DAY 06

前缀和与区间统计

💻 编程题 1 道📚 知识点 前缀和与区间统计⏱ 建议用时 55 分钟
①本日知识点 · 前缀和与区间统计

prefix[i] = prefix[i-1] + a[i];区间和 = prefix[r] - prefix[l-1]。

本组 1 道题全部来自 GESP 真题,按「前缀和与区间统计」归在一起练。题面取洛谷原题(含公式与样例),题解取美力程 GESP 题解库(思路 + 参考代码 + 复杂度)。

P14074有趣的数字和2025-09 · 数学 / 分治 / 记忆化搜索
数学分治记忆化搜索数位 DP进制组合数学前缀和位运算
📝 题目描述
如果一个正整数的二进制表示包含奇数个 1,那么小 A 就会认为这个正整数是有趣的。

例如,7 的二进制表示为 (111)_2,包含 1 的个数为 3 个,所以 7 是有趣的。但是 9=(1001)_2 包含 2 个 1,所以 9 不是有趣的。

给定正整数 l,r,请你统计满足 l≤ n≤ r 的有趣的整数 n 之和。

⌨️ 输入格式
一行,两个正整数 l,r,表示给定的正整数。
🖨 输出格式
一行,一个正整数,表示 l,r 之间有趣的整数之和。
🔎 样例
#输入输出
1
3 8
19
2
65 36248
328505490
📌 说明 / 数据范围
【数据范围】

对于 40% 的测试点,保证 1≤ l≤ r≤ 10^4。

对于另外 30% 的测试点,保证 l=1 并且 r=2^k-1,其中 k 是大于 1 的正整数。

对于所有测试点,保证 1 ≤ l≤ r≤ 10^9。

【提示】

由于本题的数据范围较大,整数类型请使用 long long。

💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
题目拆解
📝 题目原文
若一个正整数的二进制表示包含奇数个 1,则称它是有趣的。如 7 = (111)₂ 有 3 个 1 所以有趣;9 = (1001)₂ 有 2 个 1 所以不有趣。
给定 l、r,求所有满足 l ≤ n ≤ r 的有趣整数之和。
💡人话翻译:这类"区间内满足某性质的数之和"都用前缀相减:记 f(X) 为 [0, X] 中所有有趣数之和,答案 = f(r) − f(l−1)。
而算 f(X) 的关键是按二进制位"分块统计":从高位到低位,每当 X 的某一位是 1,就可以把"这一位取 0、低位任意"的数整体算一遍。

🔍 关键词提取
二进制位统计前缀相减组合计数子块分解
已知条件
项目说明
输入一行两个正整数 l、r
输出区间内有趣数之和
数据范围1 ≤ l ≤ r ≤ 10⁹
有趣的定义二进制表示中 1 的个数为奇数
注意r ≤ 10⁹ < 2³⁰,所以只需考虑 0 ~ 29 位
需要解决的问题
为什么不能暴力?r 可达 10⁹,逐个枚举并统计 popcount 是 O(10⁹),会超时(题目也提示"时限下调")
怎么"分块"?设当前处理到第 i 位,若 X 的第 i 位为 1,那么"高位与 X 相同、第 i 位取 0、低位 i 位任意"的这 2^i 个数一定都 < X
怎么快速算这一块的"和"?在这一块里,低 i 位中"popcount 为奇/偶"的个数各占一半,所以可以用公式直接算

思维导图
🔟 按位分块 + 前缀相减

🧮 前缀相减
记 f(X) = [0,X] 中有趣数之和
答案 = f(r) − f(l−1)
把区间问题化为前缀问题
f 只需处理单点

📦 分块思想
从高位到低位扫 X
X 的某位为 1 时
"该位取 0、低位任意"整块 每块大小 2^i

📐 块内公式
前缀 popcount 记为 pc
需要 pc + 低位 popcount 为奇
低位 i 位中奇/偶各 2^(i−1) 个
块的和也有闭式公式

⚠️ 易错点
答案超 int(Σn 可达 10¹⁷)
忘加 X 自身
i = 0 与 i = 1 需特判
低位和的公式记错

样例手算推导
🧮 样例 1:l = 3,r = 8,答案 19
先直接列出区间内的数,确认理解正确。
n二进制1 的个数有趣?
3112✗
41001✓
51012✗
61102✗
71113✓
810001✓
有趣的是 4、7、8 → 4 + 7 + 8 = 19 ✓
接下来用"前缀相减 + 按位分块"算一遍,验证方法的正确性。
1
先算 f(2):[0, 2] 中的有趣数
0 = 0(0 个 1,偶)✗
1 = 1(1 个 1,奇)✓
2 = 10(1 个 1,奇)✓
f(2) = 1 + 2 = 3
f(2) = 3

2
再算 f(8)
按位分块计算(见下文的分块演示)
f(8) = 1 + 2 + 4 + 7 + 8 = 22
f(8) = 22

3
相减
答案 = f(8) − f(2) = 22 − 3 = 19
✅ 19

📌注意 f(2) 包含 2 而 f(8) − f(2) 不含——[0,8] 减去 [0,2] 正好是 [3,8],所以 2 被正确排除。这就是"前缀相减"必须用 f(r) − f(l−1) 的原因。

🧮 f(X) 的按位分块演示(X = 8)
8 = 1000₂,只有第 3 位是 1。
1
扫到第 3 位(X 此位为 1)
"高位与 X 相同、第 3 位取 0、低 3 位任意" 的数:
高位部分(第 4 位及以上)都是 0 → 前缀值 P = 0
这些数 = 0 ~ 7,共 8 个
前缀已确定的 popcount:pc = 0(偶数)
要让总的 popcount 为奇数 → 需要低 3 位的 popcount 为奇数
块 = [0, 7]

2
算这一块的个数与和
低 3 位中 popcount 为奇数的个数 = 2^(3−1) = 4
(分别是 001、010、100、111 → 1、2、4、7)
这 4 个数的和 = 1 + 2 + 4 + 7 = 14
贡献 14

3
别忘了 X 自己
扫完之后,还要单独看 X = 8 本身
popcount(8) = 1(奇数)→ 有趣
所以再加上 8
f(8) = 14 + 8 = 22 ✓

块(第 i 位)前缀 P前缀 pc需要的低位奇偶个数低位之和
第 3 位(取 0)00(偶)奇2² = 42¹ × (2³−1) = 14
X = 8 自身—1(奇)—18
合计522
⚠️公式的两个特例:低 i 位中"popcount 为奇"的个数,在 i ≥ 1 时是 2^(i−1);而"低位值之和"的公式 2^(i−2) × (2^i − 1) 只在 i ≥ 2 时成立。
i = 1 时:低位只有 0、1 两种,奇数 popcount 的只有 1,和为 1;偶数 popcount 的只有 0,和为 0。
i = 0 时:低位为空,popcount 恒为 0(偶数),此时只有前缀 pc 为奇数才能凑成有趣。这两个特例是本题最容易写错的地方。

解法对比
⚔️ 解法对比
🟢 按位分块统计(推荐) 推荐
f(r) 与 f(l−1) 各扫 30 位,用公式算每块贡献
时间 O(30)
常数极小,瞬间完成
代码 30 行
空间 O(1)
💡核心两步:① 用 f(r) − f(l−1) 把区间变成前缀;② 对 f(X) 从高位扫到低位,当 X 的第 i 位是 1 时,把"该位取 0、低位任意"的 2^i 个数用一个公式整体算掉。

🟠 逐数枚举 + popcount
从 l 枚举到 r,用 __builtin_popcount 判断
时间 O(r) = 10⁹
题目已提示"时限下调"
必然超时
只能通过 40% 的小数据
⚠️注意题目的提示:"为保证只有时间复杂度合理的算法通过本题,本题时限下调"——这等于明示"O(r) 的暴力过不了"。看到 r ≤ 10⁹ 且要统计"位"相关性质,就该想到"按位分块 / 数位 DP"。

📈 性能对比
方案复杂度可行性
按位分块O(30)✅ 稳过
逐数枚举O(r) = 10⁹❌ 超时

算法流程图
开始读入 l、r;答案 = f(r) − f(l − 1)进入 f(X):res = 0,pc = 0(前缀的 popcount)i 从 30 递减到 0X 的第 i 位是否为 1?是 ✓计算这一块否 ✗i 减 1按公式算出"该位取 0"那一块的个数与和,累加进 respc 加 1(这一位沿 X 取 1,继续贴着走)扫描结束后 pc 是否为奇数?是 ✓res 再加上 X 自身(因为 X 也有趣)否 ✗不加返回 resi 减 1 处理低位← 左右滑动查看完整流程图
动手算一算
🔟 有趣的数字和

输入 l 和 r,程序用"按位分块"算法计算结果,并与暴力枚举互相验证。

输入 l 和 r


算一下!
随机出题


结果会显示在这里

点按钮开始 →

代码精讲
💻 完整 C++ 代码
include <bits/stdc++.h>
using namespace std;

// 求 [0, X] 中"二进制含奇数个 1"的所有数之和
long long f(long long X) {
if (X < 0) return 0;
long long res = 0;
int pc = 0; // 已确定前缀中 1 的个数

for (int i = 30; i >= 0; i--) {
if ((X >> i) & 1) { // 第 i 位为 1,可以"分块"
long long cnt, sumLow;
if (i >= 2) {
cnt = 1LL << (i - 1); // 低位中奇数个 1 的个数
sumLow = (1LL << (i - 2)) * ((1LL << i) - 1); // 这些低位值之和
} else if (i == 1) {
// 低位只有 0(偶)和 1(奇)
if (pc % 2 == 0) { cnt = 1; sumLow = 1; } // 需要低位为奇 -> 取 1
else { cnt = 1; sumLow = 0; } // 需要低位为偶 -> 取 0
} else { // i == 0:低位为空,popcount 恒为 0(偶)
if (pc % 2 == 1) { cnt = 1; sumLow = 0; }
else { cnt = 0; sumLow = 0; }
}

long long pre = (X >> (i + 1)) << (i + 1); // 高位部分(i 位及以下清零)
res += cnt * pre + sumLow;

pc++; // 这一位沿 X 取 1,继续贴着走
}
}

if (pc % 2 == 1) res += X; // 别忘了 X 自身
return res;
}

int main() {
long long l, r;
scanf("%lld %lld", &l, &r);
printf("%lld\n", f(r) - f(l - 1));
return 0;
}
🔑为什么要用 long long?因为答案可能达到 10¹⁷ 量级——例如 [1, 10⁹] 里有趣数的和约为总量的一半,约 2.5 × 10¹⁷,远超 int 上限。题目提示也专门说了这一点。另外 1LL << i 里的 LL 不能省,否则 1 << 30 虽然没溢出,但后续乘法会以 int 进行而溢出。

📖 关键几行怎么看
代码作用为什么这样写
for (i = 30; i >= 0; i--)位扫描r ≤ 10⁹ < 2³⁰,最高位是第 29 位
if ((X >> i) & 1)分块条件X 该位为 1 时才能"取 0 分块"
cnt = 1LL << (i - 1)块内计数低 i 位中奇偶 popcount 各占一半
sumLow = (1LL << (i-2)) * ((1LL << i) - 1)块内求和i ≥ 2 时的公式
if (pc % 2 == 1) res += X;补上 XX 自身也要判断是否有趣
⚠️四个坑:① 用 int(答案可达 10¹⁷);② 忘记最后的 res += X;③ i = 1 和 i = 0 忘了特判;④ 1 << i 没用 1LL 导致后续乘法溢出。

边界测试 &amp; 易错点
🧪 边界测试用例表
写完程序后,用这些数据自查一遍:
输入答案考察点
3 819题面样例 1:4 + 7 + 8 = 19
65 36248328505490题面样例 2
1 111 有趣
2 222 = 10₂ 有趣
1 714有趣的是 1、2、4、7 → 1+2+4+7 = 14
1 1000000000运行验证最大范围,注意 long long
✅自查清单:① 用 long long 吗?② 加上了 X 自身吗?③ 两个特判写了吗?

🚨 易错点清单
⚠️用 int:答案可达 10¹⁷,必须用 long long。

⚠️忘记加 X 自身:分块只覆盖了"严格小于 X"的部分,X 本身要单独判断。

⚠️特判缺失:i = 1(低位只有 0、1)与 i = 0(低位为空)不能套用 i ≥ 2 的公式。

复杂度分析
📊 复杂度四宫格
时间复杂度
O(30)

空间复杂度
O(1)

r 最大
10⁹

运算量
常数级

时间怎么算的?
f(X) 扫 30 位,每位 O(1)
调用两次 f,共约 60 次运算
与 r 的大小无关
空间都用在哪?
只用几个变量。
✅ 常数级运算,瞬间完成。这正是题目"时限下调"想要的解法——复杂度与数据规模无关。

知识拓展
🔗 常用技巧小抄
// 数位统计的通用套路:把 [l, r] 化为 f(r) - f(l-1)
// f(X):从高位到低位扫,遇到 X 的 1 位就"分块"统计

// 常见目标与对应做法
// 1. 统计个数 -> 块内计数(2^(i-1) 之类)
// 2. 统计和 -> 块内计数 × 前缀值 + 低位之和
// 3. 统计平方和 -> 需要更复杂的展开(用 (P + l)^2)

// 位运算相关的小工具
__builtin_popcount(x) // int 的 popcount
__builtin_popcountll(x) // long long 的 popcount
__builtin_parity(x) // popcount 的奇偶性(1 表示奇数)

// 特例速记
// i >= 2:个数 2^(i-1),低位和 2^(i-2) * (2^i - 1)
// i == 1:低位只有 0/1,奇数 popcount 的是 {1},和 = 1
// i == 0:低位为空(偶),只有 pc 为奇数时才算 1 个

🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
前缀相减f(r) − f(l−1)所有"区间内满足条件的数"类问题
按位分块遇到 1 位就整块统计数位统计、数位 DP
与数据规模无关的复杂度O(位数)r 达 10⁹ ~ 10¹⁸ 的位统计题
🌟思考题:如果题目改成"求 [l, r] 中二进制含奇数个 1 的数的个数"(只要个数、不要和),代码要怎么改?(提示:更简单——只需把"块的和"换成"块的个数",即只累加 cnt,去掉 sumLow 和 pre 的部分。这说明"计数"是"求和"的简化版,而求和的难点在于要额外维护"这些数的值"。)

💻 参考代码
#include &lt;bits/stdc++.h&gt;

using namespace std;



// 求 [0, X] 中&quot;二进制含奇数个 1&quot;的所有数之和

long long f(long long X) {

    if (X &lt; 0) return 0;

    long long res = 0;

    int pc = 0;                        // 已确定前缀中 1 的个数



    for (int i = 30; i &gt;= 0; i--) {

        if ((X &gt;&gt; i) &amp; 1) {            // 第 i 位为 1,可以&quot;分块&quot;

            long long cnt, sumLow;

            if (i &gt;= 2) {

                cnt    = 1LL &lt;&lt; (i - 1);                   // 低位中奇数个 1 的个数

                sumLow = (1LL &lt;&lt; (i - 2)) * ((1LL &lt;&lt; i) - 1);  // 这些低位值之和

            } else if (i == 1) {

                // 低位只有 0(偶)和 1(奇)

                if (pc % 2 == 0) { cnt = 1; sumLow = 1; }  // 需要低位为奇 -&gt; 取 1

                else             { cnt = 1; sumLow = 0; }  // 需要低位为偶 -&gt; 取 0

            } else {                    // i == 0:低位为空,popcount 恒为 0(偶)

                if (pc % 2 == 1) { cnt = 1; sumLow = 0; }

                else             { cnt = 0; sumLow = 0; }

            }



            long long pre = (X &gt;&gt; (i + 1)) &lt;&lt; (i + 1);     // 高位部分(i 位及以下清零)

            res += cnt * pre + sumLow;



            pc++;                       // 这一位沿 X 取 1,继续贴着走

        }

    }



    if (pc % 2 == 1) res += X;          // 别忘了 X 自身

    return res;

}



int main() {

    long long l, r;

    scanf(&quot;%lld %lld&quot;, &amp;l, &amp;r);

    printf(&quot;%lld\n&quot;, f(r) - f(l - 1));

    return 0;

}
💻 参考代码
// 数位统计的通用套路:把 [l, r] 化为 f(r) - f(l-1)

// f(X):从高位到低位扫,遇到 X 的 1 位就&quot;分块&quot;统计



// 常见目标与对应做法

// 1. 统计个数  -&gt; 块内计数(2^(i-1) 之类)

// 2. 统计和    -&gt; 块内计数 × 前缀值 + 低位之和

// 3. 统计平方和 -&gt; 需要更复杂的展开(用 (P + l)^2)



// 位运算相关的小工具

__builtin_popcount(x)       // int 的 popcount

__builtin_popcountll(x)     // long long 的 popcount

__builtin_parity(x)         // popcount 的奇偶性(1 表示奇数)



// 特例速记

// i &gt;= 2:个数 2^(i-1),低位和 2^(i-2) * (2^i - 1)

// i == 1:低位只有 0/1,奇数 popcount 的是 {1},和 = 1

// i == 0:低位为空(偶),只有 pc 为奇数时才算 1 个
②编程打卡 · 点一下就能勾选
☑ 已勾选 0 / 2 项点一下条目即可勾选
五级 · 编程 DAY 07

数学推导与换算

💻 编程题 1 道📚 知识点 数学推导与换算⏱ 建议用时 55 分钟
①本日知识点 · 数学推导与换算

先化简公式再落代码;取整方向、模运算性质是丢分重灾区。

本组 1 道题全部来自 GESP 真题,按「数学推导与换算」归在一起练。题面取洛谷原题(含公式与样例),题解取美力程 GESP 题解库(思路 + 参考代码 + 复杂度)。

P13014最大公因数2025-06 · 数学
数学
📝 题目描述
对于两个正整数 a,b,他们的最大公因数记为 \gcd(a,b)。对于 k > 3 个正整数 c_1,c_2,…,c_k,他们的最大公因数为:

$\gcd(c_1,c_2,…,c_k)=\gcd(\gcd(c_1,c_2,…,c_{k-1}),c_k)

给定 n 个正整数 a_1,a_2,\dots,a_n 以及 q 组询问。对于第 i(1 \le i \le q) 组询问,请求出 a_1+i,a_2+i,\dots,a_n+i 的最大公因数,也即 \gcd(a_1+i,a_2+i,\dots,a_n+i)$。

⌨️ 输入格式
第一行,两个正整数 n,q,分别表示给定正整数的数量,以及询问组数。

第二行,n 个正整数 a_1,a_2,…,a_n。

🖨 输出格式
输出共 q 行,第 i 行包含一个正整数,表示 a_1+i,a_2+i,…,a_n+i 的最大公因数。
🔎 样例
#输入输出
1
5 3
6 9 12 18 30
1
1
3
2
3 5
31 47 59
4
1
2
1
4
📌 说明 / 数据范围
对于 60% 的测试点,保证 1 ≤ n ≤ 10^3,1 ≤ q ≤ 10。

对于所有测试点,保证 1 ≤ n ≤ 10^5,1 ≤ q ≤ 10^5,1 ≤ a_i ≤ 1000。

💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
题目拆解
📝 题目原文
给定 n 个正整数 a₁…aₙ 和 q 组询问。第 i 组询问求 gcd(a₁ + i, a₂ + i, …, aₙ + i)。
💡人话翻译:每次询问是把所有数同时加上 i,再求它们的最大公因数。如果每次询问都重新算一遍,q 组就是 O(nq),太慢。关键洞察:所有数同时加一个数,"两两之差"保持不变——所以可以先预处理出所有差值的 gcd,之后每组询问只需一次 gcd 运算。

🔍 关键词提取
gcd 性质差值不变式预处理多次询问
已知条件
项目说明
输入第一行 n、q;第二行 n 个数;共 q 组询问(第 i 组就是 +i)
输出q 行,每行一个答案
数据范围n, q ≤ 10⁵
询问形式第 i 组询问为 a_j + i(j = 1…n)
核心性质同时加同一个数,差值不变
需要解决的问题
为什么要算差值?设 g = gcd(a₂ − a₁, a₃ − a₁, …, aₙ − a₁),那么所有 a_j + i 两两之差都是 g 的倍数
结论是什么?gcd(a₁+i, a₂+i, …, aₙ+i) = gcd(a₁ + i, g)
n = 1 怎么办?此时没有差值,g = 0,所以答案是 gcd(a₁ + i, 0) = a₁ + i

思维导图
🔗 差值 gcd 不变式

🧠 核心性质
所有数同时加 i
两两之差完全不变
所以差的 gcd 也不变
记为 g

📐 化简结论
gcd(a₁+i, …, aₙ+i)
= gcd(a₁+i, a₂−a₁, …)
= gcd(a₁+i, g)
g = gcd of (a_j − a₁)

⚡ 加速查询
预处理一次 g:O(n log A)
每组询问 O(log A)
总共 O(n + q) 次 gcd
远快于 O(nq)

⚠️ 易错点
n = 1 时 g = 0,答案就是 a₁+i
差值要取绝对值
用 int 但答案可能大
忘记预处理导致超时

样例手算推导
🧮 样例 1:a = {6, 9, 12, 18, 30},询问 i = 1, 2, 3
先算差值 gcd。
1
预处理差值
以 a₁ = 6 为基准,其他数与它的差:
9 − 6 = 3、12 − 6 = 6、18 − 6 = 12、30 − 6 = 24
g = gcd(3, 6, 12, 24) = 3
g = 3

询问 ia₁ + igcd(a₁+i, g) = gcd(a₁+i, 3)答案
16 + 1 = 7gcd(7, 3)1
26 + 2 = 8gcd(8, 3)1
36 + 3 = 9gcd(9, 3)3
输出 1、1、3 ✓ 与样例一致
🔑验证一下 i = 3 的情况:a 变成 {9, 12, 15, 21, 33},直接求 gcd(9,12,15,21,33)——都能被 3 整除,所以是 3 ✓。而 gcd(9, 3) = 3 一步就得到了,不用把 5 个数都算一遍。

🧮 样例 2:a = {31, 47, 59}
差值:47 − 31 = 16、59 − 31 = 28 → g = gcd(16, 28) = 4。
询问 ia₁ + igcd(a₁+i, 4)答案
132gcd(32, 4) = 44
233gcd(33, 4) = 11
334gcd(34, 4) = 22
435gcd(35, 4) = 11
536gcd(36, 4) = 44
输出 4、1、2、1、4 ✓ 与样例一致
💡为什么这个等式成立?因为 gcd(x, y) = gcd(x, y − x)。反复使用:gcd(a₁+i, a₂+i) = gcd(a₁+i, a₂−a₁),再加上第三个数的运算,最终就得到 gcd(a₁+i, gcd(所有差值))。这是"更相减损术"的直接应用。

解法对比
⚔️ 解法对比
🟢 预处理差值 gcd(推荐) 推荐
先算 g = gcd(所有 a_j − a_1),每组询问只需 gcd(a_1+i, g)
预处理 O(n log A)
每组询问 O(log A)
总复杂度 O((n+q) log A)
代码 15 行
💡实现:int g = 0; for (j = 2; j <= n; j++) g = gcd(g, a[j] - a[1]); 然后每组询问输出 gcd(a[1] + i, g)。注意 gcd(x, 0) = x 这个性质让 n = 1 也能自然处理。

🟠 每组询问都重新求 gcd
对每个 i,遍历所有 n 个数求 gcd
每组 O(n log A)
总复杂度 O(nq log A)
n = q = 10⁵ 时约 10¹⁰ 次
必然超时
⚠️注意量级:n 和 q 都可达到 10⁵,相乘就是 10¹⁰,远超任何时间限制。必须利用"差值不变"这个性质把工作量降下来。

📈 性能对比
方案总复杂度n = q = 10⁵ 时
预处理差值O((n+q) log A)约 3 × 10⁶(可行)
每组重算O(nq log A)约 10¹⁰(超时)

算法流程图
开始读入 n、q 和数组 ag = 0j 从 2 到 n:g = gcd(g, a[j] − a[1])i 从 1 到 q输出 gcd(a[1] + i, g)q 组询问都回答完了吗?结束i 加 1 继续← 左右滑动查看完整流程图
动手算一算
🔗 多组询问最大公因数

第一行输入数组 a,第二行输入 q,程序会预留差值 gcd 并逐组给出答案。

输入数组 a(第一行)和 q(第二行)6 9 12 18 30
3


算一下!
随机出题


结果会显示在这里

点按钮开始 →

代码精讲
💻 完整 C++ 代码
include <bits/stdc++.h>
using namespace std;

long long a[100005];

int main() {
int n, q;
scanf("%d %d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);

// 预处理:所有数与 a[1] 之差的 gcd
long long g = 0;
for (int j = 2; j <= n; j++) {
g = __gcd(g, a[j] - a[1]); // gcd(0, x) = x,所以初值取 0 天然正确
}

// 逐组回答
for (long long i = 1; i <= q; i++) {
printf("%lld\n", __gcd(a[1] + i, g));
}
return 0;
}
🔑为什么 g 初值取 0 很方便?因为 gcd(0, x) = x,所以第一轮 g = gcd(0, a[2]-a[1]) = a[2]-a[1],相当于自动完成了初始化。而且 n = 1 时循环不执行,g 保持 0,此时答案 gcd(a[1]+i, 0) = a[1]+i 也正好正确——一个初值同时解决了两种情况。

📖 关键几行怎么看
代码作用为什么这样写
g = 0初值gcd(0, x) = x,天然处理首轮和 n = 1
g = gcd(g, a[j] - a[1])累积差值 gcd所有差值都是 g 的倍数
__gcd(a[1] + i, g)回答询问一步到位,不必遍历整个数组
long long类型a 的值和答案可能较大
⚠️三个坑:① 每组询问都重新遍历求 gcd(O(nq) 超时);② g 初值取了 a[2]-a[1] 而不是 0,导致 n = 1 时出错;③ 用 int 但数值范围较大。

边界测试 &amp; 易错点
🧪 边界测试用例表
写完程序后,用这些数据自查一遍:
输入答案考察点
5 3
6 9 12 18 301
1
3题面样例 1
3 5
31 47 594
1
2
1
4题面样例 2
1 3
78
9
10n = 1 时 g = 0,答案就是 a₁ + i
2 2
5 56
7两个数相同,差值 0,g = 0,答案即 a₁ + i
3 2
2 4 63
4差值 2、4 → g = 2;gcd(3,2)=1…需按公式算
✅自查清单:① 预处理了差值 gcd 吗?② g 初值取 0 吗?③ n = 1 的情况对吗?

🚨 易错点清单
⚠️每组重算:O(nq) 会超时,必须预处理差值 gcd 后 O(1)(一次 gcd)回答。

⚠️g 初值写错:应为 0(依赖 gcd(0,x)=x),否则 n = 1 时无法处理。

⚠️差值没取绝对值:虽然 gcd 会自动处理符号,但为清晰起见可以主动取绝对值。

复杂度分析
📊 复杂度四宫格
时间复杂度
O((n + q) log A)

空间复杂度
O(n)

n, q 最大
10⁵

运算量
约 3 × 10⁶

时间怎么算的?
预处理:n − 1 次 gcd,每次 O(log A)
每组询问:1 次 gcd
合计 O((n + q) log A)
n = q = 10⁵ 时约 300 万次运算
空间都用在哪?
需要存下数组 a(用于计算差值)。
✅ 约 300 万次运算,瞬间完成。相比 O(nq) 的 10¹⁰,优化了三个数量级。

知识拓展
🔗 常用技巧小抄
// 核心性质:gcd(a, b) = gcd(a, b - a) (更相减损术)
// 推广:gcd(x + i, y + i) = gcd(x + i, y - x)
// 所以 gcd(a1+i, a2+i, ..., an+i) = gcd(a1+i, gcd(a2-a1, ..., an-a1))

// 求多个数的 gcd
long long g = 0;
for (int j = 2; j <= n; j++) g = __gcd(g, a[j] - a[1]);

// 单次询问
long long ans = __gcd(a[1] + i, g);

// 类似技巧:差分数组
// 把"同时加/减"的操作转化成"差值不变",是处理区间操作的常用手段

🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
差值不变式同时加数 → 差值不变区间加减、平移类问题
gcd 更相减损gcd(x,y) = gcd(x,y−x)所有 gcd 相关的化简
预处理 + 快速查询把 O(n) 的判断降到 O(1)多次询问类题目
🌟思考题:如果询问改成"第 i 组求 a₁ × i, a₂ × i, …, aₙ × i 的 gcd",还能用类似的技巧吗?(提示:gcd(a₁i, a₂i, …, aₙi) = i × gcd(a₁, …, aₙ),只需预处理一次所有数的 gcd,之后每组询问乘上 i 即可——同样是"预处理 + O(1) 查询"的思路。注意 i × g 可能较大,用 long long。)

💻 参考代码
#include &lt;bits/stdc++.h&gt;

using namespace std;



long long a[100005];



int main() {

    int n, q;

    scanf(&quot;%d %d&quot;, &amp;n, &amp;q);

    for (int i = 1; i &lt;= n; i++) scanf(&quot;%lld&quot;, &amp;a[i]);



    // 预处理:所有数与 a[1] 之差的 gcd

    long long g = 0;

    for (int j = 2; j &lt;= n; j++) {

        g = __gcd(g, a[j] - a[1]);     // gcd(0, x) = x,所以初值取 0 天然正确

    }



    // 逐组回答

    for (long long i = 1; i &lt;= q; i++) {

        printf(&quot;%lld\n&quot;, __gcd(a[1] + i, g));

    }

    return 0;

}
💻 参考代码
// 核心性质:gcd(a, b) = gcd(a, b - a)  (更相减损术)

// 推广:gcd(x + i, y + i) = gcd(x + i, y - x)

// 所以 gcd(a1+i, a2+i, ..., an+i) = gcd(a1+i, gcd(a2-a1, ..., an-a1))



// 求多个数的 gcd

long long g = 0;

for (int j = 2; j &lt;= n; j++) g = __gcd(g, a[j] - a[1]);



// 单次询问

long long ans = __gcd(a[1] + i, g);



// 类似技巧:差分数组

// 把&quot;同时加/减&quot;的操作转化成&quot;差值不变&quot;,是处理区间操作的常用手段
②编程打卡 · 点一下就能勾选
☑ 已勾选 0 / 2 项点一下条目即可勾选
五级 · 模拟自测

五级模拟自测卷

✍️ 客观题 20⏱ 建议用时 50 分钟💯 满分 20 分
📝 五级模拟自测卷 · 12 单选 + 8 判断 · 每题 1 分
M模拟卷自编📌 覆盖本级别 7 天理论全部考点20 题 · 20 分
1.单选
gcd(48, 18) 的值是(  )。
2.单选
埃氏筛中,对素数 i 从 i*i 开始标记而不是从 i*2 开始,原因是(  )。
3.单选
线性筛(欧拉筛)的时间复杂度是(  )。
4.单选
360 的标准分解式是(  )。
5.单选
在单链表中,已知指针 p 指向某结点,在 p 之后插入新结点 s 的时间复杂度是(  )。
6.单选
在双向链表中删除结点 p(p 既非头也非尾),正确的操作顺序是(  )。
7.单选
二分查找中写 mid = lo + (hi - lo) / 2 而不是 (lo + hi) / 2,是为了(  )。
8.单选
递归函数求 n! 时,必须设置的递归出口是(  )。
9.单选
快速排序在平均情况下的时间复杂度是(  )。
10.单选
归并排序的空间复杂度是(  )。
11.单选
用数组模拟高精度加法时,进位应该(  )。
12.单选
用贪心法解决「用最少的纸币凑出指定金额」时,能保证最优的前提是(  )。
13.判断
埃氏筛的时间复杂度是 O(n log log n)。(  )
14.判断
单链表可以在 O(1) 时间内随机访问第 k 个结点。(  )
15.判断
二分查找要求待查数据必须有序。(  )
16.判断
递归函数如果缺少递归出口,会因调用栈过深而崩溃。(  )
17.判断
快速排序是稳定排序。(  )
18.判断
归并排序是稳定排序。(  )
19.判断
线性筛保证每个合数只被它的最小质因子筛掉一次。(  )
20.判断
贪心算法在任何问题上都能得到全局最优解。(  )
参考答案与解析
  • 1.B 48%18=12 → 18%12=6 → 12%6=0,除数 6
  • 2.B 如 6=2×3,在筛 2 的时候就已经标记了,重复标记是白做功
  • 3.C 每个合数只被它的最小质因子筛一次,总标记次数 ≤ n
  • 4.B 360 = 8×45 = 2³×3²×5
  • 5.A 只需改两根指针,与链表长度无关
  • 6.A 先把前后两个结点接上,再释放 p;B 顺序也可行,但考试标准答案按 A 记
  • 7.B lo、hi 都接近 int 上限时 lo+hi 会溢出成负数
  • 8.A 0! = 1! = 1;没有出口会无限递归直到栈溢出
  • 9.B 平均 O(n log n),最坏(每次基准都是极值)退化到 O(n²)
  • 10.C 归并需要与原数组等长的辅助数组
  • 11.B 与手算一致:从个位开始加,逢十进一
  • 12.B 面额不成规范体系时贪心会错,如面额 1、3、4 凑 6,贪心得 4+1+1(3 张),最优是 3+3(2 张)
  • 13.A 调和级数 ∑n/p ≈ n log log n
  • 14.B 必须从头遍历,是 O(k)
  • 15.A 无序就无法通过比较排除一半区间
  • 16.A 即栈溢出
  • 17.B 划分时相等元素可能被交换到别处
  • 18.A 合并时相等元素优先取左边即可保持稳定
  • 19.A 这正是它 O(n) 的原因
  • 20.B 贪心需要「最优子结构 + 贪心选择性质」
GESP C++ 五级 · 7 天理论 + 7 天编程 · 真题 165 道逐题标注期次与题号