蓝桥杯省赛必学算法清单：排序、二分、贪心、DP等核心考点全解析

1. 先给这份“半成品”算法清单定个位

先说说我为什么想写这个东西。蓝桥杯备赛群里最常见的问题就是：我该学哪些算法？要不要先把线段树啃下来？网络流会不会考？每次看到这种问题我都想按住对方的肩膀摇一摇——你先把手里的暴力分拿稳再说。

我自己的备赛经历比较有代表性。第一年参加蓝桥杯，当时刚学完C++语法，觉得自己行了，直接去刷某OJ上的困难题，什么后缀自动机、树链剖分，看了两天人都是懵的。结果到了省赛，真正卡住我的不是那些高级数据结构，而是最简单的模拟题没写对、贪心排序方向搞反了、BFS忘记标记已访问导致死循环。那次比赛给我最大的教训是：蓝桥杯的算法考察重心，和很多竞赛玩家的想象不太一样。

所以这份基础版清单，定位非常明确：完整覆盖蓝桥杯省赛里出现频率最高的那几类算法，包括排序与二分、字符串处理、贪心与模拟、图论基础、动态规划入门、数论与位运算。它不追求算法广度，也不追求把每个算法讲到天花乱坠的优化，而是告诉你每类算法在考场上的真实考法、常见变形、以及最容易踩的坑。为什么叫“半成品”？因为按我的规划，后面还有进阶篇，线段树、树状数组、状态压缩DP、网络流这些都会单独整理。但基础版本身已经是一套可以照着复习的完整路线，适合语法刚入门、还没开始系统刷题、或者刷了两三百道题但感觉脑子里还是一团浆糊的同学。

顺便回答一个高频问题：粒子群算法、模拟退火这些要不要学？我的建议是，省赛阶段完全不碰，国赛现场如果你发现要靠这两种算法才能解的题，说明你前面的基础算法已经足够扎实了，到时候再临场学也来得及。蓝桥杯省赛的获奖难度，大部分时候不在于算法多高深，而在于基础算法你能不能又快又稳地写对。

2. 排序与二分：最容易被轻视的送分题

2.1 各排序算法的选型逻辑

先看一张我整理的基础排序算法对比表，这张表我建议你贴在电脑旁边，或者在脑子里形成条件反射：

蓝桥杯考排序，大多数时候你真的只需要一行 sort(a, a + n)。但为什么我还要逼自己把六个排序全部手写一遍？因为蓝桥杯特别喜欢“借排序的壳，考算法的核”。比如归并排序，省赛题里经常不是让你排序，而是让你用归并的过程求逆序对；再比如快速排序的 partition 过程，是后面很多“第K大”类问题的基础。如果只是背一个sort的API，遇到这些变形题就会被卡住。

另外一个经常被忽略的点：Java组和Python组虽然自带排序，但C/C++组的sort底层是introsort，它综合了快排、堆排和插入排序，平均性能很好，但最坏情况在某些实现下仍是O(n log n)。手写排序时务必注意边界，特别是快速排序固定取第一个元素作为基准时，遇到已经有序的数组会退化成O(n²)，处理大量数据会直接超时。考场上的保守做法是直接用标准库排序，只有题目明确要求实现排序算法时才手写。

2.2 二分查找：边界问题一错就是死循环

二分查找是蓝桥杯的高频考点，但也是翻车重灾区。最常见的错误是死循环，比如下面这个反面教材：

cpp复制// 错误示范：当 l=2, r=3 时，mid=(l+r)/2=2，
// 如果目标值在右半部分，l=mid=2，永远无法退出循环
while (l < r) {
    int mid = (l + r) / 2;
    if (check(mid)) l = mid;
    else r = mid - 1;
}

正确模板其实只有两个，背熟其中一个即可。我习惯用“左闭右闭”的写法：

cpp复制// 找第一个满足 check(mid) 的位置
int l = 0, r = n - 1; // 左闭右闭区间
while (l < r) {
    int mid = (l + r) / 2;
    if (check(mid)) r = mid;
    else l = mid + 1;
}
// 找最后一个满足 check(mid) 的位置
int l = 0, r = n - 1;
while (l < r) {
    int mid = (l + r + 1) / 2; // 注意加1，避免死循环
    if (check(mid)) l = mid;
    else r = mid - 1;
}

