数位DP总结+例题

数位DP详解与实战
最新推荐文章于 2025-08-20 12:30:00 发布
原创 最新推荐文章于 2025-08-20 12:30:00 发布 · 1.2k 阅读 · 14 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

学了数位DP很久了，今天就简单的总结一下吧。

一、什么是数位DP

  数位DP简单来说是一种统计数的DP，该类题一般可以用暴力写出来，但是由于数据太大，一般会超时。数位DP一般是统计[l,r]中满足题中要求的数的个数，至于为什么称为数位DP，因为要对数的每一位进行讨论（个位，十位，百位……）。数位DP一般有两种写法，一种是循环，另一种是递归。通常用循环写，比较的麻烦，所以我们一般都是用递归来写。

二、数位DP的常规写法

  数位DP一般用来统计一段区间中满足题意数的个数，例如区间[l,r]，而我们一般计算两个区间的值[0,l],[0,r]，然后再相减。所以主函数我们一般的写法为：

    int l,r;
    while(scanf("%d%d",&l,&r)&&l+n)
    {
        printf("%d\n",solve(r)-solve(l-1));
    }
    ///统计[l,r]区间中满足题意数的个数

然后就是要对数的每一位进行分解，分解后用一个数组保存，方便我们后期的使用：

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

最后就是数位DP的核心代码了，一般都可以把这个当做模板来使用，只需要根据题中的意思来改一些地方就可以了。

int dfs(int pos,/*当前讨论位数*/,bool lead/*前导零*/,bool limit/*数位上界变量*/)//不是每个题都要判断前导零
{
    
    if(pos==-1)///递归边界，既然是按位枚举，最低位是0，那么pos==-1说明这个数我枚举完了
        return 1;/*这里一般返回1，表示你枚举的这个数是合法的，那么这里就需要你在枚举时必须每一位都要满足题目条件，也就是说当前枚举到pos位，
        前面的数都是合法的，不过返回值还要看题目要求，后面例题里会体现出来*/
    if(!limit && !lead && dp[pos]!=-1)///第二个就是记忆化(在此前可能不同题目还能有一些剪枝)
        return dp[pos];
    int End=limit?a[pos]:9;//根据limit判断枚举的上界End;
    int ans=0;
    //开始计数
    for(int i=0; i<=End; i++) ///枚举，然后把不同情况的个数加到ans就可以了
    {
        if()///里面的选择判断要根据题中要求来判断
            ...
        else if()
            ...
        ans+=dfs(pos-1,/*状态转移*/,lead && i==0,limit && i==End)//最后两个变量传参都是这样写的
    }
    if(!limit && !lead)///这里对应上面的记忆化，在一定条件下时记录，保证一致性.
        dp[pos]=ans;
    return ans;
}

总体代码：

int a[20];
int dp[20];//不同题目状态不同
int dfs(int pos,/*当前讨论位数*/,bool lead/*前导零*/,bool limit/*数位上界变量*/)//不是每个题都要判断前导零
{
    
    if(pos==-1)///递归边界，既然是按位枚举，最低位是0，那么pos==-1说明这个数我枚举完了
        return 1;/*这里一般返回1，表示你枚举的这个数是合法的，那么这里就需要你在枚举时必须每一位都要满足题目条件，也就是说当前枚举到pos位，
        前面的数都是合法的，不过返回值还要看题目要求，后面例题里会体现出来*/
    if(!limit && !lead && dp[pos]!=-1)///第二个就是记忆化(在此前可能不同题目还能有一些剪枝)
        return dp[pos];
    int End=limit?a[pos]:9;//根据limit判断枚举的上界End;
    int ans=0;
    for(int i=0; i<=End; i++) ///枚举，然后把不同情况的个数加到ans就可以了
    {
        if()///里面的选择判断要根据题中要求来判断
            ...
        else if()
            ...
        ans+=dfs(pos-1,/*状态转移*/,lead && i==0,limit && i==End)//最后两个变量传参都是这样写的
    }
    if(!limit && !lead)///这里对应上面的记忆化，在一定条件下时记录，保证一致性.
        dp[pos]=ans;
    return ans;
}
int solve(int x)
{
    int pos=0;
    while(x)//把数位都分解出来
    {
        a[pos++]=x%10;//个人老是喜欢编号为[0,pos),看不惯的就按自己习惯来，反正注意数位边界就行
        x/=10;
    }
    return dfs(pos-1/*从最高位开始枚举*/,1,1);//刚开始最高位都是有限制并且有前导零的，显然比最高位还要高的一位视为0嘛
}
int main()
{
    int l,r;
	memset(dp,-1,sizeof(dp));
    while(~scanf("%d%d",&l,&r))
    {
        printf("%d\n",solve(r)-solve(l-1));
    }
    return 0;
}

 

