数位DP套路模板

最新推荐文章于 2024-07-16 18:11:29 发布
最新推荐文章于 2024-07-16 18:11:29 发布
阅读量132 收藏
点赞数
分类专栏： 题解 笔记 文章标签： 算法 动态规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xinnnnnyu/article/details/128237031
版权

数位DP

【介绍】

显然，是一种DP。

再显然，是一种关于每一位数字之间关系（性质）的DP

【题目特征】

题目描述一般是求【L，R】范围内满足各位数字间存在某种规律的数有几个

数位DP的题目数据范围往往很大，动不动就是1e18，但是由于是数位DP只跟位数有关，所以也就18位。

【算法设计】

使用记忆化搜索进行DP因为会出现重复出现的状态，使用记忆化搜索可以减少重复的搜索，减少复杂度。

一.记忆化搜索的过程

​ 从起点向下搜索，搜索的途中累加每一位的答案，最后在起点得到答案。

二. 区间转化为[0,X]

​ 对于[L,R]的区间问题，一般我们可以根据前缀和相减转化为[0,R] - [0,L-1]的问题。

三.dfs的参数

pos, 当前找到了第几位
limit，因为问题已经转化为了小于X的所有正整数中符合条件的个数，我们从高位枚举，一旦当前位小于X，那么后面数字可以随便选。limit就是判断当前位是否可以任意选。

递归中limit的传递

1.当前没有限制limit=0，那么显然后面应该都没限制，是0

2.当前有限制limit=1；

​ 1.如果当前位选的数小于X对应位数字，那么后面应该是没限制0

​ 2.如果当前位选的数恰好等于X对应位数字，这个分支相当于是紧贴着X的每一位（前面枚举到的位选的和X一样），那么后面还要限制数字大小，limit为1

综上：我们可以总结出limit的转移方程 limit = limit&&j==X[i] (X[i]是当前位能枚举得最大值, j是当前正在枚举得数)

3.**pre，**有些题目的性质是和前几位数字有关，那么也可以加上pre1…pre2

4.**zero，**判断是否有前导0，比如所有位相同的数包括000333（实质是333）前面都是0的话取1，否则取0

递归中zero前导零的传递

1.前一位是前导0

​ 1.当前位是0，那么后面还是zero还是1

​ 2.当前位不是0，那么后面zero=0

2.前一位不是前导0，那么不管当前位是不是0，后面zero都是1

综上：我们可以总结出zero的转移方程 zero = zero&&(!j) (X[i]是当前位能枚举得最大值, j是当前正在枚举得数)

四.记忆化搜索的记忆化

​ 我们可以用一个dp数组来记录已经确认的状态的值，下标用来表示状态，等到后面搜到相同状态时不用递归到最底层直接可以拿来复用。

五.模板
ll dfs(int pos,int pre,int st,……,int lead,int limit)//记忆化搜索
{
    if(pos>len) return st;//剪枝
    if((dp[pos][pre][st]……[……]!=-1&&(!limit)&&(!lead))) return dp[pos][pre][st]……[……];//相同状态，也可以吧limit和lead也放入dp数组中（多开两个维度）
    ll ret=0;//暂时记录当前方案数
    int res=limit?a[len-pos+1]:9;//res当前位能取到的最大值，limit的作用
    for(int i=0;i<=res;i++)//搜索每个可取的数
    {
        //有前导0并且当前位也是前导0
        if((!i)&&lead) ret+=dfs(……,……,……,i==res&&limit);
        //有前导0但当前位不是前导0，当前位就是最高位
        else if(i&&lead) ret+=dfs(……,……,……,i==res&&limit); 
        else if(根据题意而定的判断) ret+=dfs(……,……,……,i==res&&limit);
    }
    if(!limit&&!lead) dp[pos][pre][st]……[……]=ret;//没前导零，后面无限制，当前状态方案数记录
    return ret;
}
ll part(ll x)//把数按位拆分
{
    len=0;
    while(x) a[++len]=x%10,x/=10;
    memset(dp,-1,sizeof dp);//初始化-1（因为有可能某些情况下的方案数是0）
    return dfs(……,……,……,……);//进入记搜
}
int main()
{
    scanf("%d",&T);
    while(T--)
    {
        scanf("%lld%lld",&l,&r);
        if(l) printf("%lld",part(r)-part(l-1));//[l,r](l!=0)
        else printf("%lld",part(r)-part(l));//从0开始要特判
    }
    return 0;
}

​

【例题】

一般的数位DP套路题都是一个数满足什么性质，而这题是两个数满足一个性质就是与起来是0。那么我们类比一下，原来限制单个数后面取值的limit现在要有两个，而当前搜索的位置因为两个数位置总是同步的，所以只需要一个。因为两个数&起来等于0，那么他们相加是不进位的，又取了log，答案就是最高位的位置加1，所以每一位的贡献就是这位是最高位的数量乘以这位的位置+1.

