数位DP(记忆化搜索)

数位dp的例题

LeetCode2376.统计特殊整数

题目描述：如果一个正整数每一个数位都是 互不相同 的，我们称它是 特殊整数 。
给你一个 正 整数 n ，请你返回区间 [1, n] 之间特殊整数的数目。
数据范围：
思路: 记忆化搜索，一位一位的往后搜，然后注意前缀零的处理和是否有被前面位数限制当前位，具体细节见代码,具体记忆化搜索把哪些重复的优化了我还暂时有点懵

class Solution {
public:
    int countSpecialNumbers(int n) {
        using ll = long long;
        unordered_map<ll, int> f; // 记忆化数组
        string digit = to_string(n);
        
        // 对存储的状态哈希成ll，提高记忆化搜索效率
        auto get = [](int u, int mask, int is_limit, int is_num) -> ll {
            ll state = mask;               // 用0~30位来存储mask
            state |= 1LL * is_limit << 31; // 用第31位来存储is_limit
            state |= 1LL * is_num << 32;   // 将第32位来存储is_num
            state |= 1LL * u << 33;        // 将第33位及以上来存储u
            return state;
        };
        
        // u 表示当前枚举到了哪一位
        // mask表示0~u-1位已经枚举过了的标记
        // is_limit表示当前位是否被前面限制, 例如n=12345, 如果前面是123那么当前第4位只能是0~4, 如果前面是不是123那么当前位可以是0~9
        // is_num表示前面是否是数字, 因为可以跳过000这样的前面位, 这里主要是为了配合mask防止000xyz这样的情况
        // 记忆化搜索, 返回从u位开始的答案数量
        function<int(int, int, bool, bool)> dp = [&](int u, int mask, bool is_limit, bool is_num) -> int {
            if (u == digit.size()) // 枚举完了
                return is_num ? 1 : 0;
            
            ll state = get(u, mask, is_limit, is_num);
            if (f.count(state)) // 是否计算过
                return f[state];
        
            int res = 0;
            if (!is_num) 
                res += dp(u + 1, mask, false, false); // 继续跳过当前位
            
           
            int up = is_limit ? digit[u] - '0' : 9;  // 如果前面都被限制，那么当前位最高是digit[u]
            // 如果前面没有跳过那么当前可以从0开始，否则只能从1开始(第一位不能是0)
            for (int d = is_num ? 0 : 1; d <= up; ++d) 
                if ((mask >> d & 1) == 0) // d 不在mask中
                    res += dp(u + 1, mask | (1 << d), is_limit && d == up, true);
            
            return f[state] = res;
        };
        
        return dp(0, 0, true, false);
    }
};

代码参考自：0x3f

---

LeetCode233.数字1的个数

题目描述：给定一个整数 n，计算所有小于等于 n 的非负整数中数字 1 出现的个数。

我觉得优化的部分就是像比如说前面5位中有3个1,只有算出一个$12114xxxx$的情况, 那么$11124xxxx$里面的,$23111xxxx$这样的，形如前面5位中包含3位1,后面的部分可排列的情况是一样的，只要第一次算出$dp[5][3][false][flase]$后面再遇见这种情况就通过记忆化直接加，不用再算了

class Solution {
private: 
    int dp[10][15][2]; // dp[i][cnt1][is_limit] 枚举到第i位, 当前i位中有cnt1个1的情况下，1出现的次数
public:
    int countDigitOne(int n) {
        memset(dp, -1, sizeof dp);
        auto digit = to_string(n);
        
        function<int(int, int, bool)> f = [&](int u, int cnt1, bool is_limit) {
            if (u == digit.size()) 
                return cnt1;
            
            if (dp[u][cnt1][is_limit] >= 0)
                return dp[u][cnt1][is_limit];
            
            int res = 0;
            int up = is_limit ? digit[u] - '0' : 9;
            for (int d = 0; d <= up; ++d)
                res += f(u + 1, cnt1 + (d == 1), is_limit && d == up);
            
            return dp[u][cnt1][is_limit] = res;
        };
        
        return f(0, 0, true);
    }
};

