数位DP

　　萌新第一题：HDU2089 不要62　

#include <iostream>
#include <string.h>
#include <cstdio>
#include <queue>
#include <math.h>
#include <string>
#include <map>
#include <algorithm>

#define SIGMA_SIZE 26
#pragma warning ( disable : 4996 )

using namespace std;
typedef long long LL;

inline LL LMax(LL a,LL b)    { return a>b?a:b; }
inline LL LMin(LL a,LL b)    { return a>b?b:a; }
inline int Max(int a,int b) { return a>b?a:b; }
inline int Min(int a,int b) { return a>b?b:a; }
inline int gcd( int a, int b ) { return b==0?a:gcd(b,a%b); }
inline int lcm( int a, int b ) { return a/gcd(a,b)*b; }  //a*b = gcd*lcm
const int inf  = 0x3f3f3f3f;
const int mod  = 100000000;
const int maxn = 1e6+5;
const int maxk = 200;

int dp[20][2];
int num[20];

int find( int pos, int pre, int sta, bool limit )
{
    if ( pos == -1 ) return 1;
    if ( !limit && dp[pos][sta] != -1 ) return dp[pos][sta];
    int up = limit?num[pos]:9;
    int tmp = 0; 
    for ( int i = 0; i <= up; i++ )
    {
        if ( pre == 6 && i == 2 ) continue;
        if ( i == 4 ) continue;
        tmp += find(pos-1, i, i==6, limit&&i==num[pos]);
    }

    if (!limit) dp[pos][sta] = tmp;
    return tmp;
}

int solve( int x )
{
    int pos = 0;
    while(x)
        { num[pos++] = x % 10; x /= 10; }

    return find( pos-1, -1, 0, true );
}

int main()
{
    int lhs, rhs;
    while ( ~scanf("%d %d", &lhs, &rhs) && lhs && rhs )
    {
        memset( dp, -1, sizeof(dp) );
        printf( "%d
", solve(rhs)-solve(lhs-1) );
    }
    return 0;
}

　　萌新第二题：HDU3652 B数...

　有点巧妙啊，第一题只是相当于把题解抄下来了，再做这道题稍微有点感觉了，详细见注释　

#include <iostream>
#include <string.h>
#include <cstdio>
#include <queue>
#include <math.h>
#include <string>
#include <map>
#include <algorithm>

#define SIGMA_SIZE 26
#pragma warning ( disable : 4996 )

using namespace std;
typedef long long LL;

inline LL LMax(LL a,LL b)    { return a>b?a:b; }
inline LL LMin(LL a,LL b)    { return a>b?b:a; }
inline int Max(int a,int b) { return a>b?a:b; }
inline int Min(int a,int b) { return a>b?b:a; }
inline int gcd( int a, int b ) { return b==0?a:gcd(b,a%b); }
inline int lcm( int a, int b ) { return a/gcd(a,b)*b; }  //a*b = gcd*lcm
const int inf  = 0x3f3f3f3f;
const int mod  = 100000000;
const int maxn = 1e6+5;
const int maxk = 200;

//dp[i][j][k] i:位数 j:余数 k:0表示前面不是1，1表示前面是1，2表示前面已经有13了
int dp[15][15][3];
int bit[15];

int find(int pos, int mod, int pre, bool lim )
{
    if ( pos == -1 ) return ( mod == 0 && pre == 2 );

    // 务必理解什么是记忆化
    if ( !lim && dp[pos][mod][pre] != -1 ) return dp[pos][mod][pre];
    
    int num = lim?bit[pos]:9;

    int tmp = 0;
    for ( int i = 0; i <= num; i++ )
    {
        int mmod = (mod*10 + i) % 13;    //其实就是做了一个除法，拿笔做演算下，比如计算2333除以13，
                                        //就知道这一步是什么意思了
        
        int ppre = 0;                //初始设为0
        if ( pre == 0 && i == 1 )    //如果前面不是1，现在是1
            ppre = 1;
        if ( pre == 1 && i == 1 )    //如果前面是1，现在还是1
            ppre = 1;
        if ( pre == 1 && i == 3 )    //如果前面是1， 现在是3
            ppre = 2;
        if ( pre == 2 ) ppre = 2;

        tmp += find( pos-1, mmod, ppre, lim&&i==bit[pos] );
    }

    //注意对有lim的处理（实际上有lim的计算很少）
    //仔细想想，当lim为true的时候，那么上面的for循环就不完整，也就是num可能不为9
    //既然该状态不完整，所以不能记忆保存下来啦！
    if (!lim) dp[pos][mod][pre] = tmp;
    return tmp;
}

int solve( int x )
{
    int pos = 0;
    while(x)
        { bit[pos++] = x%10; x/=10; }

    return find(pos-1, 0, 0, true);
}

int main()
{
    int rhs; 
    
    while ( ~scanf("%d", &rhs) )
    {
        memset( dp, -1, sizeof(dp) );
        memset( bit, 0, sizeof(bit) );
        printf( "%d
", solve(rhs) ); 
    }
    return 0;
}