我看了半天的数位 DP，DP 没学会，人倒是麻了。

解决什么

一般用于求解给你一个区间 \([l,r]\)，问你其中满足条件的数有多少个。

这种题目还是蛮常见的，我们一般情况下暴力只能拿一少部分分，之前我看着那个 \(n\le 10^{18}\) 是一脸懵逼，这东西 \(O(n)\) 都过不去，啥高级的东西能 A 啊。

然后就有了今天让我麻了的数位 DP。

思想

题目中给的让我们难以下手，我们不如转化一下：求 \([1,r]\) 中符合限制的数并减去 \([1,l-1]\) 的数。

这样就好处理多了，当然也可以从 \(0\) 开始，根据题目而定。

然后我们把要求的 \([1,x]\) 区间中的 \(x\) 给一位一位分解开，然后 dfs 往里面填数。

在分解的时候，我们用一个数组 \(a[i]\) 来存储从高位到低位（一般是）的数字，来当作填数的限制。

我们在 dfs 的时候，传的参数至少是包含 pos 当前填到第几个数以及 limit 也就是当前点是否有限制，如果有的话，我们在后面遍历当前点填的数的时候直接调用之前的 \(a[]\) 数组就好了。

当然我们在 dfs 的时候是要记忆化的，不然复杂度直接飙升，我们可以根据题目给的限制条件来把状态相同的归到一类然后存放到数组里面，然后我们就可以在遇到与当前状态相同的时候直接调用记忆化数组来让我们的复杂度变得美丽。

遍历每一个数的时候一般分为两种情况，一个有前导零，一个没有前导零。

code:

#include <bits/stdc++.h>

#define int long long
#define N 20

using namespace std;

int a[N], cnt, f[N][N << 3][2][2], dight; 

inline int dfs(int p, int cntd, int lead, int limit)//p是当前位置，cntd是当前答案lead是有没有前导零。limit是当前数字枚举到的数量上限
{
    if(p == cnt) return cntd;//到了就直接返回搜到的值
    if(f[p][cntd][lead][limit] != -1) return f[p][cntd][lead][limit];//记忆化，以前搜过了就直接返回
    int ans = 0;//统计答案
    for(int v = 0; v <= (limit ? a[p] : 9); v ++)//枚举当前点可以是哪些数字
    {
        if(lead && v == 0)//如果要是当前点有前导零，并且当前的点的下一个枚举的是0
            ans += dfs(p + 1, cntd, 1, limit && v == a[p]);//答案累加，计算当前状态下的答案标记有前导零
        else
            ans += dfs(p + 1, cntd + (v == dight), 0, limit && v == a[p]);//正常情况
    }
    return f[p][cntd][lead][limit] = ans;//返回答案的同时记忆化
}

inline int fx(int x)
{
    cnt = 0;
    memset(f, -1 , sizeof f);
    memset(a, 0, sizeof a);//清空数组
    while(x) a[cnt ++] = x % 10, x /= 10;//由低位到高位
    reverse(a, a + cnt);//反转一下让他顺序变正常
    return dfs(0, 0, 1, 1);//开始搜索 前面有0并且第一个数是有限制的
}

signed main()
{
    int L, R;
    cin >> L >> R;

    for(int i = 0; i <= 9; i ++)//枚举九个数字
    {
        dight = i;//更新dight的值
        cout << fx(R) - fx(L - 1) << " ";//跑一遍输出当前数字出现的次数
    }

    return 0;
}

和前面讲的一样，利用记忆化搜索，注释应该很清楚了吧。

数位 DP 板子题。

我们设 \(f_{i,j}\) 为当前从左往右枚举到第 \(i\) 个数没有枚举时，当前枚举完的 \(1\) 的个数为 \(j\) 时的能得到的有 \(k\) 个 \(1\) 的个数。

我们用 ? 来表示当前点没有填入，假设我们现在从左往右填，当前的状态是 10101?????，我们 dfs 完以后，直接存入 \(f_{6,3}\) 里，我们要是再枚举到类似 10011????? 这种的，我们可以发现，后面问号的可能性是一样的，也就是说，他们得到的答案是一样的，那么我们就可以进行记忆化了。

我们对于给定的 \(n\) 按照其他的数位 DP 一样拆成二进制下的数，将每一位都存放到 \(a_{i}\) 里，也就是说 \(a_{i}\) 表示从左往右第 \(i\) 个数可以填 \(1\sim a_{i}\)。

由于这里的情况很少，只有 \(0\) 和 \(1\)，所以可以直接展开循环。

code：

#include <bits/stdc++.h>

#define int long long
#define N 100

using namespace std;

int n, k, a[N], f[N][N];//枚举到第i个数当前当前j个1的个数 

inline int dfs(int p, int limit, int cnt)
{
    if( cnt > k ) return 0;
    if(! p) return (cnt == k ? 1 : 0);
    if(! limit && f[p][cnt] != -1) return f[p][cnt];
    int res = 0, flag = (limit ? a[p] : 1);
    res += dfs(p - 1, limit && flag == 0, cnt);
    if(flag) res += dfs(p - 1, limit && flag == 1, cnt + 1);
    if (! limit) f[p][cnt] = res;
    return res;
}

inline int fx(int x)
{
    memset(f, -1, sizeof f);
    int len = 0;
    while(x) a[++ len] = (x & 1), x >>= 1;
    return dfs(len, 1, 0);
}

signed main()
{
    cin >> n >> k;
    cout << fx(n) << endl;
    return 0;
}