#include<bits/stdc++.h>
using namespace std;


#define mem(a,b) memset(a,b,sizeof a)
#define PII pair<int,int>
#define ll long long
#define ull unsigned long long
#define fi first
#define se second
#define endl '\n'
#define PI acos(-1.0)
#define lcm(a,b) a/gcd(a,b)*b
#define INF 0x3f3f3f3f3f3f3f3f
#define debug(a) cerr<<#a<<"="<<a<<endl;
#define Adebug(a,i) cerr<<#a<<"["<<i<<"]="<<a[i]<<endl;
#define int long long
#define rep(i, a, b) for(int i = (a); i <= (b); i ++)
#define per(i, a, b) for(int i = (a); i >= (b); i --)
#define vi vector<int>
#define vpii vector<PII>
#define pb push_back
#define rvs(s) reverse(s.begin(),s.end())
#define all(s) s.begin(),s.end()
#define sz(s) (int)(s.size())
#define lb(s) ((s) & (-s))
#define mk(s, t) make_pair(s, t)


inline void wt(ll x){cout << x;}
inline void wtl(ll x){cout << x << endl;}
inline void wtb(ll x){cout << x << ' ';}
template <typename T> bool ckmax(T &x, T y){return x < y ? x = y, true : false;}
template <typename T> bool ckmin(T &x, T y){return x > y ? x = y, true : false;}
int qmi(int a, int k, int p){int res = 1;while (k){if (k & 1) res = (ll)res * a % p;a = (ll)a * a % p;k >>= 1;}return res;}
int qpow(int a,int b){int res = 1;while(b){if(b&1) res *= a;b>>=1;a*=a;}return res;}
int mo(int x,int p){return x = ((x%p)+p)%p;}
int gcd(int a,int b){return b?gcd(b,a%b):a;}
const int maxn = 1e6+7;
const int mod = 1e9+7;
int dx[] = {0,0,1,-1}, dy[] = {1,-1,0,0};

int T,N,M,K;
int num1[33],num2[33],dp[33][2][2];
int st[maxn];
int bit[33];
int L, R, ans;

int dfs(int now, int limit1, int limit2, int zero){
	if(now == -1) return 1;//枚举完了
	int &x = dp[now][limit1][limit2];
	if(~x) return x;//已经搜过了
	if ((!limit1)&&(!limit2)&&!zero) return x = bit[now+1];//没有限制，后面就是全部的组合
	int end1 = limit1?num1[now]:1;
	int end2 = limit2?num2[now]:1;
	x = 0;
	int temp = 0, cnt = 0;
	rep(i,0,end1){
		rep(j,0,end2){
			if(i&j) continue;//不符合&=0
			if(zero&&(i|j)){
				temp = dfs(now-1,limit1&&(i==end1),limit2&&(j==end2),0);
				x = (x+temp)%mod;//为上一层累加
				cnt = (cnt+temp)%mod;//当前位是最高位
			}
			else{
				x = (x+dfs(now-1,limit1&&(i==end1),limit2&&(j==end2),zero&&(!(i|j))))%mod;//为上一层累加
			}
		}
	}
	ans=(ans+cnt*(now+1))%mod;
	return x;
}
void part(int X, int Y){
	int len = -1;//数字放在【0，len】中
	while(X || Y) {
		num1[++len] = X%2, X/=2;
		num2[len] = Y%2, Y/=2;
	}
	ans = 0;
	mem(dp,-1);
	dfs(len,1,1,1);
	wtl(ans);
}
void solve(){
	cin >> L >> R;
	part(L,R);

}
signed main()
{

	bit[0] = 1;
	rep(i,1,32) bit[i] = bit[i-1]*3%mod;
	cin >> T;
	while(T--) solve();
  return (0-0); //<3
}

这题与上题不同，只有一个数，我们可以用前缀和相减来求，但是数字太大有5000位，需要用到字符串来存储，对字符串求减一涉及到借位，可能有些麻烦（其实也并不麻烦）。这里提供另一种思路，就是判断L这个数是否满足即可。

参数分析：

  1. 满足f（x）= x（mod M） 我们可以构造g（x）= f（x）- x，那么条件变成g（x）= 0 （mod M）
  2. 计算f（x）时，为了避免重复计算贡献，规定当前数字只会跟前面的数字产生贡献，那么我们只需要记录每一位数字的前缀和pre，然后当前数字的贡献就是j * pre
#include<bits/stdc++.h>
using namespace std;


