数位DP习题

已于 2022-12-27 16:10:50 修改
阅读量411 收藏
点赞数
分类专栏： 动态规划 文章标签： 深度优先 算法 图论
于 2022-10-31 21:25:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53203911/article/details/127623785
版权

1.度的数量

#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
const int N=35;
int f[N][N];
using namespace std;
int l,r,k,b;
int dp(int n){
    vector<int>v;
    while(n){
        v.push_back(n%b);
        n=n/b;
    }
    int last=0,res=0;
    for(int i=v.size()-1;i>=0;i--){
        int num=v[i];
        if(num>0){  
            res+=f[i][k-last];  // 当前位置取0，且限制大于0 剩下的数字可以随便选
            //下面是当前位置选1
            if(num>1){   //如果当前位置限制大于1，则当前位置选1后，后面的数选择没有限制
            //直接从剩下的位置中选出来剩下来的1即可
            //注意这里last不能直接++，下面还会用到last如果直接++的话，会影响下面的判断
                if(k-last-1>=0) res+=f[i][k-last-1];
                break;
            }
            else {   // 当前位置的限制正好等于1，则当前位置选1后，后面的数有限制（如果随便选的话
            //有可能大于n） ，所以要继续枚举
                last++;//当前位置选1
                if(last>k) break;// 如果发现当前位置选1后超出限定个1，则不合法,直接break
            }
        }
        if(!i&&k==last) res++;  // 这种情况只会发生在取到最后一位数字，最后一位数字恰好为0
        //且前面刚好取了k个1,如果最后一位数字大于0且前面已经取完了k个1，那么这种方案会在第19行加上
    }
    return res;
}
void init(){
    for(int i=0;i<N;i++){
        for(int j=0;j<=i;j++){
            if(!j) f[i][j]=1;
            else f[i][j]=f[i-1][j-1]+f[i-1][j];
        }
    }
}
int main(){
    cin >>  l >> r >> k >> b;
    init();
    cout << dp(r)-dp(l-1);
    return 0;
}

参考题解

//记忆化搜索做法
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=35;
int f[N][N];//f[i][j]=k 从前i位中选 且已选1的个数为j的方案数为k(不贴合状态下)
int l,r,k,b;
int a[N];
int dfs(int i,int j,bool limit){ // 当前枚举到第i个数 且 已经选了j个1，当前贴合状态为limit
    //if(j>k) return 0;
    if(i==0){ // 数枚举完了
        if(j==k) return 1;  // 如果符合题意，说明当前方案数有效，返回1
        else return 0;
    }
    if(!limit&&f[i][j]!=-1){  //如果当前不贴合 而且f[i][j] 已经计算过了 则直接记忆化操作
        return f[i][j];
    }
    int res=0,m;
    if(limit){ //如果贴合则当前位数只能取到当前位的最大值 比如a[i]=6 第i位只能取到6，如果不贴合可以取到9
        m=min(1,a[i]);
    }
    else {
        m=1;  // 不贴合 m本可以取到9 但是本题取大于1的数字无意义 所以取到1
    }
    for(int op=0;op<=m;op++){
      //  if ((op == 1 && j == k) || op > 1) continue;
        res+=dfs(i-1,j+(op==1),limit&&(op==a[i]));
    }
    if(!limit){
        return f[i][j]=res;
    }
    else {
        return res;
    }
}
int dp(int n){
    memset(f,-1,sizeof f);
    int cnt=0;
    while(n) {
        a[++cnt]=n%b;
        n=n/b;
    }
    return dfs(cnt,0,1);
}
int main(){
    cin >> l >> r >> k >> b;
    cout << dp(r)-dp(l-1);
    return 0;
}

参考题解
参考题解
参考题解

2.数字游戏

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=50;
int l,r;
int a[N],f[N][N];//表示前i个数且最后一位是j的符合题意的个数比如f[2][3]=5 表示 x3xxxxx 符合题意的有5种
int dfs(int i,int j,bool limit){
    if(i==0){
        return 1;
    }
    if(!limit&&f[i][j]!=-1) return f[i][j];
    int res=0,m;
    if(limit){
        m=a[i];
    }
    else {
        m=9;
    }
    for(int op=0;op<=m;op++){
        if(op<j) continue;
        res+=dfs(i-1,op,limit&&(op==a[i]));
    }
    if(limit){
        return res;
    }
    else {
        return f[i][j]=res;
    }
}
int dp(int n){
    int cnt=0;
    memset(f,-1,sizeof f);
    while(n){
        a[++cnt]=n%10;
        n=n/10;
    }
    return dfs(cnt,0,1);
}
int main(){
    while(cin >> l >> r){
       // cout << dp(r) << "here";
        cout << dp(r)-dp(l-1) << endl;
    }
    return 0;
}