---

AcWing338. 计数问题

题目描述 给定两个整数 a 和 b，求 a 和 b 之间的所有数字中 0∼9 的出现次数。
例如，a=1024，b=1032，则 a 和 b 之间共有 9 个数如下：
1024 1025 1026 1027 1028 1029 1030 1031 1032
其中 0 出现 10 次，1 出现 10 次，2 出现 7 次，3 出现 3 次等等…
输入格式
输入包含多组测试数据。
每组测试数据占一行，包含两个整数 a 和 b。
当读入一行为 0 0 时，表示输入终止，且该行不作处理。
输出格式
每组数据输出一个结果，每个结果占一行。
每个结果包含十个用空格隔开的数字，第一个数字表示 0 出现的次数，第二个数字表示 1 出现的次数，以此类推。
数据范围
$0<a,b<100000000$

思路：直接套模板，一个一个从统计从$1到n$, 然后$calc(b,x)-calc(a,x)$

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

int dp[10][10][2][2];
int calc(int num, int x)
{
    memset(dp, -1, sizeof dp);
    auto digit = to_string(num);
    // 当前位数u, 统计次数cntx, 是否被限制, 前面是否选择
    function<int(int, int, bool, bool)> f = [&](int u, int cntx, bool is_limit, bool is_num) {
        if (u == digit.size())
            return cntx;
        
        if (dp[u][cntx][is_limit][is_num] >= 0) 
            return dp[u][cntx][is_limit][is_num];
            
        int res = 0;
        if (!is_num)
            res += f(u + 1, cntx, false, false);
            
        int up = is_limit ? digit[u] - '0' : 9;
        for (int d = is_num ? 0 : 1; d <= up; ++d)
            res += f(u + 1, cntx + (d == x), is_limit && (d == up), true);
            
        return dp[u][cntx][is_limit][is_num] = res;
    };
    return f(0, 0, true, false);
}

int main()
{
    int a, b;
    while (cin >> a >> b, a || b)
    {
        if (a > b) swap(a, b);
        for (int i = 0; i < 10; ++i)
            cout << calc(b, i) - calc(a - 1, i) << " \n"[i == 9];
    }
    return 0;
}

acw

---

LeetCode902. 最大为N的数字组合

题目描述：给定一个按 非递减顺序 排列的数字数组 digits 。你可以用任意次数 digits[i] 来写的数字。例如，如果 digits = [‘1’,‘3’,‘5’]，我们可以写数字，如 ‘13’, ‘551’, 和 ‘1351315’。

思路：还是套模板，记忆法就是避免算重复的数据

class Solution {
public:
    int atMostNGivenDigitSet(vector<string>& digits, int n) {
        auto num = to_string(n);
        vector<vector<vector<int>>> dp(10, vector<vector<int>>(2, vector<int>(2, -1)));
        
        // 枚举到第u位, 是否是被限制, 前面是否都没有填
        function<int(int, bool, bool)> f = [&](int u, bool is_limit, bool is_num) {
            if (u == num.size())
                return is_num ? 1 : 0;
            
            if (dp[u][is_limit][is_num] >= 0)
                return dp[u][is_limit][is_num];
            
            int res = 0;
            if (!is_num) 
                res += f(u + 1, false, false);
            
            int down = is_num ? 0 : 1;
            int up = is_limit ? num[u] - '0' : 9;
            for (auto &s : digits)
            {
                int d = s[0] - '0';
                if (d > up) break;
                res += f(u + 1, is_limit && d == up, true);
            }
        
            return dp[u][is_limit][is_num] = res;            
        };
        
        // 从第0位开始, 当前被限制, 没有填数
        return f(0, true, false);
    }
};