这里的关键区别在 mid 的取整方向。找“最左满足”时，mid = (l+r)/2 向下取整，配合 r = mid；找“最右满足”时，必须用 mid = (l+r+1)/2 向上取整，配合 l = mid。很多人死循环就是因为上下取整和左右收缩方向配错了。我当时的记忆方法是：左边界收缩要向上取整，右边界收缩要向下取整，也就是“左上右下”。

二分的另一个高频考法是“答案二分”，比如“最小化最大值”“最大化最小值”这类问题，典型的如：把n个数分成m段，使每段和的最大值最小。这种题两步走：先二分答案，再用贪心或模拟验证答案是否可行。初学者容易犯的错是上来就想着怎么直接求出最优解，其实二分答案的优势就是把“求最值”转化成“判断可行性”，而可行性判断往往比直接构造最优解简单得多。

2.3 排序还能这么用：区间问题与贪心的入场券

排序不只是为了排序。蓝桥杯里有一大类题，核心思路就是把元素按照某种规则排好序，然后问题就自然解决了。经典的是区间调度：有n个任务，每个任务有开始时间和结束时间，问最多能完成多少个。解法是先按结束时间从小到大排序，然后依次选择结束时间最早且与已选区间不冲突的任务。这个排序顺序一旦搞反（按开始时间排），贪心就会出问题。

另外一个例子是合并区间：给出一堆区间，把重叠部分合并。做法是先按左端点排序，然后遍历，维护当前合并的右边界，如果下一个区间的左端点大于当前右边界，就说明需要开新区间。这题本身是热身级别，但它背后的“排序预处理”思想贯穿很多中档题——先排序，再扫描，再维护某个状态，这是非常通用的解题套路。

我已经记不清在蓝桥杯赛场上多少次用到这个套路了。所以遇到题目第一反应不应该是套某个炫酷的算法名，而是先问：这组数据能不能排序？排完序之后问题会不会变简单？能排序就排序，排序不会亏。

3. 字符串处理：KMP之外还有三个高频考点

3.1 KMP的next数组到底怎么算

字符串算法是蓝桥杯的常客，KMP又是其中被问得最多的。题目里那个经典例子：模式串 p = "abacaba"，求 next 数组。我先说结论：手算出来应该是 next = {-1, 0, 0, 1, 0, 1, 2, 3}（如果 next[i] 定义为模式串前 i 个字符的公共前后缀长度，不同教材定义略有差异，蓝桥杯和考研408都采用这个定义，但实际刷题平台可能用 -1 开头或 0 开头，看题面）。

手算的步骤特别简单：next[i] 表示 p[0...i-1] 这个子串中，最长的相等前缀和后缀的长度。拿 "abacaba" 举例：

• next[0] 约定为 -1（或 0，两种实现都要会，别混）
• next[1]：子串 "a"，前缀后缀都没有，取 0
• next[2]：子串 "ab"，前缀 "a" 和后缀 "b" 不等，取 0
• next[3]：子串 "aba"，前缀 "a" 等于后缀 "a"，取 1
• next[4]：子串 "abac"，"a" 不等于 "c"，"ab" 不等于 "ac"，取 0
• next[5]：子串 "abaca"，"a" 等于 "a"，所以至少为1；再看 "ab" 和 "ca" 不等，取1
• next[6]：子串 "abacab"，"a" 等于 "b"？不等；"ab" 和 "ab" 相等，取2
• next[7]：子串 "abacaba"，"a" 等于 "a"，"ab" 等于 "ba"？不等；"aba" 等于 "aba"，取3

如果你只是在刷题，其实完全不用手动算，代码模板背熟就行。但考场上有一种情况：题目不是直接让你匹配字符串，而是让你“判断循环节”“求字符串周期性”，这时候 KMP 的 next 数组性质 len - next[len] 就是字符串最小循环节的长度。这个性质如果没理解，题目一变就懵。

3.2 字符串哈希：比KMP更通用的比较武器

个人观点：如果你只能学一个字符串算法，在不考虑常数性能的情况下，字符串哈希可能是性价比最高的。它的核心思想是：把一个字符串看作一个 base 进制的大整数，取模后得到一个整数，两个字符串相等当且仅当它们的哈希值相等（极大概率）。

cpp复制using ull = unsigned long long;
const ull base = 13331; // 常见基底

ull h[N], p[N];

