数位dp总结 之 从入门到模板（stO）
#转载自https://blog.csdn.net/wust_zzwh/article/details/52100392
基础篇
数位dp是一种计数用的dp，一般就是要统计一个区间[le,ri]内满足一些条件数的个数。所谓数位dp，字面意思就是在数位上进行dp咯。数位还算是比较好听的名字，数位的含义：一个数有个位、十位、百位、千位......数的每一位就是数位啦！
之所以要引入数位的概念完全就是为了dp。数位dp的实质就是换一种暴力枚举的方式，使得新的枚举方式满足dp的性质，然后记忆化就可以了。
两种不同的枚举：对于一个求区间[le,ri]满足条件数的个数，最简单的暴力如下：
for(int i=le;i<=ri;i++)if(right(i)) ans++;
然而这样枚举不方便记忆化，或者说根本无状态可言。
新的枚举：控制上界枚举，从最高位开始往下枚举，例如：ri=213，那么我们从百位开始枚举：百位可能的情况有0,1,2(觉得这里枚举0有问题的继续看)
然后每一位枚举都不能让枚举的这个数超过上界213（下界就是0或者1，这个次要），当百位枚举了1，那么十位枚举就是从0到9，因为百位1已经比上界2小了，后面数位枚举什么都不可能超过上界。所以问题就在于：当高位枚举刚好达到上界是，那么紧接着的一位枚举就有上界限制了。具体的这里如果百位枚举了2，那么十位的枚举情况就是0到1，如果前两位枚举了21，最后一位之是0到3(这一点正好对于代码模板里的一个变量limit 专门用来判断枚举范围)。最后一个问题：最高位枚举0：百位枚举0，相当于此时我枚举的这个数最多是两位数，如果十位继续枚举0，那么我枚举的就是以为数咯，因为我们要枚举的是小于等于ri的所以数，当然不能少了位数比ri小的咯！(这样枚举是为了无遗漏的枚举，不过可能会带来一个问题，就是前导零的问题，模板里用lead变量表示，不过这个不是每个题目都是会有影响的，可能前导零不会影响我们计数，具体要看题目)
由于这种新的枚举只控制了上界所以我们的Main函数总是这样：
int main()
{long long le,ri;while(~scanf("%lld%lld",&le,&ri))printf("%lld\n",solve(ri)-solve(le-1));
}
w_w 是吧！统计[1,ri]数量和[1,le-1]，然后相减就是区间[le,ri]的数量了，这里我写的下界是1，其实0也行，反正相减后就没了，注意题目中le的范围都是大于等于1的(不然le=0,再减一就G_G了)
在讲例题之前先讲个基本的动态模板(先看后面的例题也行)：dp思想，枚举到当前位置pos，状态为state(这个就是根据题目来的，可能很多，毕竟dp千变万化)的数量(既然是计数,dp值显然是保存满足条件数的个数)
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));}
}相信读者还对这个有不少疑问，笔者认为有必要讲一下记忆化为什么是if(!limit)才行，大致就是说有无limit会出现状态冲突，举例：
约束：数位上不能出现连续的两个1(11、112、211都是不合法的)
假设就是[1,210]这个区间的个数
状态:dp[pos][pre]:当前枚举到pos位，前面一位枚举的是pre(更加前面的位已经合法了)，的个数(我的pos从0开始)
先看错误的方法计数，就是不判limit就是直接记忆化
那么假设我们第一次枚举了百位是0，显然后面的枚举limit=false，也就是数位上0到9的枚举，然后当我十位枚举了1，此时考虑dp[0][1],就是枚举到个位，前一位是1的个数，显然dp[0][1]=9;(个位只有是1的时候是不满足的)，这个状态记录下来，继续dfs，一直到百位枚举了2，十位枚举了1，显然此时递归到了pos=0,pre=1的层，而dp[0][1]的状态已经有了即dp[pos][pre]!=-1；此时程序直接return dp[0][1]了，然而显然是错的，因为此时是有limit的个位只能枚举0，根本没有9个数，这就是状态冲突了。有lead的时候可能出现冲突，这只是两个最基本的不同的题目可能还要加限制，反正宗旨都是让dp状态唯一
对于这个错误说两点：一是limit为true的数并不多，一个个枚举不会很浪费时间，所以我们记录下! limit的状态解决了不少子问题重叠。第二，有人可能想到把dp状态改一下dp[pos][state][limit]就是分别记录不同limit下的个数，这种方法一般是对的，关于这个具体会讲，下面有题bzoj3209会用到这个。
数位的部分就是这些，然后就是难点，dp部分，dp大牛的艺术，弱鸡只能看看+...+
既然从高位往低位枚举，那么状态一般都是与前面已经枚举的数位有关并且通常是根据约束条件当前枚举的这一位能使得状态完整(比如一个状态涉及到连续k位，那么就保存前k-1的状态，当前枚举的第k个是个恰好凑成成一个完整的状态，不过像那种状态是数位的和就直接保存前缀和为状态了)，不过必然有一位最简单的一个状态dp[pos]当前枚举到了pos位。dp部分就要开始讲例题了，不过会介绍几种常用防tle的优化。
实战篇
例一：HDU 2089 不要62入门题。就是数位上不能有4也不能有连续的62，没有4的话在枚举的时候判断一下，不枚举4就可以保证状态合法了，所以这个约束没有记忆化的必要，而对于62的话，涉及到两位，当前一位是6或者不是6这两种不同情况我计数是不相同的，所以要用状态来记录不同的方案数。dp[pos][sta]表示当前第pos位，前一位是否是6的状态，这里sta只需要去0和1两种状态就可以了，不是6的情况可视为同种，不会影响计数。
#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
using namespace std;
typedef long long ll;
int a[20];
int dp[20][2];
int dfs(int pos,int pre,int sta,bool limit)
{if(pos==-1) return 1;if(!limit && dp[pos][sta]!=-1) return dp[pos][sta];int up=limit ? a[pos] : 9;int tmp=0;for(int i=0;i<=up;i++){if(pre==6 && i==2)continue;if(i==4) continue;//都是保证枚举合法性tmp+=dfs(pos-1,i,i==6,limit && i==a[pos]);}if(!limit) dp[pos][sta]=tmp;return tmp;
}
int solve(int x)
{int pos=0;while(x){a[pos++]=x%10;x/=10;}return dfs(pos-1,-1,0,true);
}
int main()
{int le,ri;//memset(dp,-1,sizeof dp);可优化while(~scanf("%d%d",&le,&ri) && le+ri){memset(dp,-1,sizeof dp);printf("%d\n",solve(ri)-solve(le-1));}return 0;
}入门就不多讲了，开始讲常用优化吧！
第一:memset(dp,-1,sizeof dp);放在多组数据外面。
第二：相减。
#include<cstdio>
#include<cstring>
#include<iostream>
#include<string>using namespace std;
const int N=1e4+5;
int dp[12][N];
int f(int x)
{if(x==0) return 0;int ans=f(x/10);return ans*2+(x%10);
}
int all;
int a[12];
int dfs(int pos,int sum,bool limit)
{if(pos==-1) {return sum<=all;}if(sum>all) return 0;if(!limit && dp[pos][all-sum]!=-1) return dp[pos][all-sum];int up=limit ? a[pos] : 9;int ans=0;for(int i=0;i<=up;i++){ans+=dfs(pos-1,sum+i*(1<<pos),limit && i==a[pos]);}if(!limit) dp[pos][all-sum]=ans;return ans;
}
int solve(int x)
{int pos=0;while(x){a[pos++]=x%10;x/=10;}return dfs(pos-1,0,true);
}
int main()
{int a,ri;int T_T;int kase=1;scanf("%d",&T_T);memset(dp,-1,sizeof dp);while(T_T--){scanf("%d%d",&a,&ri);all=f(a);printf("Case #%d: %d\n",kase++,solve(ri));}return 0;
}减法的艺术！！！
#pragma comment(linker, "/STACK:10240000,10240000")
#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<queue>
#include<set>
#include<vector>
#include<map>
#include<stack>
#include<cmath>
#include<algorithm>
using namespace std;
const double R=0.5772156649015328606065120900;
const int N=1e5+5;
const int mod=1e9+7;
const int INF=0x3f3f3f3f;
const double eps=1e-8;
const double pi=acos(-1.0);
typedef long long ll;
int dp[35][66];
int a[66];
int dfs(int pos,int sta,bool lead,bool limit)
{if(pos==-1)return sta>=32;if(!limit && !lead && dp[pos][sta]!=-1) return dp[pos][sta];int up=limit?a[pos]:1;int ans=0;for(int i=0;i<=up;i++){if(lead && i==0) ans+=dfs(pos-1,sta,lead,limit && i==a[pos]);//有前导零就不统计在内else ans+=dfs(pos-1,sta+(i==0?1:-1),lead && i==0,limit && i==a[pos]);}if(!limit && !lead ) dp[pos][sta]=ans;return ans;
}
int solve(int x)
{int pos=0;while(x){a[pos++]=x&1;x>>=1;}return dfs(pos-1,32,true,true);
}
int main()
{memset(dp,-1,sizeof dp);int a,b;while(~scanf("%d%d",&a,&b)){printf("%d\n",solve(b)-solve(a-1));}return 0;
}
然后就是一些需要自己yy的题：
#include<cstdio>
#include<cstring>
#include<iostream>
#include<string>using namespace std;typedef long long ll;ll dp[20][163][163][2];
int a[20];
ll dfs(int pos,int sum,int val,int mod,bool limit)
{if(sum-9*pos-9>0) return 0;//最坏的情况，这一位及后面的全部为9都不能达到0那就直接GG，这个剪枝不会影响acif(pos==-1) return sum==0 && val==0;if(dp[pos][sum][val][limit]!=-1) return dp[pos][sum][val][limit];int up=limit?a[pos]:9;ll ans=0;for(int i=0;i<=up;i++){if(sum-i<0) break;ans+=dfs(pos-1,sum-i,(val*10+i)%mod,mod,limit && i==a[pos]);}dp[pos][sum][val][limit]=ans;return ans;
}
ll solve(ll x)
{int pos=0;while(x){a[pos++]=x%10;x/=10;}ll ans=0;for(int i=1;i<=pos*9;i++)//上限就是每一位都是9{memset(dp,-1,sizeof dp);ll tmp=dfs(pos-1,i,0,i,true);ans+=tmp;}return ans;
}
int main()
{// cout<<18*9<<endl;ll le,ri;
// memset(dp,-1,sizeof dp);while(~scanf("%lld%lld",&le,&ri))printf("%lld\n",solve(ri)-solve(le-1));return 0;
}
/*
1 1000000000000000000
*/
基本讲的差不多了。前段时间学了点新东西！！
新的领域--计数转求和
#pragma comment(linker, "/STACK:10240000,10240000")
#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<queue>
#include<set>
#include<vector>
#include<map>
#include<stack>
#include<cmath>
#include<algorithm>
using namespace std;
const double R=0.5772156649015328606065120900;
const int N=1e5+5;
const int mod=1e9+7;
const int INF=0x3f3f3f3f;
const double eps=1e-8;
const double pi=acos(-1.0);
typedef long long ll;
ll fact[20];
void init()
{fact[0]=1;for(int i=1;i<20;i++)fact[i]=fact[i-1]*10%mod;
}
struct node
{ll cnt,sum,sqr;node(ll cnt=-1,ll sum=0,ll sqr=0):cnt(cnt),sum(sum),sqr(sqr){}
}dp[20][7][7];
int a[20];
ll fac(ll x)
{return x*x%mod;
}
ll dfs(int pos,ll num,ll val,ll&cnt,ll&sum,bool limit)
{if(pos==-1) {if(num==0 || val==0)return 0;cnt=1;return 0;}if(!limit && dp[pos][num][val].cnt!=-1) {cnt=dp[pos][num][val].cnt;sum=dp[pos][num][val].sum;return dp[pos][num][val].sqr;}int up=limit?a[pos]:9;ll sq=0;for(int i=0;i<=up;i++)if(i!=7){ll cn=0,su=0;ll tmp=dfs(pos-1,(num+i)%7,(val*10+i)%7,cn,su,limit && i==a[pos]);ll tm=i*fact[pos]%mod;tmp=(tmp+fac(tm)*cn%mod+(tm*su%mod)*2%mod)%mod;//计数之后要更新sum,sqrsum=(sum+su+(i*fact[pos]%mod)*cn%mod)%mod;cnt=(cnt+cn)%mod;sq=(sq+tmp)%mod;}if(!limit) dp[pos][num][val]=node(cnt,sum,sq);return sq;
}
ll solve(ll x)
{int pos=0;while(x){a[pos++]=x%10;x/=10;}ll t1=0,t2=0;return dfs(pos-1,0,0,t1,t2,true);
}
bool judge(ll x)
{int sum=0;int pos=0;if(x%7==0) return false;while(x){if(x%10==7) return false;sum+=x%10;x/=10;}sum%=7;return sum!=0;
}
int main()
{init();for(int i=0;i<20;i++)for(int j=0;j<7;j++)for(int k=0;k<7;k++)//memset{dp[i][j][k].cnt=-1;dp[i][j][k].sum=0;dp[i][j][k].sqr=0;}int T_T;scanf("%d",&T_T);while(T_T--){ll le,ri;scanf("%I64d%I64d",&le,&ri);ll ans=solve(ri)-solve(le-1);ans=(ans%mod+mod)%mod;printf("%I64d\n",ans);}return 0;
}
做题去~~
数位dp总结 之 从入门到模板（stO）相关推荐
- 数位dp总结 之 从入门到模板
转自巨佬:https://blog.csdn.net/wust_zzwh/article/details/52100392 基础篇 数位dp是一种计数用的dp,一般就是要统计一个区间[le,ri]内满 ...
- 数位dp总结 之 从入门到模板
基础篇 数位dp是一种计数用的dp,一般就是要统计一个区间[le,ri]内满足一些条件数的个数.所谓数位dp,字面意思就是在数位上进行dp咯.数位还算是比较好听的名字,数位的含义:一个数有个位.十位. ...
- 数位DP入门+数位DP模板
数位dp是一种计数用的dp,一般就是要统计一个区间[le,ri]内满足一些条件数的个数.所谓数位dp,字面意思就是在数位上进行dp咯.数位还算是比较好听的名字,数位的含义:一个数有个位.十位.百位.千 ...
- 数位dp 的简单入门
时间紧张,就不讲那么详细了. 之前一直被深搜代码误解,以为数位dp 其实就是记忆化深搜...(虽说爆搜确实很舒服而且还好想) 但是后来发现数位dp 的标准格式其实是 预处理 + dp ...... 数 ...
- 数位dp入门题 洛谷P2657 [SCOI2009] windy 数
题干 传送门 windy 定义了一种 windy 数. 题目描述 不含前导零且相邻两个数字之差至少为 2的正整数被称为 windy 数.windy 想知道,在 a 和 b 之间,包括 a 和 b ,总 ...
- 数位dp的概念和模板
基础篇 数位dp是一种计数用的dp,一般就是要统计一个区间[le,ri]内满足一些条件数的个数.所谓数位dp,字面意思就是在数位上进行dp咯.数位还算是比较好听的名字,数位的含义:一个数有个位.十位. ...
- 数位dp模板 [dp][数位dp]
现在才想到要学数位dp,我是不是很弱 答案是肯定的 以一道自己瞎掰的题为模板 1 //题: 2 //输入数字n 3 //从0枚举到n,计算这n+1个数中含有两位数a的数的个数 4 //如12930含有 ...
- 数位dp从会打模板到不会打模板
打了几个数位$dp$,发现自己除了会打模板之外没有任何长进,遇到非模板题依然什么都不会 那么接下来这篇文章将介绍如何打模板(滑稽) 假设我们要处理$l----r$ 采用记忆化搜索的方式,枚举$< ...
- hdu 2089 数位dp入门
HDU 2089 题意:中文题 思路:数位dp入门题 AC代码: #include "iostream" #include "string.h" #includ ...
最新文章
- Ajax---使用json数据格式输出数据
- OSI参考模型与TCP/IP协议的比较研究
- C++中map容器的说明和使用技巧
- 关于 原码 反码 补码 位运算
- uml图工具_UML建模工具更新情况（二）
- Spring2.5整合JPA
- cpu频率_AMD EPYC米兰处理器样品曝光：64核128线程的Zen 3芯，频率可达3.5GHz_游戏硬件CPU...
- vb编程软件_原创经验，如何安装vb编程软件
- [JS-BOM]BOM_Window窗口对象
- python支持向量机回归_机器学习实战-支持向量机原理、Python实现和可视化（分类）...
- c++ 计算正弦的近似值_一篇文章搞懂正弦保真性
- addslashes注入漏洞与mb_addslashes
- fatal exception java_java.lang.IllegalStateExceptio
- 51nod-1358：浮波那契
- LeetCode学习记录（1-3）
- 键盘修改器，绝对管用
- 2020奶茶行业研究报告
- python读取excel日期小数_RPA-使用Python读取Excel日期结果为数字时的转换处理方法...
- oracle 10g R2数据库的安装部署
- 《ClickHouse原理解析与应用实践》读书笔记（2）