3.Windy数

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=35;
int f[N][N][2]; // f[i][j][1]=k 表示前i位最后一位是j且含有前导0(即前面一位是0)的方案
int l,r;
int a[N];
int dfs(int i,int j,bool limit,int lead){
    if(i==0) return 1;
    if(!limit&&f[i][j][lead]!=-1) return f[i][j][lead];
    int res=0,m=(limit)?a[i]:9;
    for(int op=0;op<=m;op++){
        if(lead||abs(op-j)>1) res+=dfs(i-1,op,limit&&op==a[i],lead&&op==0);
    }
    return limit?res:f[i][j][lead]=res;
}
int dp(int n){
    int cnt=0;
    memset(f,-1,sizeof f);
    while(n){
        a[++cnt]=n%10;
        n=n/10;
    }
    return dfs(cnt,0,1,1);
}
int main(){
    cin >> l >> r;
    cout << dp(r)-dp(l-1);
    return 0;
}

4.数字游戏2

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=35;
int f[N][110];
int l,r,mod;
int a[N];
int dfs(int i,int j,int limit){
    if(i==0) {
        if(j==0) return 1;
        else return 0;
    }
    if(!limit&&f[i][j]!=-1) return f[i][j];
    int res=0,m=limit?a[i]:9;
    for(int op=0;op<=m;op++){
        res+=dfs(i-1,(j+op)%mod,limit&&(op==a[i]));
        //cout <<i<<" "<<op<<" "<< res <<" "<<m<< endl;
    }
    return limit?res:f[i][j]=res;
}
int dp(int n){
    memset(f,-1,sizeof f);
    int cnt=0;
    while(n){
        a[++cnt]=n%10;
        n=n/10;
    }
    return dfs(cnt,0,1);
}
int main(){
    while(cin>>l>>r>>mod){
    cout << dp(r)-dp(l-1) << endl;}
    return 0;
}

5.不要62

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=35;
int l,r;
int a[N];
int f[N][N];
int dfs(int i,int j,int last,int limit){
    if(i==0) return 1;
    if(!limit&&f[i][j]!=-1) return f[i][j];
    int res=0,m=limit?a[i]:9;
    for(int op=0;op<=m;op++){
        if(op==4||(op==2&&last==6)) continue;
        res+=dfs(i-1,op,op,limit&&a[i]==op);
    }
    return limit?res:f[i][j]=res;
}
int dp(int n){
    int cnt=0;
    memset(f,-1,sizeof f);
    while(n){
        a[++cnt]=n%10;
        n=n/10;
    }
    return dfs(cnt,0,0,1);
}
int main(){
    while(cin >>l >> r){
    if(l!=0&&r!=0) cout << dp(r)-dp(l-1)<<endl;}
    return 0;
}

6.恨7不成妻

// f[i][j][k]={cnt,sum,sum2} 表示前i位每位数字之和%7为j,前i位所组成的数字%7为k,在满足
// i,j,k的条件下 第i-1位至第最后一位所能组成的无关7的个数为cnt,第i-1位至第最后一位所能组成的无关7的数的
//和为sum,第i-1位至第最后一位所能组成的无关7的数的平方和为sum2
//Q1: 怎么由后i-1位的无关数的和推出后i位无关数的和？
// res.sum+=tmp.cnt*B+tmp.sum;  (B为10的i次幂)
//Q2: 怎么由后i-1位的无关数的平方和推出后i位无关数的平方和？
// res.sum2+=tmp.cnt*B^2+tmp.sum2+2*B*tmp.sum
#include<iostream>
#include<cstring>
#include<algorithm>
#define int long long
using namespace std;
const int N=22,mod=1e9+7;
struct node{
    int cnt=0,sum,sum2;
}f[N][10][10];
int t,l,r;
int p[N];
int a[N];
node dfs(int i,int j,int k,int limit){
    if(i==0){
        if(j!=0&&k!=0) return {1,0,0};
        else return {0,0,0};
    }
    if(!limit&&f[i][j][k].cnt!=-1) return f[i][j][k];
    node res={0,0,0};   // 记得初始化
    int m=limit?a[i]:9;
    for(int op=0;op<=m;op++){
        if(op==7) continue;                                    //发现了一件事情 关于取余
        node tmp=dfs(i-1,(j+op)%7,(k*10+op)%7,limit&&op==a[i]);    // (k%7*10+op)%7==(k*10+op)%7 (k<=6)
        (res.cnt+=tmp.cnt)%=mod;
        int B=op*p[i-1]%mod;
        (res.sum+=tmp.cnt*B%mod+tmp.sum)%=mod;
        (res.sum2+=tmp.cnt*B%mod*B%mod+tmp.sum2%mod+2*B%mod*tmp.sum%mod)%=mod;
    }                                                      
    return limit?res:f[i][j][k]=res;
}
int dp(int n){
    int cnt=0;
    memset(f,-1,sizeof f);
    while(n){
        a[++cnt]=n%10;
        n=n/10;
    }
    return dfs(cnt,0,0,1).sum2;
}
signed main(){
    cin >> t;
    p[0]=1;
    for(int i=1;i<N;i++) p[i]=(10*p[i-1])%mod; // p[i]=10^i;
    while(t--){
        int l,r;
        cin >> l >> r;
        cout << (dp(r)-dp(l-1)+mod)%mod << endl;
    }
    return 0;
}

