蓝桥杯 C/C++ 备考攻略：3-6 个月入门到实战，含高频考点与代码模板 | 极客日志

C++算法

蓝桥杯 C/C++ 备考攻略：3-6 个月入门到实战，含高频考点与代码模板

提供蓝桥杯 C/C++ 方向 3-6 个月备考计划，涵盖基础语法、高频算法模块及真题实战。内容包括基础阶段语法重点、进阶阶段的动态规划与搜索算法、冲刺阶段真题训练方法。附带素数判定、背包问题、BFS 等常用代码模板，以及考场时间分配与答题技巧，帮助考生高效复习并提升成绩。

道系青年发布于 2026/3/26更新于 2026/5/821 浏览

蓝桥杯 C/C++ 备考攻略：3-6 个月入门到实战，含高频考点与代码模板

一、备考规划：3-6 个月阶段拆解（零基础友好）

1. 基础阶段（1-2 个月）：夯实语法与工具

核心目标：掌握 C/C++ 基础语法，熟练使用编译器（Dev-C++/VS Code），能独立编写简单程序。

每日学习时长：2-3 小时。

（1）语法重点（按优先级排序）

核心语法：变量 / 常量、数据类型（int/long long/double/char）、运算符（算术 / 逻辑 / 位运算）、分支（if-else/switch）、循环（for/while/do-while）—— 这是所有题目的基础，务必熟练。
数组与字符串：一维数组（存储数据）、二维数组（矩阵问题）、字符串处理（strlen/strcpy/strcmp，C++ 可多用 string 类）。
函数与指针：函数定义 / 调用 / 递归（递归是蓝桥杯高频考点，如斐波那契、阶乘）、指针基础（地址与取值、指针与数组结合）。
结构体与 STL（C++ 重点）：结构体（自定义数据类型，如存储学生信息、坐标）、STL 容器（vector 动态数组、queue 队列、stack 栈、map 键值对 ——C++ 选手必学，能大幅简化代码）。

（2）工具与练习

编译器选择：推荐 Dev-C++（轻量、兼容性好，蓝桥杯竞赛环境类似）或 VS Code（需配置 MinGW）。
练习平台：洛谷'入门题库'（P1000-P1050）、蓝桥杯官网'基础练习'，每天做 2-3 道基础题，巩固语法。

2. 算法进阶阶段（2-3 个月）：突破高频算法

核心目标：掌握蓝桥杯常考算法，能独立解决中等难度题目（如模拟、枚举、动态规划）。

每日学习时长：3-4 小时

（1）高频算法模块（蓝桥杯 90% 题目覆盖）

算法模块	核心考点	典型题目
模拟与枚举	暴力枚举（循环遍历）、模拟过程（如日期计算）	蓝桥杯'基础练习・回文数''大臣的旅费'
递归与递推	递归函数设计、递推公式（斐波那契、递推数列）	'基础练习・斐波那契数列''瓷砖铺放'
排序与查找	快速排序 / 冒泡排序、二分查找（整数 / 浮点数）	'基础练习・排序''查找整数'
动态规划（DP）	线性 DP（最大子序和、最长递增子序列）、背包问题（01 背包、完全背包）	'地宫取宝''剪绳子'
数学问题	素数判定、最大公约数（gcd）、最小公倍数（lcm）、阶乘、组合数	'基础练习・素数判断''分解质因数'
图论基础	深度优先搜索（DFS）、广度优先搜索（BFS）	'迷宫问题''岛屿数量'
贪心算法	局部最优解推导全局最优（如活动安排、区间问题）	'独木桥''排队打水'

（2）学习方法

算法理解：先看算法原理（推荐《算法图解》《啊哈算法》，零基础友好），再手动模拟过程（如递归的调用栈、DP 的状态转移表）。
代码实现：每学一个算法，先独立写代码，再对比标准题解，修正逻辑漏洞（如递归的终止条件、DP 的初始化）。

