ACM 数位DP

转载自 http://blog.csdn.net/fkjslee

引言

数位DP: 与记数有关的一种动态规划, 一般题目是 : 求0 ~ n 之间有多少个符合….条件的数, 或者l ~ r 之间有多少个符合条件的数, 第二种一般来说可以转化到第一种[0, r] - [0, l) = [l, r] 这类问题通常会和取模, 记数, 数字和, 等运算联系在一起;
本文将以:
1.数位DP的所用定理(其实就一个同模)
2.数位DP的状态, 状态转移, 初始化
3.数位DP的统计过程(简单解释一下程序的运算顺序, 每一步是做什么的)
4.例题
的形式介绍数位DP

为了介绍方便会用一个例题来解释数位DP(这个例子没有用到下面所讲的同模的定理)
题目链接 : http://acm.hdu.edu.cn/showproblem.php?pid=2089

题目大意就是问你从l 到 r 有多少个不含62和4的数

所用定理:

 因为数位DP很多和取模有关, 并且和所在数字的位置有关, 所以有个很重要的取模定理(我发现有些人会用这个定理, 但是从来没有去想过这个定理为什么可以)
 定理: 如果(a * 10 + b) % x = y 那么(a % x * 10 + b) % x = y;
 就是说一个数a对于一个数b取模, 它可以一位一位的算;
 举个例子, 求7456 % 9 = ?
 7 % 9 = 7
 (7 * 10 + 4) % 9 = 2
 (2 * 10 + 5) % 9 = 7
 (7 * 10 + 6) % 9 = 4;
 所以7456 % 9 = 4;
 证明:
 令 a = k1 * x + b1; b = k2 * x + b2;
 那么左边的(a * 10 + b) % x = y 就可以写成 (k1 * x * 10 + b1 * 10 + k2 * x + b2) % x 
 右边的 (a % x * 10 + b) % x = y 就可以写成((k1 * x + b1) % x * 10 + k2 * x + b2) % x
 即 ((k1 * x * 10 + b1 * 10) % x + (k2 * x + b2) % x) % x
 即 (k1 * x * 10 + b1 * 10 + k2 * x + b2) % x  等于右边
 用了一个同模定理 a * b % c = a % c * b % c 

数位DP的状态, 状态转移, 初始化 :

大部分数位DP的状态都会有一个状态 : 这个数是几位数, 比如dp[3]一般表示的是后面3位随便填的意思, 指的就是0 ~ 1000的范围的数(当然可能还有其他的限制, dp的维度可能不止一维) 对于上面介绍的例题, 我的状态是这样的 dp[i][j] 表示 i 位数, 并且最高位是j 的不含62和4的 数字有多少个(现在想想 好像一维也可以?)
状态转移 : dp[i][j] = dp[i-1][0~9] 表示 i 位数最高位是 j = i-1位数, 最高位是0 ~ 9 的情况和, 如果j = 6 低位不能为2 如果j = 4, dp[i][j] = 0
初始化 : 数位DP的初始化dp[0]一般不好理解 我也只是模糊的感觉, 如果觉得难理解的话, 可以多写一点 初始化dp[1]也可以 其他位置的初始化成0, 如果开全局的话也可以不用memset 因为全局一出来就初始化成0了
如下图就是对于上面例题的状态 状态转移 和初始化

数位DP的统计过程 :

数位DP的统计是按照从高位到低位依次数下来 举个例子更容易明白, 比如我们统计 324 那么我们先把324 + 1 = 325(为什么+1 看后面)
1算 [0, 100)
2算[100, 200)
3算[200, 300)
4算[300, 310)
5算[310, 320)
6算[320, 321)
7算[321, 322)
8算[321, 323)
9算[323, 324)
10算[324, 325)
注意括号开闭, 你就知道为什么要 + 1了
比如我们对于上面的例题 算21(举个小一点的例子)
[0, 10) = 9
[10, 20) = 9
[20, 21) = 1
[21, 22) = 1;
所以有 20个符合条件的数
再对于 626(因为有62, 同理有4的情况)
1算[0, 100)
2算[100, 200)
…
6算[500, 600)
7算[600, 610)
8算[610, 620)
9算[620, 621) 但是因为前面已经有 62了, 所以接下来的都不符合情况, 不加入结果
到此就完成了[0, x] 中符合条件的数的统计

对于求[l, r] 中符合条件的数 只需要求出[0, r] 和 [0, l-1] 然后相减就可以了
代码如下:

//
//  Created by fkjs on 2015-12-03
//  Copyright (c) 2015 fkjs. All rights reserved.
//
//#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <set>
#include <vector>

using namespace std;

typedef long long int ll;
const int INF = 0x3f3f3f3f;

int dp[11][11];
int n, m;

int getnum(int x) {
    int digit[10];
    int k = 0;
    while(x) {
        digit[++k] = x % 10;
        x /= 10;
    }
    digit[k+1] = 0;
    int ret = 0;
    for(int i = k; i; --i) {
        for(int j = 0; j < digit[i]; ++j)
            if(j - 4 && !(digit[i+1] == 6 && j == 2))
                ret += dp[i][j];
        if(digit[i] == 4 || (digit[i+1] == 6 && digit[i] == 2)) break;
    }
    return ret;
}

