CodeForces 55D "Beautiful numbers"（数位DP+离散化处理）

传送门

参考资料：

　　[1]:CodeForces 55D Beautiful numbers(数位dp&&离散化)

题意：

　　求一个区间内的Beautiful numbers有多少个。Beautiful numbers指：一个数能整除所有组成它的非0数字。 
　　例如15可以被1和5整除，所以15是Beautiful numbers。

我的理解：

　　起初，我先定义一个三维数组 dp[ i ][ j ][ k ]:来到 i 位置时，所有非零数的lcm = j，当前数位 k 时含有的 Beautiful numbers 的个数。

　　但是，由题意得，当前的数 k 可以是个很大的数（9e18），数组根本就开不下，那怎么办呢？

　　将当前的数 hash 一下，如何hash呢？

　　假设 a,b,c,d 为[0,9]的数，那么不存在另一个 a',b',c',d'

　　使得 a*11+b*13+c*17+d*19 = a' *11+b' *13+c' *17+d' *19;

　　也就是说，这 19 位数分别乘以大于10 的互不相等的前19个素数是不会存在重数的；

　　那么，hash完后，最大的数才7000多，那么开个 dp[20][50][8000] 的数组绰绰有余；

　　但问题来了，既然每个数的 hash 值都不想等，那，哪来的记忆化搜索？

　　所以说，这就是赤裸裸的暴力！！！！！！

　　so，举足无措，只好参考大佬博客辽。

　　下面具体说说我的理解：

　　首先解释一下上述博客中给出的公式 sum%(x*n)%x == sum%x 的证法以及作用；

　　证明：

　　　　sum%(x*n) = sum-(int)(sum / (x*n) )*(x*n);

　　　　sum%(x*n)%x =  [sum-(int)(sum / (x*n) )*(x*n) ] % x = sum%x - 0 = sum % x;

　　那，接下来就要看看要怎么用这个公式了，预处理出 1~9的所有不同组合的 lcm ，我是用DFS预处理的；

参考代码如下：

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 using namespace std;
 #define mem(a,b) memset(a,b,sizeof(a))

 int a[];
 bool vis[];//vis[i]:判断数字 i 是否访问过
 bool vis2[*******];//vis2[lcm]:判断当前的lcm是否在之前出现过

 int GCD(int a,int b)
 {
     return a== ? b:GCD(b%a,a);
 }
 int LCM(int a,int b)
 {
     return a*b/GCD(a,b);
 }

 void DFS(int t,int lcm,int &k)
 {
     if(!vis2[lcm])
     {
         a[k++]=lcm;
         vis2[lcm]=true;
     }

     for(int i=;i <= ;++i)
     {
         if(vis[i])
             continue;
         vis[i]=true;
         DFS(t+,LCM(lcm,i),k);
         vis[i]=false;
     }
 }
 int main()
 {
     int k=;

     mem(vis,false);
     mem(vis2,false);

     DFS(,,k);
     sort(a,a+);
     for(int i=;i < k;++i)
         printf("%d,",a[i]);

     return ;
 }

预处理出所有的lcm

　　与处理完后，你会发现最大的lcm为2520，且 2520%(其余的lcm) = 0；

　　那么，这就好办了，对于当前所形成的数 curNum 和当前的 lcm，我们需要判断 curNum % lcm 是否等于0，那么问题就是

　　curNum 太大了怎么办？

　　通过上面的公式，可知 curNum%lcm = curNum%(lcm*(2520/lcm) )%lcm = (curNum%2520)%lcm;

　　所以，每次只需要将 curNum%2520 即可。　　

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 using namespace std;
 #define ll long long
 #define mem(a,b) memset(a,b,sizeof(a))

 ll n,m;
 int digit[];
 ll dp[][][];
 int a[]={ , , , , , , , , ,,
            ,,,,,,,,,,
            ,,,,,,,,,,
            ,,,,,,,,
            ,,,,,,,,,};

 int GCD(int a,int b)
 {
     return a== ? b:GCD(b%a,a);
 }
 int LCM(int a,int b)
 {
     return a*b/GCD(a,b);
 }

 ll DFS(int curPos,int curNum,int lcm,bool limit)
 {
     if(curPos == -)
         return curNum%lcm ==  ? :;
     int t=lower_bound(a,a+,lcm)-a;
     if(!limit && dp[curPos][t][curNum] != -)
         return dp[curPos][t][curNum];

     int up=limit ? digit[curPos]:;
     ll ans=;
     for(int i=;i <= up;++i)
         ans += DFS(curPos-,(curNum*+i)%,(i !=  ? LCM(lcm,i):lcm),limit&&i==digit[curPos]);
     if(!limit)
         dp[curPos][t][curNum]=ans;

     return ans;
 }
 ll Solve(ll x)
 {
     int k=;
     while(x)
     {
         digit[k++]=x%;
         x /= ;
     }
     return DFS(k-,,,true);
 }
 int main()
 {
     int test;
     scanf("%d",&test);
     mem(dp,-);
     while(test--)
     {
         scanf("%lld%lld",&n,&m);
         printf("%lld\n",Solve(m)-Solve(n-));
     }
     return ;
 }