三、代码里的一些注意点

1,为什么要记忆化：

    if(!limit && !lead && dp[pos]!=-1)///第二个就是记忆化(在此前可能不同题目还能有一些剪枝)
        return dp[pos];
    if(!limit && !lead)///这里对应上面的记忆化，在一定条件下时记录，保证一致性.
        dp[pos]=ans;

我们就以HDU2089 不要62来讨论，题意是数字中不能出现数字4和62（6和2没有连在一起满足条件）。现在dp[pos],表示的是pos位数的数字里面有多少满足条件，我们讨论[0,256].首先我们百位为0，递归下去讨论十位,limit=0。当十位讨论到5时。递归下去讨论个位limit=0，肯定除了54以为都满足条件，所以在讨论十位为5时，dp[1]加了9，但是当百位讨论到2，十位讨论到5时，dp[1]已经有值了，现在limit是等于1的，要是现在我们不判断（!limit）这个条件，就会直接返回dp[1]，但是我们只讨论到256，所以跟题意不符，所以在返回判断那里要判断limit。（可以说的不是太清楚，自己模拟一下就比较好懂）。

2.枚举上限End的确定和limit的传参：

    int End=limit?a[pos]:9;//根据limit判断枚举的上界End;
    ans+=dfs(pos-1,/*状态转移*/,lead && i==0,limit && i==a[pos])//最后两个变量传参都是这样写的

还是讨论[0,256]。中满足的数，我们首先第一次递归传参limit为1（可以看solve函数），然后End等于2，后面递归limit传参都为（limit && i==End），当百位上讨论0-1时，limit传参下去为0，十位都能讨论到0-9，因为0-99,100-199都小于256。当百位讨论到2是，limit传参下去为1，十位只能讨论到5，个位的道理是一样的。

四、例题和题解：

HDU2089不要62

HDU4734 F(x)

POJ 3252 Round Numbers

HDU3709 Balanced Number

HDU4507 吉哥系列故事——恨7不成妻（比较难的数位DP）

         2019长安大学ACM校赛-XOR

HDU2089不要62

题意：就是计算一段区间里，数字里没有出现4和62的数字的个数。

题解：这是数位DP的一个入门题吧，改一下模板就能过，细节看代码：

#include <iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<map>
#include<queue>
#include<set>
#include<cmath>
#include<stack>
#include<string>
const int maxn=5e2+10;
const int mod=1e9+7;
const int inf=1e8;
#define me(a,b) memset(a,b,sizeof(a))
#define lowbit(x) x&(-x)
#define mid (l+r)/2
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
#define PI 3.14159265358979323846
int dir[4][2]= {0,-1,-1,0,0,1,1,0};
typedef long long ll;
using namespace std;
int d[10],dp[30];
int dfs(int pos,int x,int lit)
{
    if(pos==-1)///所有数枚举完了，当前数数字肯定满足条件，直接返回1
        return 1;
    if(!lit&&dp[pos]==-1)
        return dp[pos];
    int End=lit?d[pos]:9;
    int ans=0;
    for(int i=0;i<=End;i++)
    {
        if(i==4)///出现4跳过
            continue ;
        else if(x==6&&i==2)///x为该数字的上一位，要是出现62，直接跳过
            continue ;
        else
            ans+=dfs(pos-1,i,lit&&i==End);
    }
    if(!lit)
        dp[pos]=ans;
    return ans;
}
int solve(int n)
{
    int len=0;
    while(n)
    {
        d[len++]=n%10;
        n/=10;
    }
    return dfs(len-1,0,1);
}
int main()
{
    int m,n;
    while(scanf("%d%d",&m,&n)&&m+n)
    {
        printf("%d\n",solve(n)-solve(m-1));
    }
    return 0;
}

 