void init(const string& s) {
    p[0] = 1;
    for (int i = 0; i < s.size(); i++) {
        h[i + 1] = h[i] * base + (s[i] - 'a' + 1);
        p[i + 1] = p[i] * base;
    }
}
// 获取 [l, r) 子串的哈希
ull getHash(int l, int r) {
    return h[r] - h[l] * p[r - l];
}

这段代码的高明之处在于：利用 unsigned long long 自然溢出取模，省去了手动取模的常数开销，同时冲突概率极低。判断子串是否相等就变成 O(1) 的时间。蓝桥杯里有一类题：给一个长字符串和若干次询问，每次问两个子串是否相等，如果用暴力 substr，每次都是 O(长度)，n 一上来就超时；用字符串哈希，直接 O(n) 预处理加 O(1) 查询。

但哈希有个致命注意点：不要用自然溢出之外还自己选个奇奇怪怪的模数，然后一冲突就换模数反复试。实际中我见过很多同学这么干，最后浪费大量时间。正确姿势是：用 unsigned long long 自然溢出，同时 base 选一个奇素数（131、13331、233333 都可以），冲突概率在竞赛场景下可以接受。如果心里实在没底，可以用双哈希——两个不同 base 或不同模数分别算，两个值都相等才认为相等，基本万无一失。

3.3 回文串与双指针：马拉车之前先会这些

一提到回文串，很多资料直接甩马拉车算法（Manacher），把初学者吓得不轻。但蓝桥杯基础题里，回文的考察方式绝大多数用中心扩展法就能搞定：枚举每个位置作为回文中心，向两边扩展。注意回文中心有两种，奇数长度的中心是一个字符，偶数长度的中心是两个字符之间的空隙，写代码时循环跑两遍就行，时间复杂度 O(n²)，n 在几千以内完全没问题。

另一种常考的是双指针判断回文串，配合字符串删除字符类的题目，比如“删掉一个字符后能否变成回文串”。这种题用头尾双指针，遇到不等时，分别尝试删左边和删右边，只要有一条路能走通就返回 true。思路很直白，但考场上很容易忘了处理“两个方向都要试”，导致丢分。

这里必须提醒一个 C++ 的常见坑：substr(l, len) 的第二个参数是长度不是结束位置，很多人随手一写就变成 substr(l, r)，结果段错误找半天。还有，在做大量字符串拼接时，+ 操作符在 C++ 里会生成新的对象，字符串长度大、次数多时会拖慢程序。用 append 或者预留空间 reserve 都能优化。

4. 贪心与模拟：蓝桥杯真正的“大头”

4.1 贪心为什么在蓝桥杯里出现频率这么高

如果统计蓝桥杯省赛所有算法题目的出现频率，贪心绝对排前三。原因很简单：贪心算法代码短、思路直观、很适合出成中等难度题。而且它不像动态规划那样需要大量的状态设计和转移推导，考场上更容易在短时间内被选手想出来。

但我必须说一个反直觉的观察：贪心题看起来简单，实际错误率极高。经典的反例太多了，比如“背包问题按单位价值贪心”就得不到最优解。还有一个我印象很深的例子：有 n 个人排队接水，第 i 个人接水时间是 t[i]，问怎么排使得总等待时间最小——答案是按接水时间从小到大排，短时间任务的先做。这类题只要排序方向一错，结果完全不对。

考场上的经验法则是：不要急着证明贪心正确性，先努力举反例。如果举了大概三五个反例都没推翻，那贪心大概率是对的；如果一想就能想到反例，赶紧换思路，不要抱着“说不定测试数据弱能过”的侥幸心理。蓝桥杯的数据一般不弱，尤其是排名靠前的赛区。

4.2 模拟题：最没有技术含量，却最能拉开分数差距

我敢说，蓝桥杯省赛的送分题里，很大一部分是“模拟题”——题目给你一个完整规则，你照做就行，不需要任何算法知识。但每年都有大量选手在这些题上翻车，原因不是不会写，而是不够细心、没有模块化意识。

拿日期模拟举例：给定两个日期，求中间隔了多少天。这种题代码长、细节多，闰年判定、月份天数、边界处理，任何一个地方错了都白给。我的习惯是先写一个通用的 daysBetween 函数，把所有日期统一转换成“从公元 1 年 1 月 1 日起的天数”，然后相减。这样就把“两个日期差”转化为“两个绝对天数差”，只写一个转换函数就够了，不用写两边。