3. 真题冲刺阶段（1 个月）：实战复盘 + 模板固化

// 错误示例：int 存储大数导致溢出
int sum = 0;
for (int i = 1; i <= 1e5; i++) sum += i; // sum 会溢出

// 正确示例：用 long long
long long sum = 0;
for (int i = 1; i <= 1e5; i++) sum += i;

// 1. 素数判定（判断 n 是否为素数，n>=2）
bool is_prime(int n) {
    if (n <= 1) return false;
    for (int i = 2; i * i <= n; i++) { // 优化：i 到 sqrt(n) 即可
        if (n % i == 0) return false;
    }
    return true;
}

// 2. 最大公约数（gcd，欧几里得算法）
int gcd(int a, int b) {
    return b == 0 ? a : gcd(b, a % b);
}

// 3. 最小公倍数（lcm，公式：lcm(a,b) = a*b / gcd(a,b)，先算 gcd 避免溢出）
int lcm(int a, int b) {
    return a / gcd(a, b) * b; // 先除后乘，减少溢出风险
}

// 01 背包模板：n 个物品，每个物品体积 v[i]，价值 w[i]，背包容量 m，求最大价值
int knapsack_01(int n, int m, int v[], int w[]) {
    int dp[1005] = {0}; // dp[j]：容量为 j 时的最大价值
    for (int i = 1; i <= n; i++) { // 遍历物品
        for (int j = m; j >= v[i]; j--) { // 逆序遍历容量，避免重复选
            dp[j] = max(dp[j], dp[j - v[i]] + w[i]);
        }
    }
    return dp[m];
}

#include <queue>
using namespace std;

// BFS 模板：迷宫（n 行 m 列，0 可走，1 障碍，求从 (0,0) 到 (n-1,m-1) 的最短步数）
int dx[] = {0, 0, 1, -1}; // 上下左右四个方向
int dy[] = {1, -1, 0, 0};

int bfs(int n, int m, int grid[][1005]) {
    int dist[1005][1005] = {0}; // 记录步数，初始为 0（未访问）
    queue<pair<int, int>> q;
    q.push({0, 0});
    dist[0][0] = 1; // 起点步数为 1
    while (!q.empty()) {
        auto [x, y] = q.front(); // C++17 特性，也可拆分为 int x = q.front().first;
        q.pop();
        if (x == n-1 && y == m-1) return dist[x][y]; // 到达终点，返回步数
        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 && grid[nx][ny] == 0 && dist[nx][ny] == 0) {
                dist[nx][ny] = dist[x][y] + 1;
                q.push({nx, ny});
            }
        }
    }
    return -1; // 无法到达终点
}

// 快速排序模板：排序数组 a[left..right]
void quick_sort(int a[], int left, int right) {
    if (left >= right) return;
    int pivot = a[left]; // 基准值（选左端点）
    int i = left, j = right;
    while (i < j) {
        // 从右找比基准小的数
        while (i < j && a[j] >= pivot) j--;
        a[i] = a[j];
        // 从左找比基准大的数
        while (i < j && a[i] <= pivot) i++;
        a[j] = a[i];
    }
    a[i] = pivot; // 基准值归位
    quick_sort(a, left, i-1); // 排序左半部分
    quick_sort(a, i+1, right); // 排序右半部分
}