HDU4734 F(x)

题意：给出两个数a,b F(x) = An * 2n-1 + An-1 * 2n-2 + ... + A2 * 2 + A1 * 1，将a的通过这样算出来算出来，然后计算0-b里面有多少数通过这个公式算出来的值小于等于a算出来的值。

题解：首先通过这个公式将a对应的值算出来，然后每次减去在枚举0-b中的数的每一位转化出来的值，然后看最后的值，要是最后的值大于等于0，说明当前数满足条件，更多细节看代码。

#include <iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<map>
#include<queue>
#include<set>
#include<cmath>
#include<stack>
#include<string>
const int maxn=1e5+10;
const int mod=100000000;
const int inf=1e8;
#define me(a,b) memset(a,b,sizeof(a))
#define lowbit(x) x&(-x)
typedef long long ll;
using namespace std;
int d[30],dp[20][maxn],er[30];
void init()
{
    er[0]=1;///er[i]=2^i
    for(int i=1; i<30; i++)
        er[i]=er[i-1]*2;
}
int dfs(int pos,int sum,int lit)
{
    if(sum<0)///要是sum小于0，说明该数不满足条件，直接返回0
        return 0;
    if(pos==-1)///要是枚举到最后一位，判断当前sum是否大于0，大于等于0，返回1，反之返回0
        return sum>=0;
    if(!lit&&dp[pos][sum]!=-1)
        return dp[pos][sum];
    int ans=0;
    int End=lit?d[pos]:9;
    for(int i=0; i<=End; i++)
        ans+=dfs(pos-1,sum-i*er[pos],lit&&i==End);///sum-i*er[pos]，每次减去当前数转化的值
    if(!lit)
        dp[pos][sum]=ans;
    return ans;
}
int inct(int m)///算出a通过式子转化出来的值。
{

    int td[30],len=0,opt=0;
    while(m)
    {
        td[len++]=m%10;
        m/=10;
    }
    for(int i=0; i<len; i++)
        opt+=td[i]*er[i];
    return opt;
}
int solve(int a,int b)
{
    int len=0;
    while(b)
    {
        d[len++]=b%10;
        b/=10;
    }
    return dfs(len-1,inct(a),1);
}
int main()
{
    int t,Case=1;
    scanf("%d",&t);
    init();
    me(dp,-1);
    while(t--)
    {
        int a,b;
        scanf("%d%d",&a,&b);
        printf("Case #%d: %d\n",Case++,solve(a,b));
    }
    return 0;
}

 

POJ 3252 Round Numbers

题意：一个十进制数化成2进制，要是二进制数里0的个数大于1的个数称为圆数，现在给出一个区间，问里面有多少圆数。

题解：与其他题不同，这个题是要化成二进制，我们不需要计算该数中0和1的个数到底有多少个，而是只需要计算两个的差值是否大于等于0，声明一个二维数组dp[pos][sum],表示pos位数，0和1个数差值为sum的数有多少个。因为这两个数的差值是dp数组的其中一个参数，所以sum要一直大于等于0。所以提前将sum提前赋一个初值，避免sum小于0，最后直接判断sum是否大于等于赋的初值，需要注意这个题得判断前置0，相信大家应该能理解为啥要判断前置0，更多细节看代码。

