数位dp小记

最新推荐文章于 2024-02-04 00:11:14 发布
原创 最新推荐文章于 2024-02-04 00:11:14 发布 · 1.3k 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#dp #数位统计

参考：

http://www.cnblogs.com/jffifa/archive/2012/08/17/2644847.html

kuangbin ：http://www.cnblogs.com/kuangbin/category/476047.html

http://blog.csdn.net/cmonkey_cfj/article/details/7798809

http://blog.csdn.net/liuqiyao_01/article/details/9109419

数位dp有递推和记忆化搜索的方法，比较来说记忆化搜索方法更好。通过博客一的一个好的模板，数位dp就几乎变成一个线性dp问题了。

下为博客一内容：

。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

偷看了下7k+大牛的数位统计dp写法，通常的数位dp可以写成如下形式：

复制代码 
int dfs(int i, int s, bool e) {
    if (i==-1) return s==target_s;
    if (!e && ~f[i][s]) return f[i][s];
    int res = 0;
    int u = e?num[i]:9;
    for (int d = first?1:0; d <= u; ++d)
        res += dfs(i-1, new_s(s, d), e&&d==u);
    return e?res:f[i][s]=res;
}
复制代码

其中：

f为记忆化数组；

i为当前处理串的第i位（权重表示法，也即后面剩下i+1位待填数）；

s为之前数字的状态（如果要求后面的数满足什么状态，也可以再记一个目标状态t之类，for的时候枚举下t）；

e表示之前的数是否是上界的前缀（即后面的数能否任意填）。

for循环枚举数字时，要注意是否能枚举0，以及0对于状态的影响，有的题目前导0和中间的0是等价的，但有的不是，对于后者可以在dfs时再加一个状态变量z，表示前面是否全部是前导0，也可以看是否是首位，然后外面统计时候枚举一下位数。It depends.

于是关键就在怎么设计状态。当然做多了之后状态一眼就可以瞄出来。

注意：

不满足区间减法性质的话（如hdu 4376），不能用solve(r)-solve(l-1)，状态设计会更加诡异。

。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

正如上面说的要注意：

前导零是否有影响。

是否满足区间减的性质。（如hdu4376，还没做，先记上）


几乎就是模板题：

模板：

UESTC 1307相邻的数差大于等于2

（不允许有前导0，前导0对计算有影响，注意前导0的处理）

int dp[15][10];
int bit[15];
int dfs(int pos, int s, bool limit, bool fzero)
{
     if (pos == -1) return 1;///前导0的影响!!!
    if (!limit && !fzero && ~dp[pos][s]) return dp[pos][s];///条件判断!!!
    int end = limit ? bit[pos] : 9;

    int ans = 0;
    for (int i = 0; i <= end; i++)
    {
        if (!fzero && abs(i - s) < 2) continue;///前导0的影响!!!
        int nows = i;
        ans += dfs(pos - 1, nows, limit && (i == end), fzero && !i);
    }

    return limit || fzero ? ans : dp[pos][s] = ans;///条件判断!!!
}
int calc(int n)
{
    if (n == 0) return 1;
    int len = 0;
    while (n)
    {
        bit[len++] = n % 10;
        n /= 10;
    }
    return dfs(len - 1, 0, 1, 1);
}
int main ()
{
    memset(dp, -1, sizeof(dp));
    int l, r;
    while (cin >> l >> r)
    {
        cout << calc(r) - calc(l - 1) << endl;
    }
    return 0;
}

其它一些题目：

Hdu3555不能出现连续的49

int bit[25];
LL dp[25][3];
/**
0
1
2
*/

/**
pos为当前考虑的位置
s为在pos之前已到达的状态
limit当前考虑的数字是否有限制,即之前已确定的数是否为n的前缀
*/
LL dfs(int pos, int s, bool limit)
{
    if (pos == -1) return s == 2;
    if (!limit && ~dp[pos][s]) return dp[pos][s];
    int end = limit ? bit[pos] : 9;///limit选择
    LL ans = 0;

    for (int i = 0; i <= end; i++)
    {
        int nows;
        if (s == 0)
        {
            if (i == 4) nows = 1;
            else nows = 0;
        }
        else if (s == 1)
        {
            if (i == 9) nows = 2;
            else if (i == 4) nows = 1;
            else nows = 0;
        }
        else if (s == 2) nows = 2;

        ans += dfs(pos - 1, nows, limit && i == end);
    }

    return limit ? ans : dp[pos][s] = ans;///limit选择
}