另一个高频模拟场景是高精度运算。蓝桥杯里数字可能会到 10^1000 这种量级，用内置类型根本装不下，需要手写高精度加法、乘法，或者用 Java 的 BigInteger、Python 的 int。C++ 选手建议提前准备一套高精度模板，别到考场现场写，现场写大概率出 bug。高精度乘法的核心是模拟竖式：c[i + j] += a[i] * b[j]，最后统一处理进位。模板化之后，在考场上就是纯套用，非常省心。

4.3 常见贪心错误与反例

整理几个我踩过或看别人踩过的贪心坑：

• 只看局部最优，不看全局。比如区间覆盖问题，每次都选覆盖范围最大的区间，不一定能得到最少区间数。这类问题要按左端点排序然后贪心扩展右边界，而不是每次都拿最大区间。
• 按一个维度贪心，但真正的约束条件在另一个维度。比如“安排会议室”既要考虑开始时间又要考虑结束时间，单纯按开始时间排序的贪心是错的，必须按结束时间排。
• 题目要求“字典序最小”时，贪心往往要和“后缀最小”结合考虑，单纯从小到大排序可能完全错误。

我在刷题时的验证方法是：随机生成小规模数据，然后和暴力搜索的结果对比。写一个 O(n!) 的暴力枚举，再和贪心答案对拍，数据量小但覆盖广，很容易发现贪心的反例。这是竞赛选手非常常用的“对拍”思路，蓝桥杯备赛阶段强烈建议学会。

5. 图论基础四件套：DFS、BFS、Dijkstra、Floyd怎么选

5.1 DFS与回溯：蓝桥杯搜索题的标配

图论在蓝桥杯里的入门门槛是搜索。DFS （深度优先搜索）不只是图的遍历算法，它更是很多组合题、排列题的核心。比如“从 n 个数中选 m 个数”的组合问题，标准写法就是 DFS 加剪枝：

cpp复制void dfs(int start, int cnt) {
    if (cnt == m) {
        // 处理当前组合
        return;
    }
    for (int i = start; i < n; i++) {
        choose.push_back(a[i]);
        dfs(i + 1, cnt + 1);
        choose.pop_back();
    }
}

组合问题的关键点是 dfs(i + 1, ...) 保证不重复；排列问题则需要一个 vis[] 数组标记已选元素。这里最常见的错误是：组合题写成了排列题，导致结果变得很大，超时。

DFS 的剪枝是一门学问，但基础版不需要学太多花哨技巧，牢记三条：可行性剪枝（当前状态不可能到达终点了就返回）、最优性剪枝（当前已不如已有答案优就返回）、重复性剪枝（用 set 或排序去重）。蓝桥杯基础题的剪枝，这三条基本够用。

还有一个容易忽略的问题：DFS 递归层数过深会导致栈溢出。C++ 默认栈空间在多数 OJ 上是 8MB 到 16MB，递归层数达到十几万层就会崩。如果题目的搜索深度可能很大，要么改成显式栈模拟，要么改用 BFS。

5.2 BFS与状态搜索：迷宫题的标准解法

BFS（广度优先搜索）在蓝桥杯里的经典场景是迷宫最短路。代码框架特别固定：

cpp复制queue<pair<int,int>> q;
q.push({sx, sy});
dist[sx][sy] = 0;
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};

while (!q.empty()) {
    auto [x, y] = q.front(); q.pop();
    for (int i = 0; i < 4; i++) {
        int nx = x + dx[i], ny = y + dy[i];
        if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
        if (dist[nx][ny] != -1) continue; // 已访问过
        dist[nx][ny] = dist[x][y] + 1;
        q.push({nx, ny});
    }
}

这个模板最好在备赛时默写十遍以上，直到闭着眼都能写对。注意几个细节：dx/dy 方向数组别写错，索引别越界检查漏掉，dist 数组初始化为 -1 表示未访问，如果直接用 vis 布尔数组，还需要额外的 dist 数组记录步数。

BFS 还有一个进阶用法是“状态搜索”：状态不是一个坐标，而是一个容器，比如“箱子推箱子”问题，状态就是“人和箱子的位置”的二元组，还需要额外注意状态空间的大小，如果用 vis[x][y][bx][by] 四维数组标记，空间够但别开小了。这类题在省赛偶尔会出现，属于基础 BFS 加上点状态设计思维，完全有能力拿下。

5.3 Dijkstra与Floyd：最短路题的取舍策略

基础版图论里，最短路算法只需要掌握两个：Dijkstra 和 Floyd。适用场景和取舍用一张表说清楚：