参考题解

7.计数统计

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=35;
int l,r;
struct node{
    int a=0,b=0,c=0,d=0,e=0,f=0,g=0,h=0,i=0,j=0,cnt=0;
}f[N][2];  //f[i].c 表示的是从i位到最后一位所含有的2的数量，f[i].cnt表示的是从i位到最后一位所能组成的所有数的个数
int a[N];  //f[i].c= 从第i-1位到最后一位含有2的数量+从第i-1位到最后一位所能组成数的个数
// 比如统计1XXX中含有1的个数  那么就是XXX中含有1个数 加上 i-1位到最后一位所能组成数的个数   
node dfs(int i,int limit,int lead){
    if(i==0) return {0,0,0,0,0,0,0,0,0,0,1};
    if(!limit&&f[i][lead].a!=-1) return f[i][lead];
    node res={0,0,0,0,0,0,0,0,0,0,0};
    int m=limit?a[i]:9;
    for(int op=0;op<=m;op++){
        node tmp=dfs(i-1,limit&&op==a[i],lead&&op==0);
        if(op==0&&lead!=1) res.a+=tmp.cnt;
        else if(op==1) res.b+=tmp.cnt;
        else if(op==2) res.c+=tmp.cnt;
        else if(op==3) res.d+=tmp.cnt;
        else if(op==4) res.e+=tmp.cnt;
        else if(op==5) res.f+=tmp.cnt;
        else if(op==6) res.g+=tmp.cnt;
        else if(op==7) res.h+=tmp.cnt;
        else if(op==8) res.i+=tmp.cnt;
        else if(op==9) res.j+=tmp.cnt;
        res.a+=tmp.a;
        res.b+=tmp.b;
        res.c+=tmp.c;
        res.d+=tmp.d;
        res.e+=tmp.e;
        res.f+=tmp.f;
        res.g+=tmp.g;
        res.h+=tmp.h;
        res.i+=tmp.i;
        res.j+=tmp.j;
        res.cnt+=tmp.cnt;
    }
    return limit?res:f[i][lead]=res;
}
node dp(int n){
    int cnt=0;
    memset(f,-1,sizeof f);
    memset(a,0,sizeof a);
    while(n){
        a[++cnt]=n%10;
        n=n/10;
    }
    return dfs(cnt,1,1);
}
int main(){
    while(cin>>l>>r){
        if(l==0&&r==0) break;
        if(l>r) swap(l,r);
        node tmpl=dp(l-1);
        node tmpr=dp(r);
        cout << tmpr.a-tmpl.a<<" "<< tmpr.b-tmpl.b<<" "<< tmpr.c-tmpl.c<<" "<< tmpr.d-tmpl.d<<" "<< tmpr.e-tmpl.e<<" "<< tmpr.f-tmpl.f<<" "<< tmpr.g-tmpl.g<<" "<< tmpr.h-tmpl.h<<" "<< tmpr.i-tmpl.i<<" "<< tmpr.j-tmpl.j<<" "<<endl;
    }
    return 0;
}




#include <iostream>
#include <cstring>
using namespace std;

const int N = 10;

int l, r;
int a[N], f[N][N];

