【学习笔记】数位DP（简单题）

最新推荐文章于 2022-10-03 19:22:03 发布
最新推荐文章于 2022-10-03 19:22:03 发布
阅读量696 收藏 4
点赞数
分类专栏： 题解 学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37809890/article/details/82703944
版权

前言

本来写的超级多超级繁琐，可是被csdn搞了，然后就没了。现在重写一遍，重新理清思路，只写关键内容。

数位dp

求区间[l,r]内，满足某条件的数的个数，这个条件一般与数的组成有关；或者统计某个量，这个量也与数的组成有关。

解法

首先这样的题一般满足前缀性质，即[l,r]内的答案可以变为[1,r]-[1,l-1]。

  1. 在满足条件的数字很少且方便搜索时，可以先打表再查找。
  2. 从高位到低位遍历每一位数，记忆化搜索得出答案。

题目列表

HDU 3555 含49.
CF 1036C 非0数位不超过3.
HDU 2089 不含62，不含4.
BZOJ 1026 相邻数位之差大于等于2
BZOJ 1833 求所有数码的出现次数
HDU 3652 含13，被13整除。

HDU 3555 Bomb

求[0,N]内含49的数的个数，写了四种不同的写法，终于找到一种好理解的。

记忆化搜索
状态表示：solve(upper,bit,status) 表示[0,upper]内满足条件的数字个数，upper的位数为bit（防中间0），当前的状态是status（0/1/2分别表示 无4/有4/有49）。
状态边界：bit=0时，如果status为2，答案是1，否则是0.
状态转移：记front为upper的首位（第bit高位），首位值i从0到front遍历，当i<front时递归的upper就是一个各位全为9的数，否则就原数的下一位；递归的bit就是当前bit-1；对status设置一个状态机：起始是0，检测到4是1，检测到49是2.
状态记录：为了避免超时，用table[bit][status]来记录记录当upper各位全为9时的答案。

手动跑一下这个过程会理解的更深刻。
代码中，p10数组表示10的幂次；getbit函数用于获得n的位数；求upper的首位：upper/p10[bit-1]，求upper删去首位后的值：upper%p10[bit-1].

vector<ll> p10(1,1);
ll table[19][3];
inline int getbit(ll n)
{
    return upper_bound(p10.begin(), p10.end(), n) - p10.begin();
}
//求[0,upper]内含49的数的个数,
//status 0/1/2 无4/有4/有49
ll solve(ll upper, int bit, int status)
{
	//printf("%I64d %d %d\n",upper,bit,status );
    if(bit==0)
    	return status==2;
    if(upper == p10[bit]-1 && table[bit][status]!=-1)
    	return table[bit][status];
    ll res = 0, front = upper/p10[bit-1];

    for(int i=0;i<=front;i++)
    {
    	ll nxt_up = i==front ? upper%p10[bit-1] : p10[bit-1]-1;
    	int nxt_st = status;
    	if(status!=2)
    	{
    		if(i==4)
    			nxt_st = 1;
    		else if(status==1 && i==9)
    			nxt_st = 2;
    		else
    			nxt_st = 0;
    	}
    	res += solve(nxt_up, bit-1, nxt_st);
    }

    if(upper == p10[bit]-1)
    	table[bit][status] = res;
    return res;
}
int main(void)
{
	for(int i = 1; i <= 18; i++)
        p10.push_back(p10.back() * 10);
    memset(table,-1,sizeof(table));
	
    int T = read();
    while(T--)
    {
    	ll N = read();
    	cout <<solve(N, getbit(N), 0) << endl;
    }
    return 0;
}

Codeforces 1036C Classy Numbers

求[L,R]内非0数位不超过3的数

状态表示：solve(upper, bit, need)表示[0,upper]内非0数位不超过need的个数。
状态边界：bit=0时返回1，因为need<0的情况已经在转移过程中卡掉了
状态转移：新的upper、bit同上题，遍历到0时status不变，其他情况在status大于0时减一。
状态记录：同上题

好生气，这题套模板5分钟左右就做完了，而cf第一次做的时候做了30多分钟，果然题数压制才是硬道理。