蓝桥杯里比较常见的考法是：n 最多 100 到 200，直接上 Floyd，三重循环，代码太短了：

cpp复制for (int k = 0; k < n; k++)
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            if (g[i][j] > g[i][k] + g[k][j])
                g[i][j] = g[i][k] + g[k][j];

注意 Floyd 的循环顺序：中间点 k 必须在外层。很多人初学会写成 i, j, k 的顺序，结果答案错得莫名其妙。k 在外层的含义是：逐步允许经过前 k 个中间点来更新最短路，这个顺序是算法正确性的核心。

如果 n 到了 10^5 级别，那就只能用堆优化的 Dijkstra，用 priority_queue 写：

cpp复制void dijkstra(int s) {
    memset(dist, 0x3f, sizeof(dist));
    dist[s] = 0;
    priority_queue<pair<int,int>, vector<pair<int,int>>, greater<pair<int,int>>> pq;
    pq.push({0, s});
    while (!pq.empty()) {
        auto [d, u] = pq.top(); pq.pop();
        if (d > dist[u]) continue; // 惰性删除
        for (auto [v, w] : g[u]) {
            if (dist[v] > dist[u] + w) {
                dist[v] = dist[u] + w;
                pq.push({dist[v], v});
            }
        }
    }
}

这里的 if (d > dist[u]) continue; 是堆优化的关键——相当于懒惰删除过期节点，否则优先队列里会堆满旧数据，复杂度退化成 O(nm log n)。看似一行代码，其实是性能的生命线。

负权边在蓝桥杯基础题里很少出现，如果真遇到了，Bellman-Ford 的模板也应该提前备好，但你要清楚它比 Dijkstra 慢得多，n 稍大就危险。SPFA 在很多构造数据下会被卡到 O(nm)，不建议作为首选。

6. 动态规划：从斐波那契到背包问题的思维跃迁

6.1 先学会“记忆化搜索”再写DP

动态规划是很多蓝桥杯选手的噩梦，因为它的状态设计、转移方程、边界条件，每一步都容易出问题。但我发现一个特别有效的入门路径：先写暴力递归，再加一个 memo 数组记录结果，这就是记忆化搜索；记忆化搜索写顺了，再改写成迭代的 DP，思路会清晰很多。

举个最简单的例子，斐波那契数列。暴力递归指数级，加个 memo 数组瞬间变成 O(n)：

cpp复制int fib(int n) {
    if (n <= 1) return n;
    if (memo[n] != -1) return memo[n];
    return memo[n] = fib(n - 1) + fib(n - 2);
}

为什么先走这一步？因为递归版本的思考方式更贴近人的直觉——你只需要想清楚“当前这个状态怎么从更小的状态推出来”，而不用管循环顺序、数组下标这些细节。而迭代 DP 容易犯的一个典型错误就是：没想清楚状态转移的先后依赖关系，导致用到某个状态时它的值还没被算出来。记忆化搜索自动解决了这个问题——它靠递归天然地从依赖的小状态开始计算。

等记忆化搜索写对、跑通，再改写成迭代 DP 就只是翻译工作：把递归的每个参数映射到数组下标，把递归调用改成查数组。这个过程做多了，你会慢慢发现 DP 其实没那么可怕。

6.2 背包问题：蓝桥杯DP的重灾区

背包问题是蓝桥杯 DP 里出现频率最高的题型。01背包、完全背包、多重背包，必须滚瓜烂熟。先看最简单的 01 背包：n 个物品，每个有重量 w[i] 和价值 v[i]，背包容量为 V，问最大价值。

cpp复制// 一维滚动数组
for (int i = 1; i <= n; i++) {
    for (int j = V; j >= w[i]; j--) { // 为什么逆序？
        dp[j] = max(dp[j], dp[j - w[i]] + v[i]);
    }
}

这里有一个所有初学者都会问的问题：为什么容量循环要逆序？答案是：01背包的每个物品只能用一次，如果正序更新，dp[j - w[i]] 可能已经是本轮更新过的值，意味着物品 i 被重复使用了。逆序遍历保证 dp[j - w[i]] 还是上一轮（未选物品 i 时）的状态。这个“去重”逻辑如果不理解，二维 DP 版本会更直观：