#include <stdio.h>
int main() {
    int num;
    scanf("%d", &num); // 输入 5 位数（范围 10000~99999）
    // 提取每一位
    int wan = num / 10000; // 万位
    int qian = (num / 1000) % 10; // 千位
    int shi = (num / 10) % 10; // 十位
    int ge = num % 10; // 个位
    // 判断是否为回文数
    if (wan == ge && qian == shi) {
        printf("yes\n");
    } else {
        printf("no\n");
    }
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX 10001 // 假设城市数量不超过 10000

// 邻接表节点
typedef struct Node {
    int to; // 目标城市
    struct Node* next; // 下一个节点
} Node;

Node* adj[MAX]; // 邻接表
int max_dist; // 最大距离
int far_city; // 最远城市

// 添加边（单向）
void add_edge(int from, int to) {
    Node* new_node = (Node*)malloc(sizeof(Node));
    new_node->to = to;
    new_node->next = adj[from];
    adj[from] = new_node;
}

// DFS：从 start 出发，记录当前距离
void dfs(int start, int dist) {
    if (dist > max_dist) {
        max_dist = dist;
        far_city = start;
    }
    Node* p = adj[start];
    while (p != NULL) {
        dfs(p->to, dist + 1); // 每走一条路，距离 +1
        p = p->next;
    }
}

int main() {
    int n; // 城市数量
    scanf("%d", &n);
    // 初始化邻接表
    memset(adj, NULL, sizeof(adj));
    for (int i = 0; i < n - 1; i++) { // n 个城市有 n-1 条道路（树结构）
        int a, b;
        scanf("%d%d", &a, &b);
        add_edge(a, b);
        add_edge(b, a); // 题目隐含道路双向，若单向则删除此句
    }
    // 第一次 DFS：找最远城市
    max_dist = 0;
    dfs(1, 0); // 假设首都为 1 号城市
    // 第二次 DFS：从最远城市找最长距离
    max_dist = 0;
    dfs(far_city, 0);
    // 最长距离对应的旅费（题目隐含公式：10*max_dist + max_dist*(max_dist+1)/2）
    printf("%d\n", 10 * max_dist + max_dist * (max_dist + 1) / 2);
    return 0;
}

#include <stdio.h>
int main() {
    int n;
    scanf("%d", &n);
    if (n == 1 || n == 2) {
        printf("1\n");
        return 0;
    }
    int a = 1, b = 1, res; // a=F(n-2), b=F(n-1)
    for (int i = 3; i <= n; i++) {
        res = a + b;
        a = b; // 更新 F(n-2) 为原 F(n-1)
        b = res; // 更新 F(n-1) 为新结果
    }
    printf("%d\n", res);
    return 0;
}

#include <stdio.h>
int main() {
    int n;
    scanf("%d", &n);
    long long f[31]; // n=30 时结果超 int，用 long long
    f[1] = 1;
    f[2] = 2;
    for (int i = 3; i <= n; i++) {
        f[i] = f[i-1] + f[i-2];
    }
    printf("%lld\n", f[n]);
    return 0;
}

#include <stdio.h>

// 快速排序：排序数组 a[left..right]
void quick_sort(int a[], int left, int right) {
    if (left >= right) return;
    int pivot = a[left]; // 基准值（选左端点）
    int i = left, j = right;
    while (i < j) {
        // 从右找比基准小的数
        while (i < j && a[j] >= pivot) j--;
        a[i] = a[j];
        // 从左找比基准大的数
        while (i < j && a[i] <= pivot) i++;
        a[j] = a[i];
    }
    a[i] = pivot; // 基准值归位
    quick_sort(a, left, i-1); // 排序左半部分
    quick_sort(a, i+1, right); // 排序右半部分
}

int main() {
    int n, a[1001];
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        scanf("%d", &a[i]);
    }
    quick_sort(a, 0, n-1);
    // 输出排序结果
    for (int i = 0; i < n; i++) {
        printf("%d ", a[i]);
    }
    return 0;
}

#include <stdio.h>
int main() {
    int n, x, a[1001];
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        scanf("%d", &a[i]);
    }
    scanf("%d", &x);
    // 顺序查找
    for (int i = 0; i < n; i++) {
        if (a[i] == x) {
            printf("%d\n", i+1); // 位置从 1 开始
            return 0;
        }
    }
    // 未找到
    printf("-1\n");
    return 0;
}

#include <stdio.h>
#include <string.h>
#define MOD 1000000007 // 题目要求结果取模