LL calc(LL n)
{
    ///
    int len = 0;
    while (n)
    {
        bit[len++] = n % 10;
        n /= 10;
    }
    ///
    return dfs(len - 1, 0, 1);
}
int main ()
{
    memset(dp, -1, sizeof(dp));
    int T;
    RI(T);
    LL n;
    while (T--)
    {
        cin >> n;
        cout << calc(n) << endl;
    }
    return 0;
}

hdu2089 不要62 

int dp[10][3];
int bit[10];
int dfs(int pos, int s, int limit, bool first)
{
    if (pos == -1) return s == 2;
    if (!limit && ~dp[pos][s]) return dp[pos][s];
    int end = limit ? bit[pos] : 9;
//    int be = first ? 1 : 0;


    int ans = 0;
    for (int i = 0; i <= end; i++)
    {
        int nows = s;
        if (s == 0)
        {
            if (i == 6) nows = 1;
            else if (i == 4) nows = 2;
        }
        if (s == 1)
        {
            if (i == 2 || i == 4) nows = 2;
            else if (i == 6) nows = 1;
            else nows = 0;
        }
        if (i == 4) nows = 2;

        ans += dfs(pos - 1, nows, limit && (i == end), first && !i);
    }

    return limit ? ans : dp[pos][s] = ans;
}
int calc(int n)
{
    int tmp = n;
    if (n == 0) return 0;
    int len = 0;
    while (n)
    {
        bit[len++] = n % 10;
        n /= 10;
    }
    return tmp - dfs(len - 1, 0, 1, 1);
}
int main ()
{
    memset(dp, -1, sizeof(dp));
    int l, r;
//    for (int i = 1; i <= 100; i++)
//        cout << i << ' ' << calc(i) << endl;
    while (cin >> l >> r)
    {
        if (l + r == 0) break;
//        cout << calc(r) << ' ' << calc(l - 1) << endl;
        cout << calc(r) - calc(l - 1) << endl;
    }

    return 0;
}

UESTC 1307相邻的数差大于等于2

（注意前导0的处理）

int dp[15][10];
int bit[15];
int dfs(int pos, int s, bool limit, bool fzero)
{
     if (pos == -1) return 1;///前导0的影响!!!
    if (!limit && !fzero && ~dp[pos][s]) return dp[pos][s];///条件判断!!!
    int end = limit ? bit[pos] : 9;

    int ans = 0;
    for (int i = 0; i <= end; i++)
    {
        if (!fzero && abs(i - s) < 2) continue;///前导0的影响!!!
        int nows = i;
        ans += dfs(pos - 1, nows, limit && (i == end), fzero && !i);
    }

    return limit || fzero ? ans : dp[pos][s] = ans;///条件判断!!!
}
int calc(int n)
{
    if (n == 0) return 1;
    int len = 0;
    while (n)
    {
        bit[len++] = n % 10;
        n /= 10;
    }
    return dfs(len - 1, 0, 1, 1);
}
int main ()
{
    memset(dp, -1, sizeof(dp));
    int l, r;
    while (cin >> l >> r)
    {
        cout << calc(r) - calc(l - 1) << endl;
    }
    return 0;
}

POJ 3252  Round Number (组合数)！！！

拆成2进制，在记录0和1的个数

求区间[l,r]中，满足传化成2进制后，0的个数>=1的个数的，数字的个数

int dp[40][40][40];
int bit[40];
int dfs(int pos, int num0, int num1, bool limit, bool fzero)
{
     if (pos == -1) return num0 >= num1;///前导0的影响!!!
    if (!limit && !fzero && ~dp[pos][num0][num1]) return dp[pos][num0][num1];///条件判断!!!
    int end = limit ? bit[pos] : 1;

    int ans = 0;
    for (int i = 0; i <= end; i++)
    {
        int new0, new1;
        if (fzero)
        {
            new0 = 0, new1 = 0;
            if (i) new1 = 1;
        }
        else
        {
            new0 = num0, new1 = num1;
            if (i) new1++;
            else new0++;
        }
        ans +=  dfs(pos - 1, new0, new1, limit && (i == end), fzero && !i);
    }
    return limit || fzero ? ans : dp[pos][num0][num1] = ans;///条件判断!!!
}
int calc(int n)
{
    if (n == 0) return 1;
    int len = 0;
    while (n)
    {
        bit[len++] = n % 2;
        n /= 2;
    }
    return dfs(len - 1, 0, 0, 1, 1);
}
int main ()
{
    memset(dp, -1, sizeof(dp));
    int l, r;
    while (cin >> l >> r)
    {
        cout << calc(r) - calc(l - 1) << endl;
    }
    return 0;
}


