[CodeForces-55D]Beautiful Numbers

题目大意：
　　问区间[l,r]内有多少正整数能被其各个数位上的所有数字整除。

思路：
　　数位DP。
　　能被所有数位整除相当于能被所有数位的LCM整除。
　　而1..9的LCM为2520。
　　f[i][j][k][flag]表示DP到第i位，当前构成的数字在%2520意义下为j，当前各个数位的LCM为k，flag表示当前数是否为边界。
　　第三维的k显然不会完全用到，事实上只会有48个可能的值，因此可以离散化。
　　枚举当前数位p，设边界数的当前数位为cur，则转移方程为：
　　f[i-1][(j*10+p)%SUM][mult[k][p-1]][false]+=f[i][j][k][false];
　　f[i-1][(j*10+p)%SUM][mult[k][p-1]][false]+=f[i][j][k][true];(p<cur)
　　f[i-1][(j*10+p)%SUM][mult[k][p-1]][true]+=f[i][j][k][true];(p==cur)
　　压一下内存，可以用滚动数组。
　　然而交上去发现会在第11个点TLE。
　　试了各种奇怪的方法，并没有什么用。
　　还发现不开优化跑40s的数据，开了O1只需要跑3s。
　　最后开性能分析，发现是在lcm的地方花了很多时间。
　　于是先打表出所有的LCM，然后就过了。
　　（然而51Nod上是10000组数据，不用记忆化搜索根本过不了）

#include<cstdio>
#include<algorithm>
using std::__gcd;
typedef unsigned long long qword;
inline qword getint() {
    register char ch;
    while(!__builtin_isdigit(ch=getchar()));
    register qword x=ch^'0';
    while(__builtin_isdigit(ch=getchar())) x=(((x<<2)+x)<<1)+(ch^'0');
    return x;
}
const int SUM=2520,LCM=48;
const qword pow[]={1ull,10ull,100ull,1000ull,10000ull,100000ull,1000000ull,10000000ull,100000000ull,1000000000ull,10000000000ull,100000000000ull,1000000000000ull,10000000000000ull,100000000000000ull,1000000000000000ull,10000000000000000ull,100000000000000000ull,1000000000000000000ull,10000000000000000000ull};
int id[SUM+1];
const int mul[]={1,2,3,4,5,6,7,8,9,10,12,14,15,18,20,21,24,28,30,35,36,40,42,45,56,60,63,70,72,84,90,105,120,126,140,168,180,210,252,280,315,360,420,504,630,840,1260,2520};
inline int lcm(const int &a,const int &b) {
    return a/__gcd(a,b)*b;
}
int mult[LCM][LCM];
inline void init() {
    for(register int i=0;i<LCM;i++) {
        id[mul[i]]=i;
    }
    for(register int i=0;i<LCM;i++) {
        for(register int j=0;j<LCM;j++) {
            mult[i][j]=id[lcm(mul[i],mul[j])];
        }
    }
}
qword f[2][SUM][LCM][2];
inline qword calc(const qword &n) {
    if(!n) return 1;
    const int len=__builtin_log10(n)+1;
    __builtin_memset(f[len&1],0,sizeof f[len&1]);
    f[len&1][0][0][true]=1;
    for(register int i=len;i;i--) {
        __builtin_memset(f[!(i&1)],0,sizeof f[!(i&1)]);
        const int cur=n%pow[i]/pow[i-1];
        for(register int j=0;j<SUM;j++) {
            for(register int k=0;k<LCM;k++) {
                if(!f[i&1][j][k][true]&&!f[i&1][j][k][false]) continue;
                f[!(i&1)][(((j<<2)+j)<<1)%SUM][k][false]+=f[i&1][j][k][false];
                f[!(i&1)][(((j<<2)+j)<<1)%SUM][k][!cur]+=f[i&1][j][k][true];
                for(register int p=1;p<10;p++) {
                    f[!(i&1)][((((j<<2)+j)<<1)+p)%SUM][mult[k][p-1]][false]+=f[i&1][j][k][false];
                    if(p<cur) f[!(i&1)][((((j<<2)+j)<<1)+p)%SUM][mult[k][p-1]][false]+=f[i&1][j][k][true];
                    if(p==cur) f[!(i&1)][((((j<<2)+j)<<1)+p)%SUM][mult[k][p-1]][true]+=f[i&1][j][k][true];
                }
            }
        }
    }
    qword ret=0;
    for(register int j=0;j<SUM;j++) {
        for(register int k=0;k<LCM;k++) {
            if(!(j%mul[k])) ret+=f[0][j][k][true]+f[0][j][k][false];
        }
    }
    return ret;
}
int main() {
    init();
    for(register int T=getint();T;T--) {
        const qword l=getint(),r=getint();
        __builtin_printf("%I64u
",calc(r)-calc(l-1));
    }
    return 0;
}