cpp复制for (int i = 1; i <= n; i++)
    for (int j = 0; j <= V; j++) {
        dp[i][j] = dp[i - 1][j]; // 不选
        if (j >= w[i]) dp[i][j] = max(dp[i][j], dp[i - 1][j - w[i]] + v[i]); // 选
    }

完全背包则相反，每个物品可以用无限次，所以内层容量循环要正序：

cpp复制for (int i = 1; i <= n; i++) {
    for (int j = w[i]; j <= V; j++) {
        dp[j] = max(dp[j], dp[j - w[i]] + v[i]);
    }
}

多重背包是 01 背包的延伸：每个物品最多用 c[i] 次。简单做法是二进制拆分——把 c[i] 个物品拆成若干个“大物品”，数量分别为 1、2、4、8...，剩下的独立成一件，这样任意 0 到 c[i] 的数量都能由这些大物品组合出来，而总件数从 c[i] 降到 O(log c[i])。这个技巧蓝桥杯中级题经常暗藏，值得作为基础版内容。

6.3 线性DP与区间DP的常用模型

背包之外，还有两类基础 DP 模型必须掌握。一类是线性 DP，典型例子是最长上升子序列（LIS）和最长公共子序列（LCS）。LIS 的 O(n²) 版本几乎必背：

cpp复制for (int i = 0; i < n; i++) {
    dp[i] = 1;
    for (int j = 0; j < i; j++) {
        if (a[j] < a[i]) dp[i] = max(dp[i], dp[j] + 1);
    }
}

LCS 的状态定义则是 dp[i][j] 表示 a 的前 i 个字符和 b 的前 j 个字符的最长公共子序列长度，转移分两种情况：a[i-1] == b[j-1] 时加 1，否则取两边的小问题较大值。

另一类是区间 DP。最有代表性的题目是“石子合并”：一排石子，每次合并相邻两堆，代价为两堆重量之和，问总代价最小。状态设计为 dp[i][j] 表示合并第 i 堆到第 j 堆的最小代价，转移时枚举断点 k：

cpp复制for (int len = 2; len <= n; len++) {
    for (int i = 0; i + len - 1 < n; i++) {
        int j = i + len - 1;
        dp[i][j] = INF;
        for (int k = i; k < j; k++) {
            dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j] + sum[i][j]);
        }
    }
}

区间 DP 容易犯的错是循环顺序：必须按区间长度从小到大枚举，而不是直接枚举左右端点。因为计算 dp[i][j] 时需要更短的区间 dp[i][k] 和 dp[k+1][j]，只有区间长度小的先算完，大区间才能正确转移。这个“由短区间推长区间”的顺序，是区间 DP 的灵魂，背代码不如理解它。

7. 数论与位运算：性价比极高的隐藏考点

7.1 快速幂：模运算下的高效幂计算

蓝桥杯的数论题，快速幂是出现频率非常高的基础算法。求 a^b mod m，如果直接循环乘，b 到 10^9 就完全超时。快速幂的核心思想是二进制拆分：把 b 写成二进制，比如 b=13，二进制是 1101，也就是 13 = 8+4+1，那么 a^13 = a^8 · a^4 · a^1，只需算 4 次乘法而不是 13 次。

cpp复制long long fastPow(long long a, long long b, long long m) {
    long long res = 1;
    a %= m;
    while (b) {
        if (b & 1) res = res * a % m;
        a = a * a % m;
        b >>= 1;
    }
    return res;
}

这个模板一定要写到肌肉记忆里。考试时它可能直接出现在“大数幂最后几位”题目中，也可能藏在矩阵快速幂里——用快速幂的思想加速斐波那契数列，把常系数递推转化为矩阵的幂运算。矩阵快速幂在蓝桥杯省赛里看运气，但基础快速幂是必须拿下的。

取模运算有个注意点：res * a % m 两个 long long 相乘可能溢出，如果 m 接近 10^18，需要改用“快速乘”（类似快速幂的思路用加法代替乘法）或者用 __int128 中转。蓝桥杯普通题不会这么极限，但国赛有这个可能。

7.2 质数筛与GCD：数论题的常见铺垫

判断质数、求最大公约数、质因数分解，这三样是数论题的“基建”。最大公约数就是经典的辗转相除法：

cpp复制int gcd(int a, int b) {
    return b == 0 ? a : gcd(b, a % b);
}

C++17 的 <numeric> 里有标准的 std::gcd，比赛中可以直接用。最小公倍数就是 a / gcd(a, b) * b，注意先除后乘防止溢出。

