[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\n",calc(r)-calc(l-1));
    }
    return 0;
}