#include <iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<map>
#include<queue>
#include<set>
#include<cmath>
#include<stack>
#include<string>
const int maxn=1e5+10;
const int mod=998244353;
const int inf=1e8;
#define me(a,b) memset(a,b,sizeof(a))
#define lowbit(x) x&(-x)
typedef long long ll;
using namespace std;
int d[50],dp[50][100];
int dfs(int pos,int sum,int lead,int lit)
{
    if(pos==0)
        return sum>=50;///判断0的个数是否大于1的个数
    if(!lead&&!lit&&dp[pos][sum]!=-1)
        return dp[pos][sum];
    int ans=0;
    int End=lit?d[pos]:1;///注意端点
    for(int i=0;i<=End;i++)
    {
        if(i==0)
        {
            if(lead)///要是前一个数字为0，而当前数也为0时，sum值不变，例如00101，前两个0都不能算
                ans+=dfs(pos-1,sum,1,lit&&i==End);
            else
                ans+=dfs(pos-1,sum+1,0,lit&&i==End);///没有前置0，当前为0，sum+1
        }
        else
            ans+=dfs(pos-1,sum-1,0,lit&&i==End);///当前数为1，sum-1
    }
    if(!lit&&!lead)
        dp[pos][sum]=ans;
    return ans;
}
int solve(int n)
{
    int len=0;
    while(n)
    {
        d[++len]=n%2;
        n/=2;
    }
    return dfs(len,50,1,1);///sum初值为50，避免sum小于0
}
int main()
{
    int n,m;
    me(dp,-1);
    while(scanf("%d%d",&m,&n)!=EOF)
    {
        printf("%d\n",solve(n)-solve(m-1));
    }
    return 0;
}

 

HDU3709 Balanced Number

题意：一个十进制数，以其中一位为支点，其两边的位数上的数乘以该位数离支点的距离的和是否相等，要是两边这样算出的值相等则为一个平衡数，现在给出一个区间，问里面有多少平衡数。

题解：一个数，分解过后，枚举每一位当支点，然后把每一个当支点能有的多少个数，再将所有情况加起来。声明一个三维dp数组dp[pos][x][sum]，表示pos位数以第x位位支点，两边差值为sum的数有多少个，然后就是常规的模板了，细节看代码。

#include <iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<map>
#include<queue>
#include<set>
#include<cmath>
#include<stack>
#include<string>
const int maxn=1e4+10;
const int mod=998244353;
const int inf=1e8;
#define me(a,b) memset(a,b,sizeof(a))
#define lowbit(x) x&(-x)
typedef long long ll;
using namespace std;
int d[20];
ll dp[20][20][maxn];
ll dfs(int pos,int x,int sum,int lit)
{
    if(pos==0)
        return sum==0;///sum为两边的差值，要是sum等于0，该数为平衡数
    if(sum<0)///因为是左边的数减右边数，要是sum小于0了，当前数肯定不是平衡数
        return 0;
    if(!lit&&dp[pos][x][sum]!=-1)
        return dp[pos][x][sum];
    ll ans=0;
    int End=lit?d[pos]:9;
    for(int i=0;i<=End;i++)
        ans+=dfs(pos-1,x,sum+(pos-x)*i,lit&&i==End);///(pos-x)*i,因为从高位开始，高于x的位数，都为正，小于都为负。这里的写法比较巧妙，大家可以思考下。
    if(!lit)
        dp[pos][x][sum]=ans;
    return ans;
}
ll solve(ll n)
{
    ll ans=0,len=0;
    while(n)
    {
        d[++len]=n%10;
        n/=10;
    }
    for(int i=1;i<=len;i++)
        ans+=dfs(len,i,0,1);
    return ans-len+1;///这里要减去0,00,000……的情况
}
int main()
{

    int t;
    scanf("%d",&t);
    me(dp,-1);
    while(t--)
    {
        ll n,m;
        scanf("%lld%lld",&m,&n);
        printf("%lld\n",solve(n)-solve(m-1));
    }
    return 0;
}

 

