数位DP

1、CF 55D Beautiful numbers

　　题意：如果一个数能被自己各个位的数字整除，那么它就叫 Beautiful numbers。求区间 [a,b] 中 Beautiful numbers 的个数。

　　思路：一个数能被它的所有非零数位整除，则能被它们的最小公倍数整除，而1到9的最小公倍数为2520， 数位DP时我们只需保存前面那些位的最小公倍数就可进行状态转移，到边界时就把所有位的lcm求出了， 为了判断这个数能否被它的所有数位整除，我们还需要这个数的值，显然要记录值是不可能的，其实我们只 需记录它对2520的模即可，这样我们就可以设计出如下数位DP：dfs(pos,mod,lcm,f),pos为当前位，mod为前面那些位对2520的模，lcm为前面那些数位的最小公倍数，f标记前面那些位是否达到上限， 这样一来dp数组就要开到19*2520*2520，明显超内存了，考虑到最小公倍数是离散的，1-2520中可能 是最小公倍数的其实只有48个，经过离散化处理后，dp数组的最后一维可以降到48，这样就不会超了。

 

#include <stdio.h>
#include <iostream>
#include <map>
#include <set>
#include <list>
#include <stack>
#include <vector>
#include <math.h>
#include <string.h>
#include <queue>
#include <string>
#include <stdlib.h>
#include <algorithm>
#define LL long long
#define eps 1e-12
#define PI acos(-1.0)
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 4010;
const int max_lcm = 2520;

LL gcd(LL a, LL b)
{
    if (b == 0)
        return a;
    return gcd(b, a%b);
}
LL lcm(LL a, LL b)
{
    return a / gcd(a, b)*b;
}
int dig[25];
LL dp[25][50][2525];//经过分析后可以设出dp[20][2050][2050]，dp[i][j][k]表示处理到i位，前面的数的最小公倍数为j，前面的数 % 2520为k。因为1~9组成的最小公倍数只有48个，可以离散化，这样数组就降到了dp[20][50][2520]。
int Hash[2525];

LL dfs(int len, int prelcm, int prenum, int up)
{
    if (len == 0)
    {
        return prenum%prelcm == 0;
    }
    if (!up && dp[len][Hash[prelcm]][prenum] != -1)
        return dp[len][Hash[prelcm]][prenum];
    int end = up ? dig[len] : 9;
    LL res = 0;
    for (int i = 0; i <= end; i++)
    {
        int nownum = (prenum * 10 + i) % max_lcm;
        int nowlcm = prelcm;
        if (i)
            nowlcm = lcm(prelcm, i);
        res += dfs(len - 1, nowlcm, nownum, up&&i == end);//flag&&i==end，在最开始，取出的end是最高位，所以如果i比end小，那么i的下一位都可以到达9，而i==num了，最大能到达的就只有,dig[pos-1] 
    }
    if (!up)
        dp[len][Hash[prelcm]][prenum] = res;
    return res;
}

LL cal(LL num)
{
    int len = 0;
    while (num)
    {
        dig[++len] = num % 10;
        num /= 10;
    }
    return dfs(len, 1, 0, 1);
}

int main()
{
    int test;
    LL a, b;
    int cnt = 0;
    for (int i = 1; i <= 2520; i++) //离散化
    {
        if (max_lcm % i == 0)
            Hash[i] = ++cnt;
    }

    scanf("%d", &test);
    memset(dp, -1, sizeof(dp));
    for (int item = 1; item <= test; item++)
    {
        scanf("%I64d %I64d", &a, &b);
        printf("%I64d\n", cal(b) - cal(a - 1));
    }

    return 0;
}

 

2、HDU 4352 XHXJ’s LIS

　　题意：假设把一个数字当成字符串，将它的最长单调递增子序列长度称为power值，求[L,R]区间内power值等于k（1<=K<=10）的值有多少个。

　　思路：dp[i][j][k]:i为当前进行到的数位，j状态压缩，为10个数字出现过的，其中1的个数就是最长上升子序列，k要求的上升子序列的长度。

#include<cstdio>
#include<cstring>
#include<iostream>
#define LL __int64
using namespace std;
LL dp[40][1<<10][11];//dp[i][j][k]:i为当前进行到的数位，j状态压缩，为10个数字出现过的，其中1的个数就是最长上升子序列，k要求的上升子序列的长度
int bit[40], pos;
LL L, R; int K;
int numone(int state)
{//得到1的个数，即最长递增子序列的长度
    int ret = 0;
    while (state)
    {
        ret += state & 1; state >>= 1;
    }
    return ret;
}
int turn(int state, int x)
{//找到第一个大于x的数并且替换他，nlogn求最长递增子序列的思想

    for(int i=x;i<=9;i++)
        if ((1<<i)&state)
        {
            return ((state^(1<<i)) | (1<<x));
        }
    return (state | (1<<x));
}
LL DP(int pp, int state, bool nozero, bool big)//has 是否有inc==K
{//nozero为前面的是否为0标记，big上界标记
    if (pp == 0)return numone(state) == K;
    if (big&&dp[pp][state][K] != -1)return dp[pp][state][K];
    LL ret = 0;
    int kn = big ? 9 : bit[pp];
    for(int i=0;i<=kn;i++)
    {
        ret += DP(pp - 1, (nozero || i != 0) ? turn(state, i) : 0, nozero || i != 0, big || kn != i);
    }
    if (big)dp[pp][state][K] = ret;
    return ret;
}
LL get(LL x)
{
    pos = 0;
    while (x)
    {
        bit[++pos] = x % 10;
        x /= 10;
    }
    return DP(pos, 0, 0, 0);
}
int main()
{
    int t; 
    memset(dp, -1, sizeof(dp));
    scanf("%d", &t);
    int Case = 1;
    while (t--)
    {
            scanf("%I64d%I64d%d", &L, &R, &K);
            printf("Case #%d: %I64d\n", Case++, get(R) - get(L - 1));
    }
    return 0;
}