#define mem(a,b) memset(a,b,sizeof a)
#define PII pair<int,int>
#define ull unsigned long long
#define fi first
#define se second
#define endl '\n'
#define PI acos(-1.0)
#define lcm(a,b) a/gcd(a,b)*b
#define INF 0x3f3f3f3f3f3f3f3f
#define debug(a) cerr<<#a<<"="<<a<<endl;
#define Adebug(a,i) cerr<<#a<<"["<<i<<"]="<<a[i]<<endl;
#define rep(i, a, b) for(int i = (a); i <= (b); i ++)
#define per(i, a, b) for(int i = (a); i >= (b); i --)
#define vi vector<int>
#define vpii vector<PII>
#define pb push_back
#define rvs(s) reverse(s.begin(),s.end())
#define all(s) s.begin(),s.end()
#define sz(s) (int)(s.size())
#define lb(s) ((s) & (-s))
#define mk(s, t) make_pair(s, t)


inline void wt(int x){cout << x;}
inline void wtl(int x){cout << x << endl;}
inline void wtb(int x){cout << x << ' ';}
template <typename T> bool ckmax(T &x, T y){return x < y ? x = y, true : false;}
template <typename T> bool ckmin(T &x, T y){return x > y ? x = y, true : false;}
int qpow(int a,int b){int res = 1;while(b){if(b&1) res *= a;b>>=1;a*=a;}return res;}
int mo(int x,int p){return x = ((x%p)+p)%p;}
int gcd(int a,int b){return b?gcd(b,a%b):a;}
const int maxn = 1e6+7;
const int mod = 1e9+7;

