CodeForces - 55D Beautiful numbers 数位dp＋离散化

题目链接：Beautiful numbers

很容易想到定义状态为dp[pos][sum][lcm] (i: 当前dfs的数位，sum: 当前节点的前缀，lcm: 当前节点前缀各位数字的最小公倍数)，但是很明显sum的范围太大，到了10^18量级。我们要做的就是缩小范围！

怎么缩小范围呢？我们先思考一下这个sum和lcm是干什么用的。当dfs到临界状态的时候，我们得到了一个前缀sum(实际上就是数字本身)和前缀的lcm，如果lcm能够整除sum，就返回1，否则返回0。所以这个sum的作用就是判断这个数字能不能整除lcm。

实际上我们知道下面这个简单的式子。

sum % (k * lcm) % lcm = sum % lcm

这个式子也很好懂，就是一个数字对lcm取模，和对lcm的倍数取模再对lcm取模得到的结果是相同的。

举个例子，sum ＝ 100，lcm ＝ 7，k ＝ 3

sum ％ 7 ＝ sum ％ (3 * 7) % 7 = 2

因为我们只是想知道sum ％ lcm的值是多少，所以不需要用sum本身来对lcm取模，只需要用sum对lcm倍数取模的结果来对lcm取模就行了。

我们知道1～9的最小公倍数为2520，所以这个倍数最好的选择就是2520啦。在dfs中，我们维护前缀对2520取模的值就可以了。

这样一来范围就变成了18 * 2520 * 2520，还是太大了。最后一维的2520是保存前缀的lcm的值，但是lcm的取值根本不会有2520这么多，暴力枚举之后发现只有48种！

所以最后一维的范围从2520降低成了48。现在范围是18 * 2520 * 48，在可接受范围之内。

代码如下：#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#define MOD 2520

using namespace std;

typedef long long int LL;
LL dp[20][2600][100];
int digit[20];
int Hash[2600];

int GCD(int x, int y)
{
return !y ? x : GCD(y, x % y);
}

int LCM(int x, int y)
{
return x * y / GCD(x, y);
}

LL dfs(int pos, int preMOD, int preLCM, int limit)
{
if (!pos)
return preMOD % preLCM == 0;
if (!limit && dp[pos][preMOD][Hash[preLCM]] != -1)
return dp[pos][preMOD][Hash[preLCM]];
int up = limit ? digit[pos] : 9;
LL ans = 0;
for (int i = 0; i <= up; i++)
ans += dfs(pos - 1, (preMOD * 10 + i) % MOD, !i ? preLCM : LCM(preLCM, i), limit && i == up);
return limit ? ans : dp[pos][preMOD][Hash[preLCM]] = ans;
}

LL cal(LL n)
{
int len = 0;
while (n)
{
digit[++len] = n % 10;
n /= 10;
}
return dfs(len, 0, 1, 1);
}

void init()
{
memset(dp, -1, sizeof(dp));
int cnt = 0;
for (int i = 1; i <= 2520; i++)
if (MOD % i == 0)
Hash[i] = cnt++;
}

int main()
{
int T;
scanf("%d", &T);
init();
while (T--)
{
LL l, r;
scanf("%lld%lld", &l, &r);
printf("%lld\n", cal(r) - cal(l - 1));
}
return 0;
}