HDU4507 吉哥系列故事——恨7不成妻（比较难的数位DP）

题意+题解：传送门

 

2019长安大学ACM校赛-XOR

题意：给出区间[l,r]，让你找出有多少x，满足。

题解：

通过这个式子得到，我们只需要找出在二进制下，某位数与左边两位数不同数的个数，更多看代码。

#pragma comment(linker, "/STACK:102400000,102400000")
#include <iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<map>
#include<queue>
#include<set>
#include<cmath>
#include<stack>
#include<string>

const int mod = 998244353;
const int maxn = 1e5 + 5;
const int inf = 1e9;
const long long onf = 1e18;
#define me(a, b) memset(a,b,sizeof(a))
#define lowbit(x) x&(-x)
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
#define PI 3.14159265358979323846
typedef long long ll;
typedef unsigned long long ull;
using namespace std;
int a[100];
ll dp[80][2][2];
ll dfs(int pos,int sta_2,int sta_1,bool limit){///sta_2保存该位左边2位的数字，sta_1保存该位左边1位的数字
    if(pos==-1)
        return 1;
    if(!limit&&dp[pos][sta_2][sta_1]!=-1)
        return dp[pos][sta_2][sta_1];
    int End=limit?a[pos]:1;
    ll sum=0;
    for(int i=0;i<=End;i++){
        if(i&sta_2)
            continue ;
        sum+=dfs(pos-1,sta_1,i,i==End&&limit);
    }
    if(!limit)
        dp[pos][sta_2][sta_1]=sum;
    return sum;
}
ll solve(ll x){
    int len=0;
    while(x){
        a[len++]=x%2;
        x/=2;
    }
    return dfs(len-1,0,0,1);
}
int main() {
    int t;
    me(dp,-1);
    scanf("%d",&t);
    while(t--){
        ll l,r;
        scanf("%lld%lld",&l,&r);
        printf("%lld\n",solve(r)-solve(l-1));
    }
    return 0;
}

以上都是本人对于数位DP的理解，要是有大佬有更好的做法，希望不吝赐教。

