蓝桥杯好数问题：数字奇偶位处理与算法优化

1. 蓝桥杯"好数"问题解析

这道题目来自第十五届蓝桥杯C++ B组竞赛，考察选手对数字处理、循环结构和条件判断的掌握程度。题目要求我们统计在1到n范围内满足特定奇偶位规则的"好数"数量。

1.1 题目规则详解

"好数"的定义基于数字各位的奇偶性，具体规则如下：

1. 从数字的最低位（个位）开始编号，个位为第1位（奇数位），十位为第2位（偶数位），以此类推
2. 奇数位上的数字必须是奇数
3. 偶数位上的数字必须是偶数

例如：

• 1234：不符合（第2位"2"是偶数，但第4位"1"是奇数）
• 1238：符合（奇数位1和3都是奇数，偶数位2和8都是偶数）
• 5：符合（只有1位，是奇数位且数字5是奇数）

1.2 暴力解法代码分析

提供的暴力解法是这类问题的典型解决思路，适合竞赛场景。我们来详细拆解这个实现：

cpp复制#include<bits/stdc++.h>
using namespace std;

int n;                     // 输入范围上限
int ans = 0;               // 结果计数器

bool check(int x) {
    int tem = x;           // 保存原始值
    int f = 0;             // 位标志：0表示奇数位，1表示偶数位
    
    while(tem) {           // 逐位处理
        if(f == 0) {       // 奇数位检查
            if(tem % 10 % 2 == 0) return false;
        } else {           // 偶数位检查
            if(tem % 10 % 2 != 0) return false;
        }
        
        tem /= 10;         // 移除已处理的最低位
        f ^= 1;            // 切换位标志
    }
    return true;
}

int main() {
    cin >> n;
    for(int i = 1; i <= n; ++i) {
        if(check(i)) ans++;
    }
    cout << ans;
    return 0;
}

1.3 关键算法细节

1.3.1 数字位处理技巧

while(tem)循环是处理数字各位的核心，它通过以下方式逐位检查：

1. tem % 10获取当前最低位数字
2. 根据f标志判断当前位的奇偶性要求
3. tem /= 10移除已处理的最低位

这种处理方式的优势在于：

• 不需要预先知道数字的位数
• 处理顺序自然从低位到高位
• 空间复杂度O(1)，不需要额外存储数字的各位

1.3.2 位标志切换优化

原代码使用if-else切换标志位，可以优化为位运算：

cpp复制f ^= 1;  // 替代 if(f == 0) f=1; else f=0;

这种写法：

• 更简洁
• 避免了分支判断
• 在多数现代CPU上执行效率更高

1.3.3 提前终止机制

当发现某位不满足条件时，立即return false，这种短路评估可以：

• 减少不必要的计算
• 对于大数或大量数据时显著提升效率

2. 算法优化思路

虽然暴力解法在竞赛中通常足够，但我们可以探讨几种优化方向：

2.1 数学规律分析

观察"好数"的数学特征，可以发现：

1. 1位数：1,3,5,7,9（5个）
2. 2位数：十位必须是偶数(2,4,6,8)，个位必须是奇数(1,3,5,7,9)→4×5=20个
3. 3位数：百位奇(5)×十位偶(5)×个位奇(5)=125个
4. 一般规律：n位数有5^n个"好数"（每位独立选择）

基于此可以设计更高效的计数算法，避免逐个检查。

2.2 数位DP解法

数位动态规划是处理这类数字统计问题的强大工具：

cpp复制#include <iostream>
#include <cstring>
using namespace std;

int dp[20][2]; // dp[pos][odd_even_flag]
int digits[20];

int dfs(int pos, int flag, bool limit) {
    if(pos == -1) return 1;
    if(!limit && dp[pos][flag] != -1) return dp[pos][flag];
    
    int up = limit ? digits[pos] : 9;
    int res = 0;
    
    for(int d = 0; d <= up; ++d) {
        if((flag && d % 2 != 0) || (!flag && d % 2 == 0))
            continue;
        res += dfs(pos-1, !flag, limit && d==up);
    }
    
    if(!limit) dp[pos][flag] = res;
    return res;
}

int countGood(int n) {
    int len = 0;
    while(n) {
        digits[len++] = n % 10;
        n /= 10;
    }
    memset(dp, -1, sizeof dp);
    return dfs(len-1, 1, true);
}

int main() {
    int n;
    cin >> n;
    cout << countGood(n) - 1; // 减去0的情况
    return 0;
}

这种解法的时间复杂度为O(log n)，适合处理极大范围的n。

3. 工程实践建议

3.1 头文件选择

竞赛中常用的bits/stdc++.h虽然方便，但在工程中有明显缺点：

建议在实际项目中明确包含所需头文件，如：

cpp复制#include <iostream>  // 输入输出
#include <vector>    // 动态数组
#include <algorithm> // 常用算法

3.2 输入验证

原代码缺少输入验证，可以增加：

cpp复制if(n < 1) {
    cout << "输入必须为正整数" << endl;
    return 1;
}

3.3 性能测试

对不同解法进行性能对比（n=1e8）：

4. 常见问题与调试技巧

4.1 边界条件处理

常见错误包括：

1. 忽略n=0的情况
2. 处理单数位数字时的标志位初始化
3. 数字前导零的影响（本题不影响）

调试建议：

• 打印中间结果验证位处理顺序
• 对小规模n(如1-20)手动验证

4.2 位标志混淆

容易混淆位序的奇偶定义，建议：

1. 添加详细注释
2. 使用枚举增强可读性：

cpp复制enum { ODD_POS = 0, EVEN_POS = 1 };

4.3 性能优化陷阱

过早优化是常见错误，应该：

1. 先确保正确性
2. 用profiler定位瓶颈
3. 优先优化最耗时的部分

5. 扩展思考

5.1 变种问题

可以尝试解决这些相关问题：

1. 统计"坏数"数量
2. 找出第k个"好数"
3. 区间查询[a,b]内的"好数"数量

5.2 多语言实现

Python实现示例：

python复制def is_good(num):
    pos = 1  # 从个位开始
    while num > 0:
        digit = num % 10
        if pos % 2 == 1:  # 奇数位
            if digit % 2 == 0:
                return False
        else:  # 偶数位
            if digit % 2 == 1:
                return False
        num //= 10
        pos += 1
    return True

def count_good_numbers(n):
    return sum(1 for i in range(1, n+1) if is_good(i))

5.3 实际应用场景

这类数字处理技巧可用于：

1. 数据校验（如身份证号校验位）
2. 数字编码/解码
3. 密码学中的位操作
4. 数字游戏逻辑实现

在实际编码时，我习惯先写几个测试用例验证边界情况，比如1位数、全奇数位、全偶数位等不同组合。对于这类位操作问题，画出示意图往往能帮助理清思路——把数字的各位拆开，标上位置和要求的奇偶性，检查时就不容易混淆了。