int main() {
    int n, m, k;
    scanf("%d%d%d", &n, &m, &k);
    int a[51][51]; // 存储地宫宝物价值
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            scanf("%d", &a[i][j]);
        }
    }
    // dp[i][j][v][c]：到达 (i,j)，价值 v，取 c 件的路径数
    int dp[51][51][1001][51] = {0};
    // 初始状态：起点 (0,0)
    if (a[0][0] <= k) {
        dp[0][0][a[0][0]][1] = 1;
    }
    // 填充 DP 表
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            // 跳过起点（已初始化）
            if (i == 0 && j == 0) continue;
            // 遍历可能的价值和宝物数量
            for (int v = 0; v <= k; v++) {
                for (int c = 1; c <= 50; c++) {
                    // 从上方 (i-1,j) 转移
                    if (i > 0) {
                        int prev_v = v - a[i][j];
                        if (prev_v >= 0 && c > 0) {
                            dp[i][j][v][c] = (dp[i][j][v][c] + dp[i-1][j][prev_v][c-1]) % MOD;
                        }
                    }
                    // 从左方 (i,j-1) 转移
                    if (j > 0) {
                        int prev_v = v - a[i][j];
                        if (prev_v >= 0 && c > 0) {
                            dp[i][j][v][c] = (dp[i][j][v][c] + dp[i][j-1][prev_v][c-1]) % MOD;
                        }
                    }
                }
            }
        }
    }
    // 统计总价值≥k 的所有路径数
    int res = 0;
    for (int v = k; v <= 1000; v++) {
        for (int c = 1; c <= 50; c++) {
            res = (res + dp[n-1][m-1][v][c]) % MOD;
        }
    }
    printf("%d\n", res);
    return 0;
}

#include <stdio.h>
#include <math.h>

int main() {
    int n;
    scanf("%d", &n);
    int dp[101];
    dp[2] = 1; // 初始条件
    for (int i = 3; i <= n; i++) {
        dp[i] = 0; // 初始化当前最大乘积为 0
        // 遍历第一段长度 j（1~i-1）
        for (int j = 1; j < i; j++) {
            // 两种情况：j 不剪，j 剪（用 dp[j]）
            int temp = fmax(j * (i - j), j * dp[i - j]);
            dp[i] = fmax(dp[i], temp);
        }
    }
    printf("%d\n", dp[n]);
    return 0;
}

#include <stdio.h>
#include <math.h>

int is_prime(int n) {
    if (n <= 1) return 0; // 不是素数
    if (n == 2) return 1; // 是素数
    if (n % 2 == 0) return 0; // 偶数不是素数
    // 遍历到 sqrt(n)，步长为 2（只看奇数）
    for (int i = 3; i <= sqrt(n); i += 2) {
        if (n % i == 0) return 0;
    }
    return 1;
}

int main() {
    int n;
    scanf("%d", &n);
    if (is_prime(n)) {
        printf("yes\n");
    } else {
        printf("no\n");
    }
    return 0;
}