夜深人静写算法（二十九）- 数位DP
英雄哪里出来
02-08 9247
动态规划进阶，她来了！
数位DP(预处理, 倍增的拼凑思想, 试填法 或者 记忆化搜索)
CK1513710764的博客
04-06 679
数位DP是一种特殊的计数DP, 与数字统计有关,一般求满足限制条件的第K小的数是多少,或者求在区间[L, R]内有多少满足条件的数字. 解决方法:先用动态规划进行预处理,基于"拼凑"思想,用"试填法"求出最终的答案. (动态规划预处理部分的作用充当记忆作用,事实上这就是动态规划的本质) 例题一: 直接从前向后枚举答案的每一位数(从小到大枚举)是多少,计算在这样的前缀下,后面的总排列数,如果加起来大于等于C, 说明当前的一位数就是这个枚举的数,我们继续讨论下一位即可. 我们先用动态规划预处理出木
数位dp(算法篇)
hellmorning的博客
09-23 3378
数位dp也就是将动态规划的思想放入到对数的每一位进行，也是一种动态规划的一种，本篇文章将会带大家简单学习一下
数位DP 详解及其案例实战 [模板+技巧+案例]
weixin_45532984的博客
03-24 2392
DP的本质：DFS+记忆化搜索(可选项)+约束(可选项) 数位DP简单介绍 数位DP的本质 数位DP在实际使用面临什么难点 数位DP典型模板和技巧 leetcode233数字 1 的个数 leetcode 2376 统计特殊整数 leetcode1012 至少有 1 位重复的数字
数位DP详解
最新发布
08-20 1286
数位DP（Digit Dynamic Programming）是一种专门解决“数字计数问题”的动态规划方法，尤其适用于处理“小于等于N的数中满足某条件的数有多少个”这类问题。由于数字的位数通常不超过20位，数位DP能通过状态压缩将看似复杂的计数问题转化为高效的DP求解。
数位DP
K键盘里的青春K
10-24 3017
基础篇 数位dp是一种计数用的dp，一般就是要统计一个区间[le,ri]内满足一些条件数的个数。所谓数位dp，字面意思就是在数位上进行dp咯。数位还算是比较好听的名字，数位的含义：一个数有个位、十位、百位、千位......数的每一位就是数位啦！ 之所以要引入数位的概念完全就是为了dp。数位dp的实质就是换一种暴力枚举的方式，使得新的枚举方式满足dp的性质，然后记忆化就可以了。
数位dp总结 之 从入门到模板
热门推荐
努力
08-03 7万+
for(int i=le;i<=ri;i++) if(right(i)) ans++; 基础篇 数位dp是一种计数用的dp，一般就是要统计一个区间[le,ri]内满足一些条件数的个数。所谓数位dp，字面意思就是在数位上进行dp咯。数位还算是比较好听的名字，数位的含义：一个数有个位、十位、百位、千位......数的每一位就是数位啦！ 之所以要引入数位的概念完全就是为了dp。
数位DP小结
琪露诺
07-12 2022
数位DP：一般是求小于等于数字N的某些特征数字个数，或者是区间[L,R]的之间的某些特征数字个数，后者一般可以转换成求差的方式来做。
模板
DrWells的博客
08-31 444
快速读入 fread namespace fastIO { #define BUF_SIZE 100000 bool IOerror = 0; inline char nc() { static char buf[BUF_SIZE], *p1 = buf + BUF_SIZE, *pend = buf + BUF_SIZE; if(p1 ==
数位DP(包含例题和模板)
m0_51678367的博客
11-23 643
如上题所示意: f®-f(l-1)就是答案. 那么f(n)要怎么求呢? 先把n分解为m进制的l位.那么对于第i位来说,就只有0或者1,因为题目里面没有系数.如181818=242^424+212^121.而没有282828=242^424+3∗223*2^23∗22. 从最高位到最低位,那么对于第i位来说如果第i位>1那么第i位可以是0(组合数学,第i位下面的i-1位可以填k-last(已经填了的1的个数)个1,即C[i-1][k-last] (下标从1开始,若是从零开始就是C[i][k-last..
蓝桥杯每日一题-----数位dp
qq_53237241的博客
02-04 1193
今天浅谈一下数位dp的板子，我最初接触到数位dp的时候，感觉数位dp老难了，一直不敢写，最近重新看了一些数位dp，发现没有想象中那么难，把板子搞会了，变通也会变的灵活的多！
`算法知识` 数位DP
WChang的博客
08-25 370
1
数位dp详解及模板
weixin_30633405的博客
08-03 794
数位dp一般应用于： 求出在给定区间[A,B][A,B]内，符合条件P(i)P(i)的数ii的个数.条件P(i)P(i)一般与数的大小无关，而与 数的组成有关. 比如说在HDU2089中， 让求区间内数中不有4和62的数字个数之和 对于此类问题，我们一般设dpdp数组dp[i][j]dp[i][j]，表示i位数，最高位是j的数，不含有62和4的...
数位dp
xueyingyexiao的博客
07-06 270
数位dp 通用解法是一种叫做记忆化搜索的东西 他是一种能够优化搜索的 在dp题中常常考虑暴力做法 但是时间复杂度不够优秀 所以往往把搜过的数记录下来 以便3以后再用 不要62 数位dp入门题 我们可以用dp[i][j] 表示状态发现 dp【i】【j】=西格玛 i-11-k k！=4或者62之流 但是我们发现假如k！=6 都一样 所以我们就 qwq楼 开dp【41】【2】 表示的是dp【i】【是否为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值