int main(void) {
    dp[0][0] = 1;
    for(int i = 1; i <= 7; ++i) {
        for(int j = 0; j <= 9; ++j) {
            if(j == 4) continue;
            for(int k = 0; k <= 9; ++k) {
                if(j == 6 && k == 2) continue;
                if(k == 4) continue;
                dp[i][j] += dp[i-1][k];
            }
        }
    }
    while(scanf("%d%d", &n, &m) == 2 && (n || m)) {
        printf("%d\n", getnum(m+1) - getnum(n));
    }
    return EXIT_SUCCESS;
}

例题:

题目链接 : http://acm.hdu.edu.cn/showproblem.php?pid=3652

(这个题就要用到上面所说的定理了)
题目大意: 问你[0, n]中有多少个数满足 包含13 且能被13整除
具体思路 : 明显的数位DP,
首先有个表示几位数的 占一维
包含13 只需要一维就可以解决, 这一维只需要3个大小, 分别代表, 没13且第一位不是3, 没13 但第一位是3, 有13
能被13整除, 也只需要一维, 只需要13个大小, 表示的这一类数中模13 等于多少就可以了
所以一共三维

dp中的第二维中0代表 : 没13且第一位不是3
1代表 : 没13 但第一位是3
2代表 : 有13

状态转移 : dp[i][0][k] += dp[i-1][0][(k + u) * 10 % 13]( 0 <= u <= 9 && u != 3)
dp[i][0][k] += dp[i-1][1][(k+u) * 10 % 13] (0 <= u <= 9 && u != 1 && u!= 3)
表示的是第 i 位 没有13 且第一位不是3 可以由第 i-1 位 没有13且第一位不是3 转移而来(最高位只要不是3) 也可以由 第一位是3转移而来(只要最高时不是3 和1 )
dp[i][1][k] += dp[i-1][0][(k+3) * 10 % 13]
dp[i][1][k] += dp[i-1][1][(k+3) * 10 % 13]
最高位是3就行
dp[i][2][k] += dp[i-1][2][(k + u) * 10 % 13]( 0 <= u <= 9) (反正已经有13了, 高位随便是什么都行)
dp[i][2][k] += dp[i-1][1][(k+1) * 10 % 13] (最高位填1, 后面的加上最高位是3 就行了)

具体代码如下: (我用的是递归的方式, 其实递推也可以)

#include <cstdio>
#include <cstring>

const int N = 15;

long long dp[N][3][N];
int digit[N];

long long Pow(int a, int b) {
    long long ret = 1;
    for(int i = 0; i < b; ++i) ret *= a;
    return ret;
}

long long dfs(int pos, int type, int mod, int lim) {
    long long ret = dp[pos][type][mod];
    if(!lim && ret) return ret;
    if(pos == 0) return type == 0 && mod == 0;
    ret = 0;
    int g = lim? digit[pos] - 1 : 9;
    if(type == 0) {
        for(int k = 0; k <= g; ++k) {
            if(k != 3) ret += dfs(pos-1, 0, (mod + k) * 10 % 13, 0);
            if(k - 3 && k - 1) ret += dfs(pos-1, 1, (mod + k) * 10 % 13, 0);
        }
    } else if(type == 1) {
        if(!lim || (lim && digit[pos] >= 3)) {
            ret += dfs(pos-1, 0, (mod + 3) * 10 % 13, 0);
            ret += dfs(pos-1, 1, (mod + 3) * 10 % 13, 0);
        }
    } else if(type == 2) {
        for(int k = 0; k <= g; ++k) {
            ret += dfs(pos-1, 2, (mod + k) * 10 % 13, 0);
            if(k == 1) ret += dfs(pos-1, 1, (mod + k) * 10 % 13, 0);
        }
    }
    if(!lim) dp[pos][type][mod] = ret;
    return ret;
}

long long cal(long long x) {
    int len = 0;
    for(int i = 0; x / Pow(10, i); ++i) digit[++len] = x / Pow(10, i) % 10;
    digit[len+1] = 0;
    long long ret = 0;
    long long sto = 0;
    for(int i = len; i; --i) {
        ret += dfs(i, 2, sto * 10 % 13, 1);
        if(digit[i+1] == 1 && digit[i] != 3) ret += dfs(i, 1, sto * 10 % 13, 1);
        if(digit[i+1] == 1 && digit[i] == 3) {
            if(i != 1) ret += (x - (sto * 10 + digit[i]) * Pow(10, i-1)) / 13 + 1;
            break;
        }
        sto = sto * 10 + digit[i];
    }
    return ret;
}

int main() {
    memset(dp, 0, sizeof dp);
    long long n;
    while(scanf("%I64d", &n) == 1) {
        printf("%I64d\n", cal(n+1));
    }
}

数位DP还有很多类型 有些甚至不能用[l, r] = [0, r] - [0, l-1]这种方法, 不过很少 而且数位DP更多的可能会和其他的一些方法放在一起出题, 感觉只要会了平时遇到的数位DP还是能解开的