vector<ll> p10(1,1);
ll table[19][4];
inline int getbit(ll n)
{
    return upper_bound(p10.begin(), p10.end(), n) - p10.begin();
}
//求[0,upper]内非0数位不超过3的个数
//status 0/1/2/3 可用0/1/2/3个
ll solve(ll upper, int bit, int status)
{
	//printf("%I64d %d %d\n",upper,bit,status );
    if(bit==0)
    	return 1;
    if(upper == p10[bit]-1 && table[bit][status]!=-1)
    	return table[bit][status];
    ll res = 0, front = upper/p10[bit-1];

    for(int i=0;i<=front;i++)
    {
    	ll nxt_up = i==front ? upper%p10[bit-1] : p10[bit-1]-1;
        if(i==0)
            res += solve(nxt_up, bit-1, status);
    	if(i && status)
            res += solve(nxt_up, bit-1, status-1);
    }

    if(upper == p10[bit]-1)
    	table[bit][status] = res;
    return res;
}
int main(void)
{
	for(int i = 1; i <= 18; i++)
        p10.push_back(p10.back() * 10);
    memset(table,-1,sizeof(table));
	
    int T = read();
    while(T--)
    {
    	ll L = read(), R = read();
    	cout << solve(R, getbit(R), 3) - solve(L-1,getbit(L-1),3) << endl;
    }
    return 0;
}

HDU 2089 不要62

求[n,m]内不含62与4的数字个数。

先对status设计一个状态机，起始为0，检测到6为1，检测到62或4为2，其中01都是合法状态。
但是写起来就会发现，能达到状态为2的可以直接卡掉，不用下传状态。
状态表示： solve(upper,bit,status)表示[0,upper]内不含62与4的数的个数。
状态边界： bit=0时返回1.
状态转移： 卡掉status=2的情况，然后下传即可。
状态记录： 同以上题

vector<ll> p10(1,1);
ll table[19][3];
inline int getbit(ll n)
{
    return upper_bound(p10.begin(), p10.end(), n) - p10.begin();
}
//求[0,upper]内不含62和4的数字个数
//status 0/1/2 其它/6/62或4
ll solve(ll upper, int bit, int status)
{
    if(bit==0)
    	return 1;
    if(upper == p10[bit]-1 && table[bit][status]!=-1)
    	return table[bit][status];
    ll res = 0, front = upper/p10[bit-1];

    for(int i=0;i<=front;i++)
    {
        if((i==2 && status) || i==4)
            continue;
        ll nxt_up = i==front ? upper%p10[bit-1] : p10[bit-1]-1;
        res += solve(nxt_up, bit-1, i==6);
    }

    if(upper == p10[bit]-1)
    	table[bit][status] = res;
    return res;
}
int main(void)
{
	for(int i = 1; i <= 18; i++)
        p10.push_back(p10.back() * 10);
    memset(table,-1,sizeof(table));
	
    while(1)
    {
    	ll L = read(), R = read();
        if(L==0)
            break;
    	cout << solve(R, getbit(R), 0) - solve(L-1,getbit(L-1),0) << endl;
    }
    return 0;
}

BZOJ 1026 Windy数

题外话：发现bzoj（八中oj），hysbz（衡阳市八中），lydsy（大视野在线测评）其实说的是一个OJ。
求[A,B]内相邻两数位相差大于等于2的数字个数。

因为可以卡掉非法情况，本题的status可以直接记录上一位。需要注意的是区分前导0和非前导0的情况。
状态表示： solve(upper,bit,status)表示[0,upper]内上一位位status时的windy数个数，其中当status为11时表示前导0.
状态边界： bit=0时返回1，因为非法状态全卡掉了。
状态转移： 遍历0到upper最高位内所有与status相差大于等于2的数，向下转移。注意如果status为11时，0也按11算，表示前导0只会转移到前导0，非前导0只会转移到非前导0.
状态记录： 同以上题

写这题之前总结了一下板子(namespace DigitDP)，等板子成熟了再独立出来。

namespace DigitDP
{
    vector<ll> p10(1,1);
    ll table[19][15]; /*change: 表的定义*/
    inline int getbit(ll n)
    {
        return upper_bound(p10.begin(), p10.end(), n) - p10.begin();
    }
    /*change: 函数目标,状态含义*/
    //求[0,upper]内相邻数位相差大于等于的情况
    //status: 上一位,11表示没有
    ll solve(ll upper, int bit, int status)
    {
        if(bit==0)
            return 1; /*change: 边界情况*/
        if(upper == p10[bit]-1 && table[bit][status]!=-1)
            return table[bit][status];
        ll res = 0, front = upper/p10[bit-1];

        for(int i=0;i<=front;i++)
        {
            ll nxt_up = i==front ? upper%p10[bit-1] : p10[bit-1]-1;
            /*change: 状态舍弃,状态转换*/
            if(abs(i-status)<2) continue;
            int nxt_st = i;
            if(i==0 && status==11) nxt_st = 11;
            res += solve(nxt_up, bit-1,nxt_st );
        }

        if(upper == p10[bit]-1)
            table[bit][status] = res;
        return res;
    }
    void init()
    {
        for(int i = 1; i <= 18; i++)
            p10.push_back(p10.back() * 10);
        memset(table,-1,sizeof(table));
    }
}using namespace DigitDP;
int main(void)
{
    init();

	ll L = read(), R = read();
    cout << solve(R, getbit(R), 11) - solve(L-1,getbit(L-1),11) << endl;

    return 0;
}