hdu3886求满足符号串的数字个数！！！

统计满足和指定 升降字符串 匹配的个数

int dp[105][105][10];
int bit[105];
char s[105];
char a[105], b[105];
int ns;

bool ok(int r, int a, int b)
{
    if (s[r] == '/') return a < b;
    else if (s[r] == '-') return a == b;
    else if (s[r] == '\\') return a > b;
}
int dfs(int pos, int r, int pre, bool limit, bool prezero)
{
    if (pos == -1) return (r == ns);
    if (!limit && !prezero && ~dp[pos][r][pre]) return dp[pos][r][pre];
    int end = limit ? bit[pos] : 9;
    int ans = 0;

    for (int i = 0; i <= end; i++)
    {
        if (prezero)
        {
            ans += dfs(pos - 1, r, i, limit && (i == end), prezero && (!i));
        }
        else
        {
            if (r < ns && ok(r, pre, i))///优先考虑向后拓展
                ans += dfs(pos - 1, r + 1, i, limit && (i == end), 0);
            else if (r > 0 && ok(r - 1, pre, i))
                ans += dfs(pos - 1, r, i, limit && (i == end), 0);
        }
        ans %= MOD;
    }
    if (!limit && !prezero) dp[pos][r][pre] = ans;
    return ans;
}
int calc(char a[], bool dec)
{

    int n = strlen(a);
    int len = 0, tmp = 0;
    while (a[tmp] == '0') tmp++;
    for (int i = n - 1; i >= tmp; i--)
    {
        bit[len++] = a[i] - '0';
    }
    if (dec && len > 0)
    {
        for (int i = 0; i < len; i++)
        {
            if (bit[i])
            {
                bit[i]--;
                break;
            }
            else bit[i] = 9;
        }
    }
    return dfs(len - 1, 0, 0, 1, 1);
}

int main ()
{
    while (scanf("%s", s) != EOF)
    {
        memset(dp, -1, sizeof(dp));
        ns = strlen(s);
        scanf("%s%s", a, b);
        printf("%08d\n", (calc(b, 0) - calc(a, 1) + MOD) % MOD);
    }
    return 0;
}

HDU 3709 平衡数

LL dp[20][20][2000];
///力矩最大为不超过10*20*10;
int bit[20];

LL dfs(int pos, int r, int sum, int e)
{
    if (pos == -1) return sum == 0;
    if (sum < 0) return 0;
    if (!e && ~dp[pos][r][sum]) return dp[pos][r][sum];
    int end = e ? bit[pos] : 9;
    LL ans = 0;
    for (int i = 0; i <= end; i++)
    {
        ans += dfs(pos - 1, r, sum + i * (pos - r), e && (i == end));
    }
    if (!e) dp[pos][r][sum] = ans;
    return ans;
}

LL calc(LL n)
{
    if (n < 0) return 0;
    int len = 0;
    while (n)
    {
        bit[len++] = n % 10;
        n /= 10;
    }
    LL ans = 0;
    for (int i = 0; i < len; i++)///需要枚举支点
        ans += dfs(len - 1, i, 0, 1);
    return ans - (len - 1);
}
int main ()
{
    memset(dp, -1, sizeof(dp));
    int t;
    LL l, r;
    RI(t);
    while (t--)
    {
        scanf("%I64d%I64d", &l, &r);
        printf("%I64d\n", calc(r) - calc(l - 1));
    }

    return 0;
}


HDU4352严格上升子序列的长度为K的个数。！！！

最长上升子序列结合，通过集合（1<<10）来处理

LL dp[25][1 << 11][11];
int bit[25];
int k;
int getnews(int s, int x)
{
    for(int i=x;i<10;i++)
        if(s&(1<<i))return (s^(1<<i))|(1<<x);
    return s|(1<<x);
}
int getnum(int s)
{
    int ret = 0;
    while (s)
    {
        if (s & 1) ret++;
        s >>= 1;
    }
    return ret;
}
LL dfs(int pos, int s, int e, int z)
{
    if (pos == -1) return getnum(s) == k;
    if (!e && ~dp[pos][s][k]) return dp[pos][s][k];
    int end = e ? bit[pos] : 9;
    LL ans = 0;

    for (int i = 0; i <= end; i++)
    {
        int news = getnews(s, i);
        if (z && !i) news = 0;
        ans += dfs(pos - 1, news, e && (i == end), z && (!i));
    }
    if (!e) dp[pos][s][k] = ans;
    return ans;
}