int T,N,M,K;
int bit[5009],A[5009],dp[5009][61][61][2],id,st[5009][61][61][2];
char R[5009],L[5009];
int f;
int dfs(int now,int pre,int fx, int limit){
	long long ans = 0;
	if(now==(N+1)){
		f = (fx==0);//判断X是否可行
		return f;
	}
	if (st[now][pre][fx][limit]==id) return dp[now][pre][fx][limit];//这样可以不用初始化dp数组，等于当前id说明是本组数据，不同组的模数是不同的，所以同一个状态的值可能不同
	st[now][pre][fx][limit] = id;
	int lim = limit?A[now]:9;
	rep(i,0,lim){
		int dif = mo((fx+i*pre-i*bit[N-now]),M);
		ans = ans+dfs(now+1,(pre+i)%M,dif,limit&&(i==A[now]));
	}
	ans = (ans+mod)%mod;
	dp[now][pre][fx][limit] = ans;
	return ans;
}
int part(char X[]){
	//printf("!---%s\n",X+1);
	++id;//标记测试数据组别
	N = strlen(X+1);	
	rep(i,1,N) A[i] = X[i]-'0';
	return dfs(1,0,0,1);	
}
void solve(){
	scanf("%s %s %d",L+1,R+1,&M);
	N = strlen(R+1);
    bit[0] = 1;
	rep(i,1,N){
		bit[i] = bit[i-1]*10%M;
	}
	int ans = part(R);
	f = 0;
	ans-=part(L);
	//debug(f);
	ans+=f;//f是判断L是否有效，有效的话就为1（前缀和相减时多减了1加回来）
	wtl(mo(ans,mod));

}
signed main()
{
	cin >> T;
	while(T--) solve();
    return (0-0); //<3
}
XINNNNNNNYU
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
DP(数位专题Ⅶ)
weixin_43533544的博客
08-07 203
题意: 给定区间[l, r] , 求[l,r]中各位数字之和能整除原数的数的个数。 >> face << Strategy: 显然数位dp, 又是和取模有关,我原本考虑: dp[i][j]→dp[i][j]\todp[i][j]→目前搜到第i个数, 且填的数的和是j, 然后dfs终点特判能不能除尽, 结果状态在原数是100+的时候依旧又重复的情况.题解有个神奇的方法, 枚举...
数位dp算法详细图文解答
02-13
数位动态规划（Digital Dynamic Programming, 简称数位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
在人间负债^
08-10 151
数位 DP 数位 DP 就是一种用计数的 DP 方式，一般是用来统计一个区间 [ l , r ] 中满足条件的数有多少。 数位 DP 字面意思就是在数位上进行 DP ，那么数位又是什么呢，数位就是一个数的每一位的位数了，比如个位，十位，百位… 那么对于统计一个区间 [ l , r ] 内满足条件的数，不使用数位 DP 和使用数位 DP 有什么不同的区别呢，下面就给出了使用数位 DP 和不使用数位 DP （暴力枚举）的区别了 不使用数位 DP ，不使用数位 DP ，那么求解一个区间中满足条件的数，最直接最暴力
[python刷题模板] 数位DP
liuliangcan的博客
11-27 1193
python刷题模板之数位dp
2021-07-08-Beautiful numbers CodeForces - 55D（数位DP+模板）
I_have_a_world的博客
07-08 143
Beautiful numbers CodeForces - 55D 1.果然，决心刷一个专题的时候，不需要立即就将正在做的题目理解。可以先多看看其他的题目，有时候，见的多了，思维发散了，自然而然就理解了（其实现在还没有完全理解，但是感受到了数位DP是怎样一个套路） 2. 题意： 给定两个数l,r（1<=l<=r<=9e18），求[l,r]间漂亮数的个数（漂亮数：能被所有非0数位整除的数） 题解： 1.参考：Beautiful numbers CodeForces - 55D（数位DP）
数位dp模板
飞向更远的博客
09-08 124
带注释 typedef long long ll; ll digit[30]; ll dp[20][state];//不同题目状态不同 ll dfs(ll pos,/*state变量*/,bool lead/*前导零*/,bool limit/*数位上界变量*/)//不是每个题都要判断前导零 { //递归边界，既然是按位枚举，最低位是0，那么pos==-1说明这个数我枚举完了 if(pos==-1) return 1;/*这里一般返回1，表示你枚举的这个数是合法的，那么这里就需要你在枚举时必
数位DP模板
Melancholy的博客
07-21 87
数位DP模板 ybt上写的什么lj模板，还得上网找个舒服的…… 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
数位dp
cccccccj
11-17 1万+
原文地址： https://blog.csdn.net/brazy/article/details/77427699 觉得写得很不错~~ ============================= 数位dp是一种计数用的dp，一般就是要统计一个区间[le,ri]内满足一些条件数的个数。所谓数位dp，字面意思就是在数位上进行dp咯。数位还算是比较好听的名字，数位的含义：一个数有个位、十位、百位、千位...
数位DP入门+数位DP模板
receiling的博客
08-20 9842
数位dp是一种计数用的dp，一般就是要统计一个区间[le,ri]内满足一些条件数的个数。所谓数位dp，字面意思就是在数位上进行dp咯。数位还算是比较好听的名字，数位的含义：一个数有个位、十位、百位、千位......数的每一位就是数位啦！ 之所以要引入数位的概念完全就是为了dp。数位dp的实质就是换一种暴力枚举的方式，使得新的枚举方式满足dp的性质，然后记忆化就可以了。 两种不同的枚举：对...
数位DP.pdf
07-12
数位DP整理的模板和一些题目的题解。QAQ没钱下载资源了只好上传点东西。
数位dp——某次队内分享任务
07-21
数位动态规划(Digit Dynamic Programming, 简称数位DP)是一种在处理与数字相关的动态规划问题时，通过分析每个数字位上的状态来优化算法的技术。它通常用于解决涉及数字序列特性的数学问题，例如计数特定类型的数...
数位DP入门
08-22
数位DP入门思想，包括详细的思考过程以及一些习题的讲解
初探数位dp.pdf
09-16
lazycal的集训队报告：初探数位DP 以HDU 2089，HDU 3652, URAL 1057等题目为例，介绍了数位DP的算法
函数模板与类模板
程序员_小兵
07-12 1559
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。
基于Big-Bang-Big-Crunch(BBBC)算法的目标函数最小值计算matlab仿真
熟悉python,matlab,C,C++,JAVA等
07-12 381
BBBC算法的核心思想模拟了宇宙从大爆炸（Big Bang）开始，经历扩张，再到可能的大收缩（Big Crunch）的过程，以此类比于在解空间中从初始分散的解集出发，通过一系列搜索过程逐步集中并接近最优解的过程。：一个简化的聚集方法可以是xi′′​=xbest​+β⋅(xi′​−xbest​)，其中xbest​是最优解，β是一个小于1的收缩因子，控制收缩速度。：每个解xi​依据一定的规则在解空间中移动，这个移动可以是随机的，也可以基于某种策略，比如基于目标函数梯度的方向或者利用当前解与其他解的相对位置。
树状数组（Binary Indexed Tree, BIT）
qq_73702550的博客
07-12 371
树状数组（Binary Indexed Tree, BIT），也称为 Fenwick Tree，是一种用于高效处理数组前缀和查询和单点更新的数据结构。它能够在 (O(\log n)) 时间内完成单点更新和前缀和查询操作。
常见的排序算法，复杂度
最新发布
m0_61544805的博客
07-16 349
稳定 / 非稳定排序：两个相等的数 排序前后 相对位置不变。 插入排序（希尔排序）： 每一趟将一个待排序记录，按其关键字的大小插入到已排好序的一组记录的适当位置上，直到所有待排序记录全部插入为止。稳定，O(n)，O(1)。 把记录按下标增量（模）分组，对每组进行直接插入排序，每次排序后减小增量，当增量减至 1 时排序完毕。不稳定，不知道（有个实验结论），O(1)。 冒泡排序： 比较相邻的元素，如果第一个比第二个大就进行交换，对每一对相邻元素做同样的工作。稳定，O(n)，O(1)。 选择

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值