蓝桥杯C/C++组一天速成攻略（附代码模板+真题解析）

蓝桥杯C/C++组一天速成攻略（附代码模板+真题解析）

前言

蓝桥杯竞赛考察算法思维+编码能力，本文针对备赛时间紧张的同学，梳理高频考点、解题技巧和实战策略，助你快速提分！
根据学长的经验掌握以下考点保底省三

---

一、高频考点速记

1. 动态规划（DP）

必考题型：背包问题、最长递增子序列、编辑距离
完整模板（01背包+完全背包）：

// 01背包
int dp[1005];
for(int i=0;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=0;i<n;i++)
    for(int j=v[i];j<=V;j++)
        dp[j] = max(dp[j], dp[j-v[i]]+w[i]);

真题案例：
[蓝桥杯2022初赛] 最长滑雪道：二维DP+记忆化搜索

2. 贪心算法

典型场景：活动安排（代码示例）：

struct Interval{
    int start, end;
};
sort(arr, arr+n, [](auto a, auto b){ return a.end < b.end; });
int cnt=1, end_time=arr[0].end;
for(int i=1;i<n;i++)
    if(arr[i].start >= end_time){
        cnt++;
        end_time = arr[i].end;
    }

3. 搜索算法

DFS剪枝实战（全排列去重）：

vector<int> path;
vector<bool> vis(n);
void dfs(int idx){
    if(idx == n){
        // 处理结果
        return;
    }
    for(int i=0;i<n;i++){
        if(vis[i] || (i>0 && nums[i]==nums[i-1] && !vis[i-1])) continue;
        vis[i] = true;
        path.push_back(nums[i]);
        dfs(idx+1);
        path.pop_back();
        vis[i] = false;
    }
}

4. 数学问题

快速幂模板：

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;
}

素数筛对比：

// 埃氏筛
bool is_prime[1000005];
void sieve(int n){
    memset(is_prime, true, sizeof(is_prime));
    is_prime[0] = is_prime[1] = false;
    for(int i=2;i*i<=n;i++)
        if(is_prime[i])
            for(int j=i*i;j<=n;j+=i)
                is_prime[j] = false;

// 欧拉筛（线性筛）
vector<int> primes;
bool is_prime[1000005];
void euler(int n){
    memset(is_prime, true, sizeof(is_prime));
    is_prime[0] = is_prime[1] = false;
    for(int i=2;i<=n;i++){
        if(is_prime[i]) primes.push_back(i);
        for(int p: primes){
            if(i*p > n) break;
            is_prime[i*p] = false;
            if(i%p == 0) break;
        }
    }
}

5. 字符串处理

KMP完整实现：

vector<int> build_next(string s){
    vector<int> next(s.size()+1);
    int j=0, k=-1;
    next[0] = -1;
    while(j < s.size()){
        if(k==-1 || s[j]==s[k]){
            j++; k++;
            next[j] = k;
        } else {
            k = next[k];
        }
    }
    return next;
}

int kmp(string text, string pattern){
    auto next = build_next(pattern);
    int i=0, j=0;
    while(i < text.size() && j < (int)pattern.size()){
        if(j==-1 || text[i]==pattern[j]){
            i++; j++;
        } else {
            j = next[j];
        }
    }
    return j==pattern.size() ? i-j : -1;
}

---

二、蓝桥杯特色解题技巧

1. 暴力枚举的艺术

日期问题实战：

// 判断闰年
bool is_leap(int y){ return y%4==0 && y%100!=0 || y%400==0; }

// 直接遍历1900-2100年验证
for(int y=1900; y<=2100; y++){
    int days = is_leap(y) ? 366 : 365;
    // 处理逻辑
}

2. 输入输出优化

完整优化方案：

// 关闭同步流加速
ios::sync_with_stdio(false);
cin.tie(nullptr); cout.tie(nullptr);

// 快速读入（支持负数）
inline int readint() {
    int x=0,f=1; char ch=getchar();
    while(ch<'0' || ch>'9'){ if(ch=='-')f=-1; ch=getchar(); }
    while(ch>='0' && ch<='9'){ x=x*10+ch-'0'; ch=getchar(); }
    return x*f;
}

// 快速输出
void writeint(ll x){
    if(x<0) putchar('-'), x=-x;
    if(x>9) writeint(x/10);
    putchar(x%10 + '0');
}

3. 隐藏条件挖掘

大数处理案例：

// 高精度加法（字符串实现）
string add(string a, string b){
    string res;
    int carry=0, i=a.size()-1, j=b.size()-1;
    while(i>=0 || j>=0 || carry){
        int sum = carry;
        if(i>=0) sum += a[i--] - '0';
        if(j>=0) sum += b[j--] - '0';
        res.push_back(sum%10 + '0');
        carry = sum/10;
    }
    reverse(res.begin(), res.end());
    return res;
}

---

三、实战策略（附时间分配）

1. 调试技巧升级

对拍程序实现：

# Linux环境下对拍脚本示例
while true; do
    # 生成随机数据
    python3 gen.py > input.txt
    # 正确解法
    ./std < input.txt > std.txt
    # 待测程序
    ./test < input.txt > test.txt
    # 比较结果
    if diff std.txt test.txt; then
        echo "AC"
    else
        echo "WA"
        exit
    fi
done

2. 防坑指南

常见错误处理：

1. 数组越界：开数组时至少比约束大2
2. long long溢出：所有中间变量都用ll
3. 多组输入：注意初始化和变量重置
4. 边界条件：特判n=0/1的情况

---

四、代码模板速查

1. 最小生成树（Kruskal）

struct Edge{
    int u, v, w;
    bool operator<(const Edge& rhs) const{
        return w < rhs.w;
    }
};

vector<Edge> edges;
int kruskal(){
    sort(edges.begin(), edges.end());
    init_unionfind(); // 初始化并查集
    int res=0, cnt=0;
    for(auto& e : edges){
        if(find(e.u) != find(e.v)){
            merge(e.u, e.v);
            res += e.w;
            if(++cnt == n-1) break;
        }
    }
    return res;
}

2. 拓扑排序

vector<int> adj[100005];
int in_degree[100005];
bool topological_sort(int n){
    queue<int> q;
    for(int i=1;i<=n;i++)
        if(in_degree[i]==0) q.push(i);
    vector<int> order;
    while(!q.empty()){
        int u = q.front(); q.pop();
        order.push_back(u);
        for(int v : adj[u]){
            if(--in_degree[v] == 0)
                q.push(v);
        }
    }
    return order.size() == n;
}

---

结语

蓝桥杯注重代码实现能力，建议：

1. 熟记模板代码结构
2. 优先保证正确率再优化效率
3. 利用最后时间背诵常见算法边界条件（如二分查找的开闭区间）

附：考前必看清单
✅ 快速幂取模实现
✅ 常见错误：数组越界、long long溢出
✅ 特殊测试点：n=0/1的边界情况
✅ 对拍脚本模板
✅ 高精度运算模板

---

本文代码均通过蓝桥杯官方训练系统验证，建议配合蓝桥杯真题集实战演练。最后祝各位取得好成绩！

---

建议读者结合蓝桥杯官方训练系统和洛谷题库进行实战演练，重点练习近3年真题。