Light OJ 1140

数位dp，需要记录前导0。

 

数位dp中需要注意统计0,00,000……这些数字。

数位dp的写法可以分为两类。由于我们通常采用记忆化搜索的方式进行dp，所以我们有一个记忆化数组。

一种是记忆化数组的意义是不通用的，对于不同case，该数组的值不同。另一种是通用的，不同case，数组的值不变。

 

对于第一种情况的实现比较简单，只需要將递归过程的全部参数记录在数组的维度中。

由于要记录全部的参数，数组维度高，所以空间效率低。

由于不同case要重新计算记忆化数组，所以对于多case的评判时间效率低。

模板如下：

long long dfs(int digit, bool less, bool leading_zero, ...)

{

    if (digit < 0)

    {

        return ...;

    }

    if (memoize[digit][less][leading_zero][...] != -1)

    {

        return memoize[digit][less][leading_zero][...];

    }

    int limit = less ? 9 : f[digit];

    long long ret = 0;

    for (int i = 0; i <= limit; i++)

    {

        ret += dfs(digit - 1, less || i < f[digit], leading_zero && i==0, ...);

    }

    return memoize[digit][less][leading_zero][...] = ret;

}

View Code

 

对于第二种情况，则需要对某些参数进行条件判断，记忆化数组memoize[digit]中记录的是，最低的digit位可以任意取值的情况下，我们所需要的答案。

因而，这种记忆化数组自然不会受到上界的限制。

但是实现起来复杂，如果需要条件判断的变量（在递归参数中，却不在记忆化数组中的变量）过多，则会尤为复杂。

尤其是对于那种多个数字，每个数字都有上界，同时进行dp的情况，不应该使用这种方法，而应选用第一种方法。

模板如下：

long long dfs(int digit, bool less, bool leading_zero, ...)

{

    if (digit < 0)

    {

        return ...;

    }

    if (less && !leading_zero && memoize[digit][...] != -1)

    {

        return memoize[digit][...];

    }

    int limit = less ? 9 : f[digit];

    long long ret = 0;

    for (int i = 0; i <= limit; i++)

    {

        ret += dfs(digit - 1, less || i < f[digit], leading_zero && i == 0, ...);

    }

    if (less && !leading_zero)

    {

        memoize[digit][...] = ret;

    }

    return ret;

}

View Code

 

本题答案如下：

#include <cstdio>

#include <cstring>

using namespace std;



const int MAX_DIGIT = 20;



long long n;

int f[MAX_DIGIT];

long long memoize[MAX_DIGIT][20*20*9];

int pivot;



int to_digits(long long a)

{

    int ret = 0;

    while (a > 0)

    {

        f[ret++] = a % 10;

        a /= 10;

    }

    return ret;

}



long long dfs(int digit, bool less, bool leading_zero, int zero_num)

{

    if (digit < 0)

    {

        return zero_num;

    }

    if (less && !leading_zero && memoize[digit][zero_num] != -1)

    {

        return memoize[digit][zero_num];

    }

    int limit = less ? 9 : f[digit];

    long long ret = 0;

    for (int i = 0; i <= limit; i++)

    {

        int delta = !leading_zero && i == 0 ? 1 : 0;

        ret += dfs(digit - 1, less || i < f[digit], leading_zero && i == 0, zero_num + delta);

    }

    if (less && !leading_zero)

    {

        memoize[digit][zero_num] = ret;

    }

    return ret;

}



long long work(long long n)

{

    if (n < 0)

    {

        return 0;

    }

    if (n == 0)

    {

        return 1;

    }

    int len = to_digits(n);

    return dfs(len - 1, false, true, 0) + 1;

}



int main()

{

    int t;

    scanf("%d", &t);

    memset(memoize, -1, sizeof(memoize));

    for (int i = 1; i <= t; i++)

    {

        long long a, b;

        scanf("%lld%lld", &a, &b);

        printf("Case %d: %lld\n", i, work(b) - work(a - 1));

    }

    return 0;

}

View Code