BZOJ 1833 count 数字计数

求[a,b]中各个数码（0-9）分别出现了多少次。

一道数位计数题，而且要算10个答案，想不到在递归边界结算答案的方法，只能在过程中去计算，用结构体去同时统计所有答案。
状态表示： solve(upper,bit,state)表示1到upper的答案，state表示是否需要计算0的答案。
边界状态： bit = 0时返回全0
状态转移： 遍历i从0到upper首位，当且仅当i=0且state为0时下传state=0.

很快就写完了，但是调的心态爆炸，甚至给用来对拍的以前ac代码找出了bug。。。后来发现是快读没开long long，心态爆炸+1.

本题中得到的启示是 边界求值或者过程求值最好只选一个，使得代码简洁。
这也会使得，边界求值求得的是[0,x]的答案，而过程求值求得的是[1,x]的答案。

struct Item
{
    int vis;
    ll num[10];
    Item()
    {
        vis = 1;
        memset(num,0,sizeof(num));
    }
    Item operator + (const Item& b) const
    {
        Item c;
        for(int i=0;i<10;i++)        
            c.num[i] = num[i] + b.num[i];
        return c;
    }
}table[19][2],item0;
namespace DigitDP
{
    vector<ll> p10(1,1);
    inline int getbit(ll n)
    {
        return upper_bound(p10.begin(), p10.end(), n) - p10.begin();
    }
    /*change: 函数目标,状态含义*/
    //求[1,upper]内所有数码的出现次数
    //status: 是否需要计算0(前导0)
    Item solve(ll upper, int bit, int status)
    {
        if(bit==0)
            return item0; /*change: 边界情况*/
        if(upper == p10[bit]-1 && table[bit][status].vis)
            return table[bit][status];
        Item res;

        for(int i=0, front = upper/p10[bit-1];i<=front;i++)
        {
            ll nxt_up = i==front ? upper%p10[bit-1] : p10[bit-1]-1;
            /*change: 状态舍弃,状态转换*/
            if(i || status)
                res.num[i] += nxt_up + 1;
            res = res + solve(nxt_up, bit-1, i || status);
        }

        if(upper == p10[bit]-1)
            table[bit][status] = res;
        return res;
    }
    void init()
    {
        for(int i = 1; i <= 18; i++)
            p10.push_back(p10.back() * 10);
        for(int i=0;i<19;i++)
            for(int j=0;j<2;j++)
                table[i][j].vis = 0;
    }
}using namespace DigitDP;
int main(void)
{
    init();

	ll L = read(), R = read();
    Item itemr = solve(R,getbit(R),0);
    Item iteml = solve(L-1,getbit(L-1),0);
    for(int i = 0;i<9;i++)
        cout << itemr.num[i] - iteml.num[i] << " ";
    cout << itemr.num[9] - iteml.num[9] <<endl;
    return 0;
}

HDU 3652 B-number

求[1,n]内含13且能被13整除的数字个数。

状态表示 ： solve(upper,bit,status,remain)表示答案，status表示是否出现了13，remain表示当前的数字模13的余数。
状态边界 ：bit=0时，只有status为2且remain为0返回1.
状态转移 ：status转移同上， r e m a i n = ( r e m a i n ∗ 10 + i ) &VeryThinSpace; m o d &VeryThinSpace; 13 remain = (remain *10 + i)\bmod 13 remain=(remain∗10+i)mod13，因为模运算对乘法和加法具有分配律。