//sum表示前面已经有了多少个x,前面的sum+后面的记忆化过的f[n][n]就是一个数中含x的数量
//这种思路其实就是穷举每一个数 看看每一个数里面有多少个1 或者其他的
// 比如12341(假设最后一位上限为1) 枚举完了 含有2个1
//     12340           枚举完了含有一个1
//那么 1234_这种一共含有3个1 即f[5][1]=3
// 如果我枚举到了1235_ 则可以直接返回3了 不必再枚举了
int dfs(int pos, int sum, int x, int lead, int limit)
{
    if (!pos)
        return sum;
    if (!limit && !lead && ~f[pos][sum])
        return f[pos][sum];

    int res = 0, up = limit ? a[pos] : 9;
    for (int i = 0; i <= up; ++i)
        if ((!lead || i) && (i == x)) 
            res += dfs(pos - 1, sum + 1, x, lead && !i, limit && i == up);
        else
            res += dfs(pos - 1, sum, x, lead && !i, limit && i == up);
    //什么时候能把当前填入的数计算进去呢？
    //1. 有前导0，但是当前数不为0，且计的数位和当前数相等，可以算进去，比如01____，1的个数+1
    //2. 有前导0，但是当前数为0，且计的数位和当前位相等，不能算进去，比如00_____，前面两个不算0的个数
    //3. 无前导0，当前数可以为0可以不为0，且计的数位和当前位相等，可以算进去，比如10___，可以算0的个数

    if (!limit && !lead)
        f[pos][sum] = res;
    return res;
}



int dp(int x, int i)
{
    memset(f, -1, sizeof(f));
    int len = 0;
    while (x)
        a[++len] = x % 10, x /= 10;
    return dfs(len, 0, i, 1, 1);
}