LL calc(LL n)
{
    int len = 0;
    while (n)
    {
        bit[len++] = n % 10;
        n /= 10;
    }
    return dfs(len - 1, 0, 1, 1);
}

int main ()
{
    LL n, m;
    memset(dp, -1, sizeof(dp));
    int t;
    scanf("%d", &t);
    int nc = 1;
    while (t--)
    {
        cin >> n >> m >> k;
        printf("Case #%d: ", nc++);
        cout << calc(m) - calc(n - 1) << endl;
    }
    return 0;
}


！！！是比较不错，待看的题

比较还好的处理的题目：

Codeforces 55D Beautiful numbers！！！

spoj 10606 Balanced Numbers


ac自动机和数位dp结合（！！！）：

hdu4376！！！（区间不可减？？？）
ZOJ3494 BCD Code(AC自动机+数位DP)！！！


整除和简单统计：

HDU4507 和7无关数的平方和！！！

HDU 3652 出现13，而且能被13整除

LightOJ 1068 能被K整数且各位数字之和也能被K整除的数

light OJ 1140两个数之间的所有数中零的个数。

lightoj 1032  二进制数中连续两个‘1’出现次数的和

其它：
LightOJ1205求区间[a,b]的回文数个数。
ural 1057 数位统计
codeforces215E周期数
codeforces258B在1-m中任选7个数，要使前六个数字中的“4”,"7"之和小于第七个的，
Zoj2599 数位统计（见题意）
zoj3162分形、自相似


