距离蓝桥杯 B 组省赛仅剩一周，时间紧迫，建议你放弃死磕难题，主攻“默写级”高频模板。B 组省赛的核心逻辑是：用正确的模板快速拿下基础分，而不是在现场推导算法。

这份清单按“性价比”排序，请优先掌握前 6 项。建议每天花 30 分钟手敲一遍这些代码，形成肌肉记忆。

---

🚀 考前必背模板（B组核心向）

1. 万能头与宏定义（防爆零）

作用：避免手滑写错头文件，统一处理 long long 溢出问题。

#include <bits/stdc++.h>
using namespace std;
typedef long long ll; // 必写，防止大数据爆int
const int INF = 0x3f3f3f3f;
const int N = 1e5 + 10; // 根据题目调整

int main() {
    // 关闭同步流，加速 cin/cout（如果用了printf就别用）
    ios::sync_with_stdio(false);
    cin.tie(0);
    
    // 你的代码
    return 0;
}

2. 二分查找（整数/实数版）

场景：求最大值最小、最小值最大，或有序查找。B组必考。

// 整数二分（找满足条件的最大值）
int l = 0, r = 1e9;
while (l < r) {
    int mid = (l + r + 1) >> 1; // 注意+1防死循环
    if (check(mid)) l = mid;    // check()需自己实现
    else r = mid - 1;
}
cout << l << endl;

// 实数二分（保留k位小数，循环100次足够精确）
double l = 0, r = 1e9;
for (int i = 0; i < 100; i++) {
    double mid = (l + r) / 2;
    if (check(mid)) r = mid;
    else l = mid;
}
printf("%.2f\n", l); // 输出时控制精度

3. 前缀和与差分（区间处理神器）

场景：频繁求区间和、区间加减。

// 一维前缀和
ll s[N];
for (int i = 1; i <= n; i++) {
    cin >> a[i];
    s[i] = s[i-1] + a[i];
}
// 查询 [l, r] 和：ans = s[r] - s[l-1];

// 一维差分（区间加）
ll d[N]; // 初始为0
void add(int l, int r, int c) {
    d[l] += c;
    d[r+1] -= c;
}
// 操作后求原数组：for (int i = 1; i <= n; i++) d[i] += d[i-1];

4. 动态规划（01背包/完全背包）

场景：资源分配、选数问题。

// 01背包（每个物品选一次，容量倒序）
int dp[N] = {0};
for (int i = 1; i <= n; i++) {
    for (int j = V; j >= v[i]; j--) { // 倒序！
        dp[j] = max(dp[j], dp[j - v[i]] + w[i]);
    }
}

// 完全背包（物品无限，容量正序）
for (int i = 1; i <= n; i++) {
    for (int j = v[i]; j <= V; j++) { // 正序！
        dp[j] = max(dp[j], dp[j - v[i]] + w[i]);
    }
}

5. 搜索（DFS/BFS 迷宫模板）

场景：全排列、迷宫最短路。

// DFS 全排列（无重复元素）
vector<int> path;
vector<bool> vis(n+1, false);
void dfs(int u) {
    if (u == n) {
        // 输出排列
        return;
    }
    for (int i = 1; i <= n; i++) {
        if (!vis[i]) {
            vis[i] = true;
            path.push_back(i);
            dfs(u + 1);
            path.pop_back();
            vis[i] = false;
        }
    }
}

// BFS 迷宫最短路（四方向）
int dx[] = {0, 0, 1, -1}, dy[] = {1, -1, 0, 0};
int dist[100][100] = {0}; // 记录步数，初始-1表示未访问
queue<pair<int, int>> q;
q.push({sx, sy});
dist[sx][sy] = 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 && !vis[nx][ny] && g[nx][ny] == 0) {
            dist[nx][ny] = dist[x][y] + 1;
            q.push({nx, ny});
            vis[nx][ny] = true;
        }
    }
}

6. 数学工具（GCD/快速幂）

场景：约分、大数取模。

// 最大公约数 & 最小公倍数
int gcd(int a, int b) {
    return b == 0 ? a : gcd(b, a % b);
}
int lcm(int a, int b) {
    return a / gcd(a, b) * b; // 先除后乘防溢出
}

// 快速幂 (a^b % mod)
ll qpow(ll a, ll b, ll mod) {
    ll res = 1;
    while (b) {
        if (b & 1) res = res * a % mod;
        a = a * a % mod;
        b >>= 1;
    }
    return res;
}

---

📈 进阶提分项（时间充裕再看）

如果上述模板已滚瓜烂熟，可以补充以下两个高频结构：

7. 并查集（连通性判断）

int fa[N];
void init() { for (int i = 1; i <= n; i++) fa[i] = i; }
int find(int x) {
    return fa[x] == x ? x : fa[x] = find(fa[x]);
}
void merge(int a, int b) {
    a = find(a), b = find(b);
    if (a != b) fa[a] = b;
}

8. 结构体排序（多关键字）

struct Node {
    int score, id;
};
bool cmp(const Node& a, const Node& b) {
    if (a.score == b.score) return a.id < b.id; // 成绩相同按id升序
    return a.score > b.score; // 成绩降序
}
sort(v.begin(), v.end(), cmp);

---

💡 最后一周冲刺策略

1. 抄写为主：不要只看不写。每天把二分、前缀和、背包、DFS四个模板默写一遍。

2. 真题驱动：找近 3 年 B 组省赛真题，只做前 5 道简单/中等题，套用上述模板。

3. 防错检查：

   • 数组大小是否开了 N = 1e5+10级别？

   • int是否全改成了 long long？（B组常考大数）

   • 二分边界 l和 r的初始值是否合理？

稳住基础模板，省二/省一希望很大。祝你顺利！