#include <stdio.h>
int main() {
    int n;
    scanf("%d", &n);
    printf("%d=", n);
    int flag = 0; // 标记是否已输出过因数（用于控制乘号）
    for (int i = 2; i <= n; i++) {
        // 循环除以当前因数 i，直到不能整除
        while (n % i == 0) {
            if (flag) {
                printf("*"); // 非第一个因数前加乘号
            }
            printf("%d", i);
            flag = 1;
            n /= i; // 用商继续分解
        }
    }
    printf("\n");
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#define MAX 100 // 假设迷宫最大 100x100

// 队列节点（存储坐标）
typedef struct {
    int x, y;
} Node;

int main() {
    int n, m;
    scanf("%d%d", &n, &m);
    int grid[MAX][MAX];
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            scanf("%d", &grid[i][j]);
        }
    }
    // 方向数组：上下左右
    int dx[] = {0, 0, 1, -1};
    int dy[] = {1, -1, 0, 0};
    int dist[MAX][MAX] = {0}; // 距离 + 访问标记（0=未访问）
    Node queue[MAX * MAX];
    int front = 0, rear = 0; // 队列首尾指针
    // 起点入队
    queue[rear].x = 0;
    queue[rear].y = 0;
    rear++;
    dist[0][0] = 1; // 起点步数为 1
    while (front < rear) {
        // 取出队首
        Node curr = queue[front];
        front++;
        // 到达终点
        if (curr.x == n-1 && curr.y == m-1) {
            printf("%d\n", dist[curr.x][curr.y] - 1); // 步数=距离 -1（起点算 0 步）
            return 0;
        }
        // 遍历 4 个方向
        for (int i = 0; i < 4; i++) {
            int nx = curr.x + dx[i];
            int ny = curr.y + dy[i];
            // 检查边界、是否可走、是否未访问
            if (nx >= 0 && nx < n && ny >= 0 && ny < m && grid[nx][ny] == 0 && dist[nx][ny] == 0) {
                dist[nx][ny] = dist[curr.x][curr.y] + 1;
                queue[rear].x = nx;
                queue[rear].y = ny;
                rear++;
            }
        }
    }
    // 无法到达
    printf("-1\n");
    return 0;
}

#include <stdio.h>
#include <string.h>
#define MAX 100

int grid[MAX][MAX];
int visited[MAX][MAX];
int n, m;

// 方向数组：上下左右
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};

// DFS：标记所有相连的陆地
void dfs(int x, int y) {
    visited[x][y] = 1; // 标记为已访问
    for (int i = 0; i < 4; i++) {
        int nx = x + dx[i];
        int ny = y + dy[i];
        // 检查边界、是否为陆地、是否未访问
        if (nx >= 0 && nx < n && ny >= 0 && ny < m && grid[nx][ny] == 1 && !visited[nx][ny]) {
            dfs(nx, ny);
        }
    }
}

int main() {
    scanf("%d%d", &n, &m);
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            scanf("%d", &grid[i][j]);
        }
    }
    memset(visited, 0, sizeof(visited));
    int count = 0; // 岛屿数量
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            // 遇到未访问的陆地，启动 DFS
            if (grid[i][j] == 1 && !visited[i][j]) {
                count++;
                dfs(i, j);
            }
        }
    }
    printf("%d\n", count);
    return 0;
}

#include <stdio.h>
#include <math.h>

int main() {
    int L, n;
    scanf("%d%d", &L, &n);
    int min_time = 0, max_time = 0;
    for (int i = 0; i < n; i++) {
        int pos;
        scanf("%d", &pos);
        // 最近桥端距离
        int min_dist = fmin(pos, L + 1 - pos);
        // 最远桥端距离
        int max_dist = fmax(pos, L + 1 - pos);
        if (min_dist > min_time) min_time = min_dist;
        if (max_dist > max_time) max_time = max_dist;
    }
    printf("%d %d\n", min_time, max_time);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

// 比较函数（用于 qsort 排序）
int cmp(const void* a, const void* b) {
    return *(int*)a - *(int*)b; // 升序排序
}

int main() {
    int n;
    scanf("%d", &n);
    int t[n];
    for (int i = 0; i < n; i++) {
        scanf("%d", &t[i]);
    }
    // 按打水时间升序排序
    qsort(t, n, sizeof(int), cmp);
    long long total_wait = 0; // 总等待时间（可能很大，用 long long）
    int sum = 0; // 前 i 个人的打水时间之和
    for (int i = 0; i < n - 1; i++) { // 最后一个人无人等待
        sum += t[i];
        total_wait += sum;
    }
    // 平均等待时间=总等待时间/人数（题目可能要求整数，直接输出即可）
    printf("%lld\n", total_wait / n);
    return 0;
}