本文通过一道题目介绍数位动态规划的概念，并提供数位DP的解题思路和代码示例。文章详细解析了数位DP在不同问题中的应用，包括处理二进制中0和1的个数、平衡数问题等，帮助读者深入理解数位DP的精髓。
先看一道题目：
不要62
Time Limit: 1000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 59667 Accepted Submission(s): 23557
Problem Description
杭州人称那些傻乎乎粘嗒嗒的人为62（音：laoer）。
杭州交通管理局经常会扩充一些的士车牌照，新近出来一个好消息，以后上牌照，不再含有不吉利的数字了，这样一来，就可以消除个别的士司机和乘客的心理障碍，更安全地服务大众。
不吉利的数字为所有含有4或62的号码。例如：
62315 73418 88914
都属于不吉利号码。但是，61152虽然含有6和2，但不是62连号，所以不属于不吉利数字之列。
你的任务是，对于每次给出的一个牌照区间号，推断出交管局今次又要实际上给多少辆新的士车上牌照了。
Input
输入的都是整数对n、m（0<n≤m<1000000），如果遇到都是0的整数对，则输入结束。
Output
对于每个整数对，输出一个不含有不吉利数字的统计个数，该数值占一行位置。
Sample Input
1 100 0 0
Sample Output
80
Author
qianneng
Source
打表的代码：
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#include<string.h>
#include<vector>
#include<algorithm>
//#include<windows.h>
#include<iostream>
using namespace std;
int a[1000000]={0};
bool jili(int x)
{
int s[10]={0};
int i=0;
while(x)
{
s[i]=x%10;
if(4==s[i])return false;
i++;
x/=10;
}
i--;
while(i>0)
{
if(6==s[i]&&2==s[i-1])return false;
i--;
}
return true;
}
int main()
{
int n,m,num,i;
for(i=4;i<1000000;i++)
if(jili(i)==false)a[i]=1;
do{
scanf("%d %d",&n,&m);
if(0==n&&0==m)break;
num=0;
for(;n<=m;n++)
if(!a[n])num++;
printf("%d\n",num);
}while(true);
return 0;
}理解了大概的思路后，再看一下数位dp的解法：（来自https://blog.youkuaiyun.com/tigerisland45/article/details/82012434）
/* HDU2089 不要62 */
#include <bits/stdc++.h>
using namespace std;
const int N = 20; // 位数，int类型不超过10位
const int D = 10; // 10进制数字的个数
int digits[N + 1];
int dp[N][D]; // dp[i][d]-共i位，前导为数字d的满足条件（不含62和4）数的数量
/*
* 参数：
* pos - 数位位置，即当前处理数的第几位，从高位开始
* pre - 前导，即前一位数字
* limit - 是否为数位上界（最大数字）
*/
int dfs(int pos, int pre, bool limit)
{
if(pos == -1) // 递归边界，已经枚举结束，则1个数满足条件
return 1;
/*if(!limit && dp[pos][pre] != -1) // 已经搜索过的不再搜索，直接使用之前的计算结果
*/
// 计数
int ans = 0;
int maxd = limit ? digits[pos] : 9; // 枚举数字，如果数字不同则枚举0-9
for(int i = 0; i <= maxd; i++) {
if(i == 4 || (pre == 6 && i == 2))
;
else
ans += dfs(pos - 1, i, limit && i == digits[pos]);
}
/*if(!limit)
dp[pos][pre] = ans;*/
return ans;
}
// 计算[0,n]中不含62和4数的数量
int solve(int n)
{
int len = 0;
while(n) {
digits[len++] = n % 10;
n /= 10;
}
return dfs(len - 1, 0, 1);
}
int main()
{
memset(dp, -1, sizeof(dp));
int n, m;
while(~scanf("%d%d", &n, &m) && (n || m))
printf("%d\n", solve(m) - solve(n - 1));
return 0;
}
接下来再看一看比较全面的数位dp的讲解------->>>> Here
typedef long long ll;
int a[20];
ll dp[20][state];//不同题目状态不同
ll dfs(int pos,/*state变量*/,bool lead/*前导零*/,bool limit/*数位上界变量*/)//不是每个题都要判断前导零
{
//递归边界，既然是按位枚举，最低位是0，那么pos==-1说明这个数我枚举完了
if(pos==-1) return 1;/*这里一般返回1，表示你枚举的这个数是合法的，那么这里就需要你在枚举时必须
每一位都要满足题目条件，也就是说当前枚举到pos位，一定要保证前面已经枚举的
数位是合法的。不过具体题目不同或者写法不同的话不一定要返回1 */
//第二个就是记忆化(在此前可能不同题目还能有一些剪枝)
if(!limit && !lead && dp[pos][state]!=-1) return dp[pos][state];
/*常规写法都是在没有限制的条件记忆化，这里与下面记录状态是对应，具体为什么是有条件的记忆化后面会讲*/
int up=limit?a[pos]:9;//根据limit判断枚举的上界up;这个的例子前面用213讲过了
ll ans=0;
//开始计数
for(int i=0;i<=up;i++)//枚举，然后把不同情况的个数加到ans就可以了
{
if() ...
else if()...
ans+=dfs(pos-1,/*状态转移*/,lead && i==0,limit && i==a[pos]) //最后两个变量传参都是这样写的
/*这里还算比较灵活，不过做几个题就觉得这里也是套路了
大概就是说，我当前数位枚举的数是i，然后根据题目的约束条件分类讨论
去计算不同情况下的个数，还有要根据state变量来保证i的合法性，比如题目
要求数位上不能有62连续出现,那么就是state就是要保存前一位pre,然后分类，
前一位如果是6那么这意味就不能是2，这里一定要保存枚举的这个数是合法*/
}
//计算完，记录状态
if(!limit && !lead) dp[pos][state]=ans;
/*这里对应上面的记忆化，在一定条件下时记录，保证一致性，当然如果约束条
件不需要考虑lead，这里就是lead就完全不用考虑了*/
return ans;
}
ll solve(ll x)
{
int pos=0;
while(x)//把数位都分解出来
{
a[pos++]=x%10;//个人老是喜欢编号为[0,pos),看不惯的就按自己习惯来，反正注意数位边界就行
x/=10;
}
return dfs(pos-1/*从最高位开始枚举*/,/*一系列状态 */,true,true);//刚开始最高位都是有限制并
且有前导零的，显然比最高位还要高的一位视为0嘛
}
int main()
{
ll le,ri;
while(~scanf("%lld%lld",&le,&ri))
{
//初始化dp数组为-1,这里还有更加优美的优化,后面讲
printf("%lld\n",solve(ri)-solve(le-1));
}
}
练习的题目可见Here
训练题
题意：求A到B间的数，表示成二进制后，其二进制0的个数大于1的个数的数有多少个
问题分析：数位dp题，要注意前导0和 三维dp
AC的c++语言程序如下：
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cmath>
#include <cstring>
using namespace std;
#define ll long long
#define INF 0x3f3f3f3f
int digits[40];
ll dp[40][40][40];
int len;
/*变量
sum - 最高位到pos位，sum=1的个数
len - 总位数
cnt - pos为如果为0的话，判断这个0是否是前导0，初始时为0
*/
ll dfs(int pos,int sum0,int sum1,bool limit,int cnt)
{
if(pos==-1)
{
if(sum0>=sum1) return 1;
else return 0;
}
if(!limit&&dp[pos][sum0][sum1]!=-1) return dp[pos][sum0][sum1];
int up=limit?digits[pos]:1;
ll ans=0;
for(int i=0;i<=up;i++)
{
if(i==1)
ans+=dfs(pos-1,sum0,sum1+1,limit&&i==digits[pos],cnt||i!=0);
else
{
if(cnt) //pos位前面有1
ans+=dfs(pos-1,sum0+1,sum1,limit&&i==digits[pos],cnt);
else //否则，sum0不加1
ans+=dfs(pos-1,sum0,sum1,limit&&i==digits[pos],cnt);
}
}
if(!limit)
dp[pos][sum0][sum1]=ans;
return ans;
}
ll solve(ll n)//转换成二进制
{
len=0;
while(n)
{
if(n&1) digits[len++]=1;
else digits[len++]=0;
n/=2;
}
return dfs(len-1,0,0,true,0);
}
int main()
{
memset(dp,-1,sizeof(dp));
ll start, finish;
while(~scanf("%lld%lld",&start, &finish)){
printf("%lld\n",solve(finish)-solve(start-1));
}
return 0;
}题目：hdu 3709 平衡数(数位好ti）
分析：
①用for循环将每一个数位为轴的情况遍历一遍
②三维数组dp，三个变量pos，pivot轴，sum力矩和
自己还是没有理解其中的精髓啊
代码：
#include <iostream>
#include <cstdio>
#include <cstring>
#define ll long long
using namespace std;
ll dp[20][20][1800];
int digit[20];
//pos 指数位，pivot指轴位，sum=sum+数*数到轴的距离(分正负)
ll dfs(int pos, int pivot, int sum, int limit)
{
if(pos==-1)
return sum == 0;
if(sum < 0) return 0; // 如果sum小于0，说明pos已经比pivot小了，再往下，pos是减小的，sum只会减小
if(!limit&&dp[pos][pivot][sum]!=-1) return dp[pos][pivot][sum];
int up = limit ? digit[pos] : 9;
ll ans = 0;
for(int i = 0; i <= up; i++)
ans+=dfs(pos-1, pivot, sum + i * (pos-pivot), limit && i==digit[pos]);
if(!limit) dp[pos][pivot][sum] = ans;
return ans;
}
ll solve(ll x)
{
if(x <0) return 0;
int len = 0;
while(x)
{
digit[len++] = x%10;
x/=10;
}
//这里用for循环将每一个数位为轴的情况遍历一遍
ll ans =0;
for(int i = 0; i < len; i++)
{
ans=(ans + dfs(len-1,i,0,1));
}
return ans - (len -1); //0被计数了len次，故减去len-1
}
int main()
{
int t;
ll a, b;
memset(dp, -1, sizeof(dp));
cin >> t;
while(t--)
{
scanf("%lld%lld", &a, &b);
cout << solve( b) -solve(a-1) << endl;
}
return 0;
}
题目：51nod 1043 幸运号码
这题开始还套用上面的模板，思维僵化啊
#include <iostream>
#include <cstdio>
#include <cstring>
#define ll long long
using namespace std;
const int mod = 1e9+7;
const int N = 1e3+100;
int n;
ll dp[2][9*N];//dp[i][j]表示i个数的和为j的总个数
int main()
{
memset(dp,0,sizeof(dp));
cin>>n;
for(int i=0;i<=9;i++)
dp[1][i] = 1;
for(int i =2;i<=n;i++)
{
for(int j=0;j<=9*i;j++)
{
ll sum = 0;
for(int k=0;k<=9;k++)
{
if(j<k) break;
sum=(sum+dp[(i-1)&1][j-k])%mod;
}
dp[i&1][j]=sum;
}
}
ll ans=0;
for(int i=1;i<=9*n;i++)//当i从0开始时，要将dp[0][0]设为1，这里面的缘由没太理解清楚
{
ans=(ans+(dp[n&1][i]-dp[(n-1)&1][i])*dp[n&1][i])%mod;
}
cout<<ans<<endl;
return 0;
}
题目：51nod 1042
1042 数字0-9的数量
- 1 秒
- 131,072 KB
- 10 分
- 2 级题
给出一段区间a-b，统计这个区间内0-9出现的次数。
比如 10-19，1出现11次（10,11,12,13,14,15,16,17,18,19,其中11包括2个1)，其余数字各出现1次。
收起
输入
两个数a,b（1 <= a <= b <= 10^18)输出
输出共10行，分别是0-9出现的次数输入样例
10 19输出样例
1
11
1
1
1
1
1
1
1
1
代码：c[i]数组存的是i数字的个数
（下面是ctrl c来的代码：：：为啥不是自己想的代码，而且注释又少的那么难看懂）
代码中dfs的自己的理解~ing：
以dfs（a:=128,b:=1,c[]）为例，b变量都是以1开始的（可以这样理解，b为1时，表示当前位是个位；为10的时候当前位是十位，以此类推）
代码中的①部分:这里就是将120,121,122.。。。128的个位上的0,1，。。。8都计到c[]数组里,③部分就是将这9个数的十位，百位上的数字计到数组里
代码中的②部分：这里就是将当前位前面的数，这里就是n=12,那么当前位（b=1时也就是个位）数字是0的有00,10,20,30,40，。。110（12个）；数字是1的有01,11,21，。。。111（12个）；一直到数字是9的。换一种方式排：00，01,02，。。09；10,11,12,。。19；20,21,...29;一直到110,111，....119./////这里b是1，所以③就是c[0]-=1,当b为10的时候，对应的10个数就是（当前位为零的，由于它的低位有0到9这十个）即00,01，。。。09十个。这东东理解都模模糊糊的_(¦3」∠)_
‘’、
#pragma comment(linker, "/STACK:10240000,10240000")
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <set>
using namespace std;
#define ll long long
#define INF 0x3f3f3f3f
const double pi = acos(-1.0);
const int N=1e5+10;
ll x[20], y[20];
void dfs(ll a, ll b, ll c[])
{
ll n=a/10,m=a%10,t=n;
for(int i=0;i<=m;i++) c[i]+=b; //---①
for(int i=0;i<10;i++) c[i]+=b*n; //----②高位对低位的影响
c[0]-=b;//将多算的0减去，特殊处理
while(t) //---③
{
c[t%10]+=b*(m+1);
t/=10;
}
if(n) dfs(n-1,b*10,c); //----n已经算过，
}
int main()
{
ll a, b;
cin>>a>>b;
dfs(a-1,1,x);
dfs(b,1,y);
for(int i=0;i<10;i++)
cout<<y[i]-x[i]<<endl;
return 0;
}
扫一扫
2431
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