int main()
{
    while (cin >> l >> r, l || r)
    {        
        if (l > r)
            swap(l, r);
        for (int i = 0; i <= 9; ++i)
            cout << dp(r, i) - dp(l - 1, i) << ' ';
        puts("");
    }
    return 0;
}
究极无敌暴龙战神
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
动态规划 -> 数位dp习题
weixin_43145397的博客
05-06 141
使用条件 区间内，满足某条件的数。 分情况讨论 分位 树上讨论
数位dp练习题
UniverseofHK的博客
06-08 572
随便记录几个题， 防止连数位dp的思路都忘了，2333 数位dp 先将上限各位保存到num数组 从高位到低位dfs（暴力） 记忆化，优雅的暴力，否则就是O(n)的算法了，对单个数据也有很大的加速 pos为-1时以及记忆存在时可直接返回 关键：时刻记住判断条件，做到不重不漏 HDU 3652 B-number B-number Time Limit: 2000/1000 MS (Java/Oth...
数位dp习题
Harris-H的博客
12-14 546
P2657 [SCOI2009] windy 数 思路：数位dpdpdp。 常用模板：四个参数x,pre,lead,lix,pre,lead,lix,pre,lead,li。 x:x:x: 当前遍历到第几位(从高位开始)。 pre:pre:pre: 当前位的前一位是什么，不同题目的preprepre可能不同。 lead:lead:lead: 当前位前面是否有前导0. li:li:li: 是否为最高位。 记忆化搜索。 令dp[i][j]dp[i][j]dp[i][j]表示位数为iii且前一个数为jjj的答案，
数位Dp习题集
scanner
10-03 176
数位Dp习题集
数位dp习题整理——codeforces
qq_43653111的博客
02-25 621
数位dp习题整理——codeforces 1.1800 题意： 给出一个二进制数n，每次操作可以将这个数变为其二进制数位上所有1的和(3->2 ; 7->3)，现在给出了一个数k，问不大于n的数中有几个数经过k次操作可以变成1。 思路： 从题中我们可以看到，一次操作可以将一个数变化为其二进制 1 的个数，于是我们设 f[i] 表示二进制中有 i 个 1 的数需要几次变化才能到达 1 。...
数位DP入门
08-22
数位DP入门思想，包括详细的思考过程以及一些习题的讲解
华为-华为od题库练习题之求最大连续bit数.zip
最新发布
05-17
本压缩包文件"华为-华为od题库练习题之求最大连续bit数.zip"显然包含了一道与华为OD相关的练习题目，其主要目标是找到一个二进制数中最大连续的1（或0）的个数。这个问题在计算机科学中属于基础算法的范畴，对理解和...
华为od-华为od练习题之求最大连续bit数-题库题解.zip
05-08
在准备华为OD的练习题时，考生需要熟练掌握基础的编程语言，理解数据结构和算法，并能灵活运用到实际问题中。通过不断地练习和挑战，可以提高对复杂问题的分析和解决能力，这对于在IT行业中取得成功至关重要。
计算机算法设计与分析练习题.docx
03-13
【计算机算法设计与分析练习题】 一．最大子段和问题 最大子段和问题是寻找一个整数序列中连续子序列的和的最大值。这里给出了一个简单的算法： ```cpp int Maxsum(int n, int a[], int& besti, int& bestj) { ...
计算机算法设计与分析练习题 .docx
03-16
- 带权中位数的计算可以通过排序后选取权值的累积和达到中位数的位置来实现，时间复杂度为O(n log n)。 - 证明不带权的中位数是带权中位数，可以基于排序后的权值累积和进行比较。 3. **一维邮局问题**： - 这是...
数位DP详解和基础例题
shezjoe的博客
08-03 1117
转载自：http://www.cnblogs.com/itlqs/p/5935308.html 数位DP其实是很灵活的，所以一定不要奢求一篇文章就会遍所有数位DP的题，这一篇只能是讲清楚一种情况，其他情况遇到再总结，在不断总结中慢慢体会这个思想，以后说不定就能达到一看到题目就能灵活运用的水平。（其实DP都是这样……）   这一篇要说的数位DP是一道最简单的数位DP：HDU2089 　　　　...
数位DP算法概述及习题
Gene_I must wait for the sunrise
11-02 1610
数位DP系列习题 1. Daniel and Spring Cleaning 题意: 给出区间 [l,r][l,r][l,r]，查询多少对 (a,b)(a,b)(a,b) 满足如下条件。(0≤l≤r≤109)(0\leq l\leq r\leq 10^9)(0≤l≤r≤109) a+b=a xor ba+b=a \ xor \ ba+b=a xor b l...
数位DP 小讲 【 理解 + 例题 】 更新 ing......
Joursion
07-24 872
因为.....因为..... 太久没更新博客了，自己 也
数位dp总结 之 从入门到模板
热门推荐
努力
08-03 7万+
for(int i=le;i<=ri;i++) if(right(i)) ans++; 基础篇 数位dp是一种计数用的dp，一般就是要统计一个区间[le,ri]内满足一些条件数的个数。所谓数位dp，字面意思就是在数位上进行dp咯。数位还算是比较好听的名字，数位的含义：一个数有个位、十位、百位、千位......数的每一位就是数位啦！ 之所以要引入数位的概念完全就是为了dp。
数位DP总结+例题
不二君
02-23 1084
学了数位DP很久了，今天就简单的总结一下吧。 一、什么是数位DP 数位DP简单来说是一种统计数的DP，该类题一般可以用暴力写出来，但是由于数据太大，一般会超时。数位DP一般是统计[l,r]中满足题中要求的数的个数，至于为什么称为数位DP，因为要对数的每一位进行讨论（个位，十位，百位……）。数位DP一般有两种写法，一种是循环，另一种是递归。通常用循环写，比较的麻烦，所以我们一般都是用递归来写...
数位DP练习题
竹摇清影照幽窗
06-12 879
文章目录T1 [ZJOI2010]数字计数T2 [SCOI2009]windy数T3 花神的数论题T4 [CQOI2016]手机号码T5 [HAOI2010]计数T6 吉哥系列故事——恨7不成妻T7 不要62T8 吉利数字 T1 [ZJOI2010]数字计数 题目描述 给定两个正整数a和b，求在[a,b]中的所有整数中，每个数码(digit)各出现了多少次。 输入输出格式 输入格式： 输入文件中...
数位DP 题集
671coder的专栏
06-17 9133
数位DP 题集 /*-------------------------------------------------------------------------*/ 常用数位DP写法： int dfs(int i, int s, bool e) { if(i==-1) return s==target_s; if(!e && ~f[i][s]) re
背包问题 动态规划
m0_53203911的博客
03-31 6061
背包问题核心 优化一般就是优化状态转移方程 01背包问题 有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。 第 i 件物品的体积是 vi，价值是 wi。 求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。 输出最大价值。 输入格式 第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。 接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i 件物品的体积和价值。 输出格式 输出一个整数，表示最大价值。 数据范围 0<N,V≤1000 0
背包类题型
m0_53203911的博客
02-13 490
宠物小精灵之收服 //二维费用的01背包，值得注意的是 我们平常做题时，费用可以为0，即是范围为0~v //，本题限制了费用不能为0，即范围是1~v那么我们只需要改变一下范围就好了即 //变为 0~v-1 就可以直接套用模板了 #include<bits/stdc++.h> using namespace std; int n,m,k; int use[1010],hurt[1010]; int f[1010][510]; int main(){ cin >> m >
数位dp模板
05-27
数位 DP 是一类动态规划算法，用于计算某个数的某种性质。通常情况下，数位 DP 需要将数分解成某种形式，然后逐位进行计算。下面是一个简单的数位 DP 模板： ```python def digit_dp(pos, sum, limit): if pos == ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值