//DigitDP.cpp 数位dp通用
namespace DigitDP
{
	vector<ll> p10(1,1);
	ll table[19][3][14]; /*change: 表的定义,以及表的使用*/
	inline int getbit(ll n)
	{
	    return upper_bound(p10.begin(), p10.end(), n) - p10.begin();
	}
	/*change: 函数目标,状态含义*/
	//求[0,upper]内含13且能被13整除的数字个数
	//status: 0/1/2 无1/有1/有13  remain:除以13的余数
	ll solve(ll upper, int bit, int status, int remain)
	{
	    if(bit==0)
	    	return status==2 && remain==0; /*change: 边界情况*/
	    if(upper == p10[bit]-1 && table[bit][status][remain]!=-1)
	    	return table[bit][status][remain];
	    ll res = 0;

	    for(int i=0, front = upper/p10[bit-1]; i<=front; i++)
	    {
	        ll nxt_up = i==front ? upper%p10[bit-1] : p10[bit-1]-1;
	        int nxt_st = status;
	    	/*change: 状态舍弃,状态转换*/
	    	if(status!=2)
	    	{
	    		if(i==1) nxt_st = 1;
	    		else if(status==1 && i==3) nxt_st = 2;
	    		else nxt_st = 0;
	    	}

	        res += solve(nxt_up, bit-1, nxt_st, (remain*10+i)%13);
	    }

	    if(upper == p10[bit]-1)
	    	table[bit][status][remain] = res;
	    return res;
	}
	void init()
	{
	    for(int i = 1; i <= 18; i++)
	        p10.push_back(p10.back() * 10);
	    memset(table,-1,sizeof(table));
	}
}using namespace DigitDP;

