POJ3253 Round Numbers + HDU2089 不要62 —— 数位DP

POJ3253 ：http://poj.org/problem?id=3252

HDU2089：http://acm.hdu.edu.cn/showproblem.php?pid=2089

题目的一般形式：

求 [ L, R ] 范围内满足限制条件的值的个数。

而 [ L, R ]  = [ 0 , R ] - [ 0, L-1 ] ，所以做法就是分别求出 在R范围内满足条件的个数t1， 和 在L-1范围内满足条件的个数t2。

则 ans = t1 - t2。

数位DP（记忆化搜索）：

数组：dp[pos][s1][s2][s3……] 

pos表示当前位， s1 、s2 ……表示限制条件，维数的个数即限制条件的个数。

比如：dp[pos][s] 表示当前位为pos， 先前状态为s的满足条件的个数。

注意：若先前状态的某个限制条件对后续状态没有影响，那么该限制条件就无需记录了。（例如：HDU3253）

搜索过程：

1.从上限开始，往下搜，直到0。

2.从高位开始，往下搜，直到最低位。

POJ3253：

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const double eps = 1e-6;
const int INF = 2e9;
const LL LNF = 9e18;
const int mod = 1e9+7;
const int maxn = 20;

int dp[50][50][50], bin[100];

//pos为当前位， num0、num1分别为高位的0、1的个数， lim表示是否处在上限， ok记录之前的位是否有效，即高位是否都为前缀0
int dfs(int pos, int num0, int num1, bool lim, bool ok)
{
    if(!pos) return  num0>=num1;

    //如果还处在上限，就不能直接返回，因为低位的数值不能随意取。
    if(!lim && dp[pos][num0][num1]!=-1) return dp[pos][num0][num1];

    int ret = 0;
    int maxx = lim? bin[pos] : 1;   //求当前位的最大值
    for(int i = 0; i<=maxx; i++)
        ret += dfs(pos-1, ok?(num0+(i==0)):0, ok?num1+(i==1):(i==1), lim&&(i==bin[pos]), ok||i );

    //如果高位不处在上限，那么表明其低位可以自由取值，这时就需要记忆化。
    if(!lim) dp[pos][num0][num1] = ret;
    return ret;
}

int solve(int n)
{
    int len = 0;
    while(n)
    {
        bin[++len] = n&1;
        n >>= 1;
    }
    return dfs(len, 0, 0, 1, 0);
}

int main()
{
    int n, m;
    memset(dp,-1,sizeof(dp));
    while(scanf("%d%d",&m, &n)!=EOF)
    {
        cout<< solve(n) - solve(m-1)<<endl;
    }
}

HDU2089：

为什么限制条件只是记录上一位是否为6，而不用记录上一位是否为4呢？

因为不管上一位的取值是否为4，其对当前位的取值没有影响，所以无需记录。

而如果上一位是6，那么当前位就不能取2。这表明了上一位是否为6的状态，影响到了当前位的取值，所以需要记录这个限制条件。

代码如下：

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const double eps = 1e-6;
const int INF = 2e9;
const LL LNF = 9e18;
const int mod = 1e9+7;
const int maxn = 20;

int dp[8][2],digit[8];

int dfs(int pos, bool state, int lim)
{
    if(!pos)  return 1;
    if(!lim && dp[pos][state] != -1)   return dp[pos][state];

    int ret = 0;
    int maxx = lim? digit[pos] : 9;
    for(int i=0; i<=maxx; i++)
    {
        if( i==4 || (state && i==2) )   continue;

        ret += dfs( pos-1, i==6, lim&&(i==maxx) );
    }
    if(!lim)  dp[pos][state] = ret;
    return ret;
}

int solve(int n)
{
    int len = 0;
    while(n)
    {
        digit[++len] = n % 10;
        n /= 10;
    }
    return dfs(len,0,1);
}

int main()
{
    int n, m;
    memset(dp,-1,sizeof(dp));
    while(scanf("%d%d",&m,&n) && (m||n) )
    {
        cout<< solve(n)-solve(m-1) <<endl;
    }
    return 0;
}