bzoj 1026

很久以前做过的一道数位DP，现在用一种新的解决数位DP的比较一般的方法。

数位DP裸题是：求[L,R]有多少个数。

先转化成求[0,R]有多少个数，然后区间相减即可。

对于[0,R]中的所有数，用0补齐前面的空位，使得每个数的长度都为R的长度。

状态：

dp[pos][0]表示从最高位到pos位，没有顶上界的数的个数

dp[pos][1]表示从最高位到pos位，顶到上界的数的个数（好吧，这个问题中，它一定为1）

然后考虑转移，

dp[pos][0]->dp[pos-1][0]（通过枚举pos-1位的数进行转移）

dp[pos][1]->dp[pos-1][0]（通过枚举pos-1位，小于该位上界的数进行转移）

dp[pos][1]->dp[pos-1][1]（只能在pos-1位填1）

顺推倒推都可以。

dp[1][0]+dp[1][1]就是答案。

对于其它的数位DP，都可以在这个DP上加上需要的状态维，然后解决其它问题。

上面的dp[pos][1]看似没有用（因为始终为1），但是实际上，我们是必须要它的，比如这道题。

我们设dp[pos][top][tail]表示：“比pos高的位，顶上界（top为1）或不顶上界(top为0），最后一位为tail的数的个数（并且要求这个数不为0）“

然后自己YY转移吧（这个不为0的要求和上一道题有点不同，具体看代码）。

新方法：

 /**************************************************************
     Problem: 1026
     User: idy002
     Language: C++
     Result: Accepted
     Time:0 ms
     Memory:808 kb
 ****************************************************************/

 #include <cstdio>
 #include <cstring>
 #define abs(a) ((a)>0?(a):-(a))

 typedef long long poi;

 poi lf, rg;
 int aa[], tot;
 poi dp[][][];

 poi calc( poi v ) {         //  v in [1,oo)
     for( tot=; v; v/= )
         aa[++tot]=v%;
     memset( dp, , sizeof(dp) );
     dp[tot][][aa[tot]] = ;
     for( int i=; i<aa[tot]; i++ )
         dp[tot][][i] = ;
     for( int i=tot; i>=; i-- ) {
         for( int c=; c<=; c++ )
             for( int s=; s<=; s++ )
                 if( abs(s-c)>= )
                     dp[i-][][s] += dp[i][][c];
         for( int s=; s<=; s++ )
             dp[i-][][s]++;
         for( int s=; s<aa[i-]; s++ )
             if( abs(s-aa[i])>= )
                 dp[i-][][s] += dp[i][][aa[i]];
         dp[i-][][aa[i-]] = dp[i][][aa[i]] && abs(aa[i]-aa[i-])>=;
     }
     poi rt=dp[][][aa[]];
     for( int i=; i<=; i++ )
         rt += dp[][][i];
     return rt;
 }
 int main() {
     scanf( "%lld%lld", &lf, &rg );
     printf( "%lld\n", calc(rg)-(lf==?:calc(lf-)) );
 }

以前的：

 /**************************************************************
     Problem: 1026
     User: idy002
     Language: C++
     Result: Accepted
     Time:0 ms
     Memory:804 kb
 ****************************************************************/

 #include <cstdio>
 #include <algorithm>
 using namespace std;

 struct Form {
     int n;
     int b[];
     int src;
     Form( int a ) {
         n = ;
         src = a;
         if( a== ) {
             n=;
             b[] = ;
             return;
         }
         while( a ) {
             b[++n] = a%;
             a/=;
         }
     }
 };
 int dp[][];     // dp[0~9][0~10]

 void init() {
     for( int h=; h<=; h++ )
         dp[h][] = ;
     for( int l=; l<=; l++ )
         for( int h=; h<=; h++ )
             for( int g=; g<=; g++ )
                 if( abs(g-h)>= )
                     dp[h][l] += dp[g][l-];
 }

 int calc( const Form &fm) { //  [0,fm.src)
     int ans = fm.src!=;    //
     for( int l=; l<fm.n; l++ )
         for( int h=; h<=; h++ ) {
             ans += dp[h][l];
             //printf( "(h=%d,l=%d)\n", h, l );
         }
     for( int h=; h<fm.b[fm.n]; h++ ) {
         ans += dp[h][fm.n];
         //printf( "(h=%d,l=%d)\n", h, fm.n );
     }
     for( int l=fm.n-; l>=; l-- ) {
         for( int h=; h<fm.b[l]; h++ )
             if( abs(h-fm.b[l+])>= ) {
                 ans += dp[h][l];
                 //printf( "(h=%d,l=%d)\n", h, l );
             }
         if( abs(fm.b[l]-fm.b[l+])< ) break;
     }
     return ans;
 }

 int main() {
 //  freopen( "windy.in", "r", stdin );
 //  freopen( "windy.out", "w", stdout );
     int A, B, ans;
     init();
     scanf( "%d%d", &A, &B );
     ans = calc(Form(B+))-calc(Form(A));
     printf( "%d\n", ans );
 }