质数筛我建议直接用欧拉筛（线性筛），它比埃氏筛稍复杂一点，但每个合数只被自己的最小质因子筛掉一次，不会重复，而且筛的过程中可以顺便求出每个数的最小质因子，为后面的质因数分解做准备：

cpp复制vector<int> primes;
bool isComposite[MAXN];
int minPrime[MAXN]; // 最小质因子

void eulerSieve(int n) {
    for (int i = 2; i <= n; i++) {
        if (!isComposite[i]) {
            primes.push_back(i);
            minPrime[i] = i;
        }
        for (int p : primes) {
            if (i * p > n) break;
            isComposite[i * p] = true;
            minPrime[i * p] = p;
            if (i % p == 0) break; // 保证每个合数只被最小质因子筛掉
        }
    }
}

质因数分解有了最小质因子数组就特别方便：每次除以 minPrime[x]，得到一个质因子，然后继续除。这个技巧在“求约数个数”“求欧拉函数”这类题里都很有用，值得在备赛时练熟。

7.3 位运算：藏着状态压缩DP的种子

位运算在蓝桥杯里出现的概率相当高，但常常不是作为独立的考点，而是作为优化手段。最常用的几个技巧：

• 判断奇偶：if (x & 1)
• 乘除 2 的幂：x << 1、x >> 1
• 取二进制第 k 位：(x >> k) & 1
• 把第 k 位设为 1：x |= (1 << k)
• 把第 k 位设为 0：x &= ~(1 << k)
• 翻转第 k 位：x ^= (1 << k)
• 枚举一个集合的所有子集：for (int sub = S; sub; sub = (sub - 1) & S)

第 7 个“枚举子集”的技巧非常精妙，它利用 (sub - 1) & S 不断跳转到下一个更小的子集，时间复杂度是 O(3^n) 而不是 O(4^n)。这是状态压缩 DP 的最初种子。蓝桥杯基础阶段，你只需要会用位运算做简单的状态标记和子集枚举，真正的状压 DP 我打算放到进阶篇单独讲。

位运算还有几个经典的坑：一是优先级问题，位运算的优先级比相等比较低，写 (x & y) == 0 时必须加括号，否则会先执行 ==；二是在枚举状态时，1 << n 可能溢出，n 到 31 以上要改用 1LL << n；三是取反 ~ 会把符号位也翻转，别指望它只翻转末尾几位。

8. 基础版该按什么顺序刷：我的个人建议

如果让我给一个最稳妥的备赛路线，排一下优先级：

• 第一优先级：排序与二分、模拟与贪心、DFS/BFS。这三块占了省赛的大半江山，代码量不大、见效快，先确保这些题能写对。
• 第二优先级：01背包和完全背包、线性 DP（LIS/LCS）、Dijkstra 堆优化。这些是中档题常客，需要投入时间理解状态和转移，但学会后收益很高。
• 第三优先级：KMP、快速幂、欧拉筛、区间 DP。这些本质上是题库里的“加分项”，省赛出题频率不如前两类高，但一旦遇到，你不慌就能甩开一批人。
• 最后：矩阵快速幂、状态压缩 DP、树状数组、线段树等进阶内容，留到基础版吃得透透的再碰。不要一开始就扎进高级算法，那是在沙滩上盖楼。

我在实际备赛中还有一个已经养成的习惯：每学完一个算法，第二天必须在不看代码的情况下手写一遍，并且在 LeetCode、洛谷、codeforces 上找两三道对应题目验证。写不出来的地方就是没学透的地方，标记下来，第三天再写。一遍到三遍的重复，能把“看懂了”变成“会写了”，两者在考场上差别巨大。

关于“半成品”这个定位，我再多说一句。很多同学的备赛心态是“算法学得越多越安心”，但蓝桥杯是限时比赛，你的目标不是懂所有算法，而是在规定时间内做出尽可能多的题目。把这份基础清单里的每个算法都练到“看到题就能条件反射写出模板”，比囫囵吞枣地扫完十种算法却每种都半生不熟要有效得多。

最后分享一个小技巧作为收尾：每次比赛前一天晚上，把上面所有算法的代码模板在电脑上快速敲一遍——不调试，纯默写。这个过程不会花很多时间，但它会帮你把每种算法的关键边界条件重新过一遍脑子。第二天考场上，你的手指会比你的脑子更先想起来怎么写，而这，往往才是真正的分数胜负手。