浅学数位dp

Aythsr

已于 2022-04-30 10:54:15 修改

阅读量300

点赞数

CC 4.0 BY-SA版权

分类专栏：算法文章标签：算法

于 2022-04-30 10:52:27 首次发布

本文链接：https://blog.youkuaiyun.com/qq_41739081/article/details/124509829

算法专栏收录该内容

13 篇文章

订阅专栏

数位 $d p$

数位dp的写法比较套路，学会一种基本能就行了，但是困难的是如何联系其他的算法。

数位 $d p$ 一般用来计数，要是计算累和，还要用到辅助计数数组。

先抛两个例题： Variety of Digits ，Digit Sum

都是计算 $[1, n]$ 的范围内，符合条件的数的个数/累和。

关键点： 前导零，卡限界

先分析前导零，如果前导零对于计数没有影响，那是最好的，比如计算某种累和。如果条件有关 $0$ ，但是不能计算前导 $0$ ，那么需要分析，采取合适的转移方程。

例：在第一个题目中，要求是计算在 $[1, n]$ 中，数位包含完全 $M_1,M_2...$ 的数的累和。

这道题难度有几点：

所求的条件是数位中至少包含 $M_1,M_2,M_3...$ ，数位 $d p$ 无法处理“至少”问题

解决方式是，我们考虑全集，即计算所有包含 ${M_1,M_2,M_3...\}$ 的情况。

第二个是前导零的问题，其实并不难解决，只是代码量偏大，有一个技巧，很妙
第三个就是如何去卡限界。

我们期待能优雅的解决这个问题。

一般来讲，数位 $d p$ 都有两个基本的状态，有限制，无限制。我们先考虑无限制的情况。无限制的情况下，当然可以任意转移。

为了更加优雅，我们定义一个状态为 dp[i][j][0] 在无限制情况下，长度小于等于 $i$ 的数在满足条件 $j$ 的情况下的累和。（$\sum j $是全集的一个划分）首先明白一个事情： $\sum _j dp[i][j][1]$ 是一个全集，是包含0的，那么我们在每一个状态下，在后面添加 $0, 1, . . . 9$ ，同时补上 $0$ 的状态，状态转移是没有问题的，在下一状态，仍然是全集。

我们得到一个转移 :

dp[i][j | (1 << k)][1] = 10 * dp[i][j][1] + num[i][j][1] * k;
num[i][j | (1 << k)][1] += num[i][j][1];
// dp 代表值
// num 是个数

但是这个是错误的，因为我们还是将前导0记录在了里面。

那么怎么规避这个问题呢，其实我们分析一下，问题出在了我们对 $0$ 到 $0$ 的转移，可以发现，其实并不需要考虑 $0$ 的存在，（如果是求累和，0不会影响结果，如果是计数，我们最后特判一下就可以了）。也就说，即使 $0$ 符合 $1$ 的条件(二进制表示下)，我们仍然将其看作为 0 的条件。然后我们特判掉我们 0 对 0 的转移，有两个好处，方便了 0 到 1 的转移，减少了 0 到 0 转移的错误。

dp[i][add(j,k)][1] = 10 * dp[i][j][1] + num[i][j][1] * k;
num[i][add(j,k)][1] += num[i][j][1];
add(int j,int k)
{
    if (j == 0 && k == 0) return 0;
    else return j | (1 << k);
}

然后是卡限界，我们都是从高位开始，而且我们一般给一个虚拟高位，代表在限界内。有了上面的说明，代码会比较优雅。

#include <bits/stdc++.h>

using namespace std;
const int MOD = 998244353;
const int lim = 1e4+100;
char s[lim];
int f[lim][1 << 10][2],st;
int cnt[lim][1 << 10][2];

int add(int a,int b)
{
    if (a == 0 && b == 0) return 0;
    else return a | (1 << b);
}

int main()
{
    cin >> s;
    int m,x;
    cin >> m;
    while (m--) cin >> x, st |= (1 << x);
    int n = strlen(s);
    cnt[0][0][1] = 1;
    for (int i = 0; i < n; ++i)
        for (int j = 0; j < 1024; ++j)
        {
            if (cnt[i][j][1] == 0 && cnt[i][j][0] == 0) continue;
            x = s[i] - '0';
            for (int k = 0; k < 10; ++k)
            {
                cnt[i + 1][add(j,k)][0] += cnt[i][j][0];
                f[i + 1][add(j,k)][0] += (1ll * cnt[i][j][0] * k % MOD + f[i][j][0] * 10ll % MOD) % MOD;
                cnt[i + 1][add(j,k)][0] %= MOD;
                f[i + 1][add(j,k)][0] %= MOD;
            } 
            for (int k = 0; k <= x; ++k)
            {
                cnt[i + 1][add(j,k)][k == x] += cnt[i][j][1];
                f[i + 1][add(j,k)][k == x] += (f[i][j][1] * 10ll % MOD + 1ll * cnt[i][j][1] * k % MOD) % MOD;
                cnt[i + 1][add(j,k)][k == x] %= MOD;
                f[i + 1][add(j,k)][k == x] %= MOD;
            }
        }
    int res = 0;
    for (int i = 0; i < 1024; ++i)
    {
        if ((i & st) == st)
        {
            res += (f[n][i][0] + f[n][i][1]) % MOD;
            res %= MOD;
        }
    }
    cout << res << endl;
    return 0;
}