统计1-n中不包含数字 2 的数字个数

洁净数

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

// 判断一个数字是否为“洁净数”，即不包含数字 '2'
bool valid_num(int num)
{
    // 将数字转换为字符串，便于逐位检查每一位数字
    string str = to_string(num);

    // 遍历字符串的每一位
    for(int i = 0; i < str.size(); i++)
    {
        // 如果当前位是 '2'，则该数不是洁净数，返回 false
        if(str[i] == '2')
            return false;
    }

    // 遍历结束后未发现 '2'，说明该数是洁净数，返回 true
    return true;
}

// 统计 1 到 n 中有多少个“洁净数”
int count_num(int n)
{
    int cnt = 0; // 用于统计洁净数的个数

    // 从 1 遍历到 n
    for (int i = 1; i <= n; i++)
    {
        // 如果当前数字是洁净数，则计数器加一
        if(valid_num(i))
            cnt++;
    }

    // 返回洁净数的总数
    return cnt;
}

int main()
{
    int num1; // 存储用户输入的 n 值
    int ans = 0; // 存储最终结果

    cin >> num1; // 输入 n 的值
    ans = count_num(num1); // 调用函数计算洁净数的数量

    cout << ans << endl; // 输出结果
    return 0;
}

数位DP

从高位到低位递归地统计不包含数字 2 的数字个数，而不是遍历每个数字。

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

int dp[20][2]; // dp[pos][0] 用于记忆化存储结果，pos 表示当前处理的位置（位数）
// 注意：这里只使用了 dp[pos][0]，因为 tight=0 时才缓存结果

// 将数字转换为各个位存入数组中，如 123 -> [1, 2, 3]
vector<int> get_digit(int n) {
    vector<int> digit;
    while(n) {
        digit.push_back(n % 10);
        n /= 10;
    }
    reverse(digit.begin(), digit.end()); // 需要从高位到低位处理
    return digit;
}

// 数位 DP 递归函数
// pos：当前处理到第几位
// tight：前缀是否受到上界的限制（true 表示必须 ≤ digit[pos]）
// lead_zero：是否还处于前导0状态
// digit：目标数的各位组成的数组
int dfs(int pos, bool tight ,bool lead_zero, const vector<int> &digit) {
    // 所有位置处理完毕，说明是一种合法的数字
    if(pos == digit.size()) {
        return 1;
    }

    // 如果已经计算过的状态，直接返回记忆化结果（优化）
    if(!tight && !lead_zero && dp[pos][0] != -1)
        return dp[pos][0];

    int limit = tight ? digit[pos] : 9; // 如果 tight 为真，则最大可选 digit[pos]，否则可以选 0~9
    int res = 0; // 当前结果初始化

    // 枚举当前位的所有可能的数字
    for(int i = 0; i <= limit; i++) {
        if(i == 2)
            continue; // 不允许出现数字2

        // 是否保持 受限 状态（只有选的数 == digit[pos] 才保持 tight）
        // 只有上一位受限 且 当前位所选数 等于 原数字当前位 最高数字 时才受限
        bool next_tight = tight && (digit[pos] == i);
        // 是否还在前导0中
        // 只有前导为0  且 当前位选的数 等于 0 才为 true 
        bool next_lead_zero = lead_zero && (i == 0);

        res += dfs(pos + 1, next_tight, next_lead_zero, digit);
    }

    // 只有 不是受限状态 且 非前导0的状态可以记忆化（否则状态不唯一）
    if(!tight && !lead_zero) {
        dp[pos][0] = res;
    }

    return res;
}

// 主函数，返回从 1 到 n 中不含数字2的个数
int count_clean_numbers(int n) {
    vector<int> digitt1 = get_digit(n); // 拆位
    memset(dp, -1, sizeof(dp));         // 初始化记忆化数组为 -1

    return dfs(0, true, true, digitt1) - 1; // 减去0，题目是从1开始的，不包含0
}

int main() {
    int n;
    cin >> n;
    cout << count_clean_numbers(n) << endl;
    return 0;
}