int main(void)
{
	int n;
	while(scanf("%d",&n)!=EOF)
	{
		printf("%I64d\n",solve(n,getbit(n),0,0) );
	}

    return 0;
}
Little_Fall
关注
专栏目录
数位DP 学习笔记1（数位DP入门）
Miracle_QSH的博客
12-24 926
HDU 2089 不要62： 题目大意是给你一个区间，让你统计这个区间里不包含 4 和 62 的数字的个数。 最朴素的思路是： 对于每个区间 [l, r]，遍历所有在区间 [l, r] 里的数字，然后检查每个数字是不是合法（没有 4 和 62 ），如果合法答案加一。 代码如下： #include&lt;bits/stdc++.h&gt; using namespace std; boo...
数位dp简单题目汇总
ten_three
12-03 2291
地址：http://acm.hdu.edu.cn/showproblem.php?pid=2089 不要62 Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 15221    Accepted Submission(s):
模板
DrWells的博客
08-31 351
快速读入 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 题集
671coder的专栏
06-17 9171
数位DP 题集 /*-------------------------------------------------------------------------*/ 常用数位DP写法： int dfs(int i, int s, bool e) { if(i==-1) return s==target_s; if(!e && ~f[i][s]) re
数位dp练习题
UniverseofHK的博客
06-08 624
随便记录几个题， 防止连数位dp的思路都忘了，2333 数位dp 先将上限各位保存到num数组 从高位到低位dfs（暴力） 记忆化，优雅的暴力，否则就是O(n)的算法了，对单个数据也有很大的加速 pos为-1时以及记忆存在时可直接返回 关键：时刻记住判断条件，做到不重不漏 HDU 3652 B-number B-number Time Limit: 2000/1000 MS (Java/Oth...
数位DP入门题目
qq_48344603的博客
01-28 195
数位DP通常是用来求解给你一个[l,r][l,r][l,r]区间，求这个区间满足一定条件的数的个数。 1.Bomb 题目链接：点击此处 题意：求[1,n][1,n][1,n]中含49的个数 数位DP往往用一个数组来记录nnn中每一个位的值，这边用digit[i]digit[i]digit[i]表示从个位到最高位的第iii位为多少。 比如1234，则digit[1]=4,digit[2]=3,digit[3]=2,digit[4]=1digit[1]=4,digit[2]=3,digit[3]=2,digit
数位DP学习笔记
shroud777的博客
03-15 287
文章目录数位DP大量例题P4999 - 烦人的数学作业P2602 - [ZJOI2010]数字计数P 数位DP 大量例题 P4999 - 烦人的数学作业 题目描述： 给出 L,RL,RL,R，求在 [L,R][L,R][L,R] 中的所有整数的数位和的和（例如 123123123 的数位和= 1+2+3=61+2+3=61+2+3=6） 1≤L≤R≤10181 \leq L \leq R \leq 10^{18}1≤L≤R≤1018 思路： 板子 code: #include<bits/stdc++.
「学习笔记」SOS DP
cyl06 的博客
07-05 258
SOS DP 学习笔记 0.0 前言 本文大部分译自 CF 博客上的原文。Link here 0.1 前置知识 状压 DP 1.0 简介 SOS DP，全称 Sum over Subsets dynamic programming，意为子集和 DP，用来解决一些涉及子集和计算的问题。 1.1 例题引入 给定一个含 2N2^N2N 个整数的集合 A，我们需要计算：对于每个集合 x∈Ax\in Ax∈A，求 xxx 中所有元素 iii 的 A[i]A[i]A[i] 的和，即求： KaTeX parse er
状压DP 学习笔记
glorious_dream的博客
03-19 950
首先来说一下状态压缩 状态压缩就是使用某种方法，简明扼要地以最小代价来表示某种状态，通常是用一串01数字（二进制数）来表示各个点的状态。这就要求使用状态压缩的对象的点的状态必须只有两种，0 或 1；当然如果有三种状态用三进制来表示也未尝不可。 使用条件 1. 解法需要保存一定的状态数据（表示一种状态的一个数据值），每个状态数据通常情况下是可以通过2进制来表示的。这就要求状态数据的每个单元只有两种状态，比如说棋盘上的格子，放棋子或者不放，或者是硬币的正反两面。这样用0或者1来表示状态数据的每个单元，
DP协议学习笔记
热门推荐
qq_22326895的博客
05-14 2万+
DP协议学习笔记1 术语1.1 AUX Channel-辅助通道1.2 DPCD1.3 MSA和SDP2 连接时序2.1 HPD2.2 读取EDID2.3 Link Training（DPCD）2.4 HDCP 1 术语 1.1 AUX Channel-辅助通道 DP设有专用总线，即AUX Channel，用于source和sink之间的握手。因为source是过程的控制装置，它为sink提出请求。sink与source进行通信的唯一途径是在热插拔检测（HPD）信号中发出一个脉冲。 因为AUX Channe
数位DP详解和基础例题
shezjoe的博客
08-03 1126
转载自：http://www.cnblogs.com/itlqs/p/5935308.html 数位DP其实是很灵活的，所以一定不要奢求一篇文章就会遍所有数位DP的题，这一篇只能是讲清楚一种情况，其他情况遇到再总结，在不断总结中慢慢体会这个思想，以后说不定就能达到一看到题目就能灵活运用的水平。（其实DP都是这样……）   这一篇要说的数位DP是一道最简单的数位DP：HDU2089 　　　　...
数位DP练习题
竹摇清影照幽窗
06-12 896
文章目录T1 [ZJOI2010]数字计数T2 [SCOI2009]windy数T3 花神的数论题T4 [CQOI2016]手机号码T5 [HAOI2010]计数T6 吉哥系列故事——恨7不成妻T7 不要62T8 吉利数字 T1 [ZJOI2010]数字计数 题目描述 给定两个正整数a和b，求在[a,b]中的所有整数中，每个数码(digit)各出现了多少次。 输入输出格式 输入格式： 输入文件中...
数位dp模板
weixin_45798469的博客
08-09 236
typedeflonglongll; inta[20]; lldp[20][state];//不同题目状态不同 lldfs(intpos,/*state变量*/,boollead/*前导零*/,boollimit/*数位上界变量*/)//不是每个题都要判断前导零 { //递归边界，既然是按位枚举，最低位是0，那么pos==-1说...
数位Dp习题集
最新发布
scanner
10-03 190
数位Dp习题集
数位DP入门题——[hdu2089]不要62
weixin_30940783的博客
10-07 206
数位DP是我的噩梦。 现在初三了，却没AC过数位DP的题目。 感觉数位DP都是毒瘤…… 题目 hdu不用登录也可以进去，所以就不把题目copy...
【数位DP——题集及提示】
..
04-28 1217
4207 -- 【模拟试题】不要62    最简单数位DP 不解释 4600 -- 【模拟试题】迷信的黄学长   挺坑！注意有正反向两种连续，传递序列里是否有2,4这两个参数，另外还要传有没有连续，所以DFS到下一层时要写作  Is_four||i==4;   Is_two||i==8;    Is_continuous||((i==pre+2&&i==last+1)||(pre
【数位dp】题目汇总
andyc_03的博客
07-21 166
P2657 [SCOI2009] windy 数 模板 HDU 2089 不要62 模板 P2602 [ZJOI2010]数字计数 多了一个枚举0-9每个数字 P3413 SAC#1 - 萌数 回文串考虑+特殊读入 HDU 4705 恨7不成妻 平方和的计算
动态规划之数位DP专题（附题目清单）
剑锋OI SharpSwordOI
12-14 772
动态规划之数位DP专题
简单数位DP总结
CrystalDavid的博客
08-21 349
数位DP
C语言学习笔记：函数、运算符与位操作
"C语言学习笔记" C语言是一种广泛使用的编程语言，它的简洁性和高效性使得它在各种领域都有着广泛的应用。本笔记主要涵盖了C语言的基础知识，包括数据类型、运算符、控制结构以及输入输出等内容。 1. 数据类型 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值