4.6.1 蓝桥杯动态规划之数位DP
tang7mj的博客
01-26 1515
数位DP是动态规划的一个重要分支，在处理数字的数位问题时非常有效。熟练掌握数位DP，对于编程竞赛和算法解题是非常有帮助的。希望本文能为你在学习数位DP的道路上提供一些指导和帮助。
数位DP - 带49的数
CSDN
12-02 2222
带49的数，数位DP
【数位dp】【回文】
ACM之路
08-14 964
PDF (English) Statistics Forum Time Limit: 2 second(s) Memory Limit: 32 MB A palindromic number or numeral palindrome is a 'symmetr
回文&升降 数位dp
weixin_30800807的博客
08-25 136
题目链接：here Problem G: 等凹数字 Description 定义一种数字称为等凹数字，即从高位到地位，每一位的数字先非递增再非递减，不能全部数字一样，且该数是一个回文数，即从左读到右与从右读到左是一样的，仅形成一个等凹峰，如543212345，5544334455是合法的等凹数字，543212346，123321，111111不是等凹数字。现在问你[L,R]中有...
lightoj 1205（回文数的数量 数位dp）
Everything can be done!
08-22 834
经典数位dp,思路就是在数的前一半的时候随意枚举，但是要考虑前导零，后一半跟前边对称就行。 #include using namespace std; typedef long long ll; typedef pair P; #define fi first #define se second #define INF 0x3f3f3f3f #define clr(x,y) memset
hdu 6156 Palindrome Function【数位dp求回文数】
HARD_UNDERSTAND
08-22 518
题目http://acm.hdu.edu.cn/showproblem.php?pid=6156题意求2～k进制下在【L，R】范围内的回文数分析数位dp求回文数，注意T范围很大，那么直接记忆进制即可。代码#include <iostream> #include <cstdio> #include <cstring> #include <algorithm>using namespace std;ty
hdu 6156 回文数 数位dp
zxl博客
09-07 421
题意：k进制下的回文个数。。其实就是普通的。。稍加修改 思路：老题，直接枚举L进制--R进制 代码： #include using namespace std; #define MEM(a,b) memset(a,b,sizeof(a)) #define bug puts("bug"); #define PB push_back #define MP make_pair #define X
数位DP - 带3的数
CSDN
12-01 4305
带3的数，数位DP
蓝桥杯每日一题-----数位dp
最新发布
qq_53237241的博客
02-04 1187
今天浅谈一下数位dp的板子，我最初接触到数位dp的时候，感觉数位dp老难了，一直不敢写，最近重新看了一些数位dp，发现没有想象中那么难，把板子搞会了，变通也会变的灵活的多！
【算法】力扣【动态规划、数位DP模板题】233. 数字 1 的个数
未来就在脚下。
01-17 1343
本文详细解析了力扣233题“数字 1 的个数”，使用数位DP不仅可以高效解决问题，同时也能够提升算法设计的灵活性和应用范围。在处理大量数据且关注数位特征的算法问题时，数位DP无疑是一个强大的工具。通过递归和记忆化搜索的手段，我们能够避免重复计算，从而大幅降低时间复杂度。
P3413 SAC#1 - 萌数【数位DP+回文数】
王小二的博客
10-24 460
题目描述 只有满足“存在长度至少为2的回文子串”的数是萌的——也就是说，101是萌的，因为101本身就是一个回文数；110是萌的，因为包含回文子串11；但是102不是萌的，1201也不是萌的。 现在SOL想知道从l到r的所有整数中有多少个萌数。 由于答案可能很大，所以只需要输出答案对1000000007（10^9+7）的余数。 输入格式： 输入包含仅1行，包含两个整数：l、r。 输出格式： 输出仅...
Lightoj1205——Palindromic Numbers（数位dp+回文数）
Beyond the Sora
09-26 2088
A palindromic number or numeral palindrome is a ‘symmetrical’ number like 16461 that remains the same when its digits are reversed. In this problem you will be given two integers i j, you have to find
数位dp判断1-m，有多少回文数
qq_40859951的博客
09-12 587
A palindromic number or numeral palindrome is a 'symmetrical' number like 16461 that remains the same when its digits are reversed. In this problem you will be given two integers i j, you have to find...
数位DP讲解
热门推荐
zhangxian___的博客
07-18 1万+
转载自：http://www.cnblogs.com/itlqs/p/5935308.html 数位DP其实是很灵活的，所以一定不要奢求一篇文章就会遍所有数位DP的题，这一篇只能是讲清楚一种情况，其他情况遇到再总结，在不断总结中慢慢体会这个思想，以后说不定就能达到一看到题目就能灵活运用的水平。（其实DP都是这样……）   这一篇要说的数位DP是一道最简单的数位DP：htt
LightOJ 1205 Palindromic Numbers（数位DP 回文数）
pxlsdz的博客
09-14 521
Description  求[a,b]中回文数的个数 Input  第一行为用例组数t，之后t行每行两个整数a和b表示查询区间端点 Output  对于每组用例，输出区间[a,b]中回文数的个数 Sample Input  4  1 10  100 1  1 1000  1 10000 Sample Output  Case 1: 9  Case 2: 18  Case 3: 108  Case ...
LightOJ - 1205 Palindromic Numbers（回文数个数，数位DP）
LP_Cong
10-11 735
A palindromic number or numeral palindrome is a 'symmetrical' number like 16461 that remains the same when its digits are reversed. In this problem you will be given two integers i j, you have to find
HDU - 6156 数位dp求k进制下回文串的个数
qq965194745的博客
08-20 586
用数位DP求k进制的回文串个数
LightOJ - 1032 Fast Bit Calculations(数位DP/ 递推)
eddddd’ world
08-21 462
A bit is a binary digit, taking a logical value of either 1 or 0 (also referred to as “true” or “false” respectively). And every decimal number has a binary representation which is actually a series of
LC第225场周赛A拓展-递推版数位dp
qq_35577488的博客
02-01 185
题目大意： 令f(i)f(i)f(i)为iii的数位和，问你一个区间[L,R][L,R][L,R]中f(i)f(i)f(i)出现最多的f(i)f(i)f(i)是多少，若有多解，输出任何一个. 1≤L≤R≤1e181 \leq L \leq R \leq 1e181≤L≤R≤1e18 题目思路: 由于范围太大，肯定是数位dp了。但是发现套数位dp模板并不好用。 ①一种暴力的套模板方法： 按照套路: dp状态为(前缀长度,前缀数位和,是否顶到L,是否顶到R)dp状态为(前缀长度,前缀数位和,是否顶到L,是否顶到
数位DP入门解析与应用实例
"数位DP入门PPT的参考文献和相关问题解析" 数位DP，全称为数字动态规划（Digital Dynamic Programming），是一种在处理与数字相关的动态规划问题时使用的技巧。它通常涉及到对数字的每一位进行操作，通过预处理和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值