数位dp记录

最新推荐文章于 2024-11-18 16:46:21 发布
最新推荐文章于 2024-11-18 16:46:21 发布
阅读量317 收藏 5
点赞数 3
文章标签： 算法 c++ 动态规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kyrietheshy/article/details/137234944
版权
文章讨论了在编程竞赛中遇到的数位动态规划问题，包括二维、三维的dp解决方案，如洛谷P3413SAC#1和CF55D/CF628D问题，展示了如何使用递归和优化技巧解决经典dp问题并避免内存溢出。
摘要由CSDN通过智能技术生成

学习了oiwiki的习题和数位dp，记录打卡一下。

都是比较经典的数位dp，感觉收益很大。

Ahoi2009 self 同类分布

经典的数位dp。

dp[20][200][200]，开三维dp，第一维表示位数的遍历，第二维表示当前所有数字的位数之和，第三位表示当前数字的模数。通过暴力去枚举所有有可能的和（9*len）。然后一起进行数位dp，从而求解出最终得数。

// #pragma GCC optimize(3)  //O2优化开启
#include<bits/stdc++.h>
using namespace std;
#define int long long
typedef long long ll;
typedef pair<int,int> PII;
const int mod=1e9+7;
const int MX=0x3f3f3f3f3f3f3f3f; 
// static char buf[100000],*pa=buf,*pd=buf;
// #define gc pa==pd&&(pd=(pa=buf)+fread(buf,1,100000,stdin),pa==pd)?EOF:*pa++
// inline int read()
// {
//     register int x(0);register char c(gc);
//     while(c<'0'||c>'9')c=gc;
//     while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=gc;
//     return x;
// }
int l,r;
int dp[20][200][200];
int a[50];
int query(int x){
    if(x==0)return 0;
    int len=0;
    while(x)a[++len]=x%10,x/=10;
    auto dfs=[&](auto self,int id,int f,int sum,int p,int sux)->int{
        if(id==0){
            return sum==p&&(sux==0);
        }
        if(f==0&&dp[id][sum][sux]!=-1)return dp[id][sum][sux];
        if(sum>p)return 0;
        int res=9;
        if(f)res=a[id];
        int cnt=0;
        for(int i=0;i<=res;i++){
            cnt+=self(self,id-1,f&(i==res),sum+i,p,(sux*10ll+i)%p);
        }
        return dp[id][sum][sux]=cnt;
    };    
    int ans=0;
    for(int i=1;i<=9*len;i++){
        memset(dp,-1,sizeof dp);
        ans+=dfs(dfs,len,1,0,i,0);
    }
    // cout<<ans<<"+++\n";
    return ans;

}
void icealsoheat(){
    cin>>l>>r;
    l--;
    cout<<query(r)-query(l);

}
signed main(){
    ios::sync_with_stdio(false);          //int128不能用快读！！！！！！
    cin.tie();
    cout.tie();
    int _yq;
    _yq=1;
    // cin>>_yq;
    while(_yq--){
        icealsoheat();
    }
}

洛谷 P3413 SAC#1 - 萌数

dp[1005][10][10][2]

我们需要记录当前位数的位置，的上一位以及上上位置的数据值，以及当前是否已经满足了对称的条件从而分别作为数位dp的四维，来进行数位dp。

// #pragma GCC optimize(3)  //O2优化开启
#include<bits/stdc++.h>
using namespace std;
#define int long long
typedef long long ll;
typedef pair<int,int> PII;
const int mod=1e9+7;
const int MX=0x3f3f3f3f3f3f3f3f; 
// static char buf[100000],*pa=buf,*pd=buf;
// #define gc pa==pd&&(pd=(pa=buf)+fread(buf,1,100000,stdin),pa==pd)?EOF:*pa++
// inline int read()
// {
//     register int x(0);register char c(gc);
//     while(c<'0'||c>'9')c=gc;
//     while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=gc;
//     return x;
// }
string l,r;
int dp[1005][11][11][3];
int a[10005];
int len;
int ui;
int query(string &x){
    // int len=0;
    len=0;
    for(int i=0;i<x.size();i++){
        a[++len]=x[i]-'0';
    }
    auto dfs=[&](auto self,int id,int f,int f0,int le,int lle,int p)->int{
        if(id>len){
            return p;
        }
        if(le!=-1&&!f&&dp[id][le][lle][p]!=-1)return dp[id][le][lle][p];
        int res=9;
        if(f)res=a[id];
        int cnt=0;
        for(int i=0;i<=res;i++){
            int yu=-1;
            if(f0|i)yu=i;
            cnt=(cnt+self(self,id+1,f&&(i==res),f0||(i!=0),yu,le,p||((i==le)&&f0)||((i==lle)&&f0)))%mod;
        }
        
        if(lle!=-1&&f0){
            dp[id][le][lle][p]=cnt;
        }
        return cnt;
    };
    

    memset(dp,-1,sizeof dp);

    int ans=dfs(dfs,1,1,0,-1,-1,0);

    return ans;

}
void icealsoheat(){
    cin>>l>>r;
    int an=0;
    for(int i=0;i<l.size();i++){
        if(i>0&&l[i]==l[i-1]){
            an=1;
        }
        if(i>1&&l[i]==l[i-2])an=1;
    }
    cout<<((query(r)-query(l)+an)%mod+mod)%mod;


}
signed main(){
    ios::sync_with_stdio(false);          //int128不能用快读！！！！！！
    cin.tie();
    cout.tie();
    int _yq;
    _yq=1;
    // cin>>_yq;
    while(_yq--){
        icealsoheat();
    }
}

CF55D Beautiful numbers

我觉得很有代表性的一道题。

最开始想过用vector和map去维护1到9的数位dp，但最后以失败告终。看了题解才发现，我们只需要处理出1到9的最小公倍数lcm就行了。

三维dp代表了位数，当前数取模2520的值，以及lcm。

此时位dp[18][2520][2020]，依旧会爆内存，但是我们可以发现，lcm一共有的数字不超过50个，我们需要提前预处理一下，可以把第三维优化成50。

与此同时，我们也不需要每一次都清空。我之前的数位dp都是正序遍历，并且每一次把dp值手动清空。但是这道题告诉我数位dp还是逆序遍历的好，逆序遍历在这道题中是可以不用每次都清空dp的值的，能大大减少时间复杂度（不然会t）。

#pragma GCC optimize(3)  //O2优化开启
#include<bits/stdc++.h>
using namespace std;
#define int long long
typedef long long ll;
typedef pair<int,vector<int>> PII;
const int mod=2520;
// const int MX=0x3f3f3f3f3f3f3f3f; 
// static char buf[100000],*pa=buf,*pd=buf;
// #define gc pa==pd&&(pd=(pa=buf)+fread(buf,1,100000,stdin),pa==pd)?EOF:*pa++
// inline int read()
// {
//     register int x(0);register char c(gc);
//     while(c<'0'||c>'9')c=gc;
//     while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=gc;
//     return x;
// }
 
string l,r;
int dp[20][2525][50];
int hh[2525];
int a[20];
void yu(){
    int idx=0;
    for(int i=1;i<=2520;i++){
        if(2520%i==0){
            hh[i]=++idx;
        }
    }
}
 
int LCM(int a,int b){
    return a*b/__gcd(a,b);
}
 
int query(string &x){
    int len=0;
    for(int i=x.size()-1;i>=0;i--){
        a[++len]=x[i]-'0';
    }
    // memset(dp,-1,sizeof dp);
    auto dfs=[&](auto self,int id,int f,int sum,int lcm)->int{
        if(!id)return sum%lcm==0;
        if(dp[id][sum][hh[lcm]]!=-1&&f==0)return dp[id][sum][hh[lcm]];
        int res=9;
        if(f)res=a[id];
        int ans=0;
        for(int i=0;i<=res;i++){
            int u=i?LCM(lcm,i):lcm;
            ans+=self(self,id-1,f&&(i==res),(sum*10+i)%mod,u);
        }
 
        if(f==0)dp[id][sum][hh[lcm]]=ans;
        return ans;
 
    };
    int ans= dfs(dfs,len,1,0,1);
    // cout<<ans<<"+++\n";
    return ans;
}
void icealsoheat(){
    cin>>l>>r;
    int an=0;
    vector<int>p(10,0);
    vector<int>ff(10,0);
    for(int i=0;i<l.size();i++){
        int x=l[i]-'0';
        ff[x]=1;
        for(int j=1;j<=9;j++){
 
                p[j]=(p[j]*10+x)%j;
 
        }
    }
    an=1;
    for(int i=1;i<=9;i++){
        if(p[i]&&ff[i]){
            an=0;
            break;
        }
    }
 
    // cout<<(query(r)-query(l)+an)<<"\n";
    printf("%lld\n",(query(r)-query(l)+an));
    // cin>>l;
    // query(l);
 
 
}
signed main(){
    ios::sync_with_stdio(false);          //int128不能用快读！！！！！！
    cin.tie();
    cout.tie();
    int _yq;
    _yq=1;
    cin>>_yq;
    memset(dp,-1,sizeof dp);
    yu();
    while(_yq--){
        icealsoheat();
    }
}

CF628D Magic Numbers

和之前的题很像，直接上代码

#pragma GCC optimize(3)  //O2优化开启
#include<bits/stdc++.h>
using namespace std;
#define int long long
typedef long long ll;
typedef pair<int,int> PII;
const int mod=1e9+7;
const int MX=0x3f3f3f3f3f3f3f3f; 
// static char buf[100000],*pa=buf,*pd=buf;
// #define gc pa==pd&&(pd=(pa=buf)+fread(buf,1,100000,stdin),pa==pd)?EOF:*pa++
// inline int read()
// {
//     register int x(0);register char c(gc);
//     while(c<'0'||c>'9')c=gc;
//     while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=gc;
//     return x;
// }
int m,d;
string L,R;
int dp[2005][2005];
void icealsoheat(){
    cin>>m>>d;
    cin>>L>>R;
    L=' '+L;
    R=' '+R;
    int cnt=0;
    auto dfs=[&](auto self,int id,int f,string &s,int sum)->int{
        if(id>=s.size()){
            return sum==0;
        }
        if(f==0&&dp[id][sum]!=-1)return dp[id][sum];
        int res=9;
        if(f)res=s[id]-'0';
        int bns=0;
        for(int i=0;i<=res;i++){
            if(i==d&&(id&1))continue;
            if(i!=d&&!(id&1))continue;
            int sux=(sum*10+i)%m;
            bns=(bns+self(self,id+1,f&(i==res),s,sux))%mod;
        }
 
        return dp[id][sum]=bns;
    };
 
    int ans=0;
    memset(dp,-1,sizeof dp);
    ans=dfs(dfs,1,1,R,0);
    // cout<<ans<<"++++\n";
    memset(dp,-1,sizeof dp);
    ans=(ans-dfs(dfs,1,1,L,0))%mod+mod;
    ans%=mod;
    // cout<<ans;
    bool ff=0;
    int summ=0;
    for(int i=1;i<L.size();i++){
        summ*=10;
        summ+=L[i]-'0';
        summ%=m;
        if(L[i]-'0'!=d&&!(i&1)){
            ff=1;
        }
        else if((i&1)&&L[i]-'0'==d)ff=1;
    }
    if(!ff&&summ==0)ans++;
    ans%=mod;
    cout<<ans;
 
}
signed main(){
    ios::sync_with_stdio(false);          //int128不能用快读！！！！！！
    cin.tie();
    cout.tie();
    int _yq;
    _yq=1;
    // cin>>_yq;
    while(_yq--){
        icealsoheat();
    }
}

数位DP - 带49的数
程序员阿甘的博客
12-02 1712
带49的数，数位DP
4.6.1 蓝桥杯动态规划之数位DP
tang7mj的博客
01-26 1093
数位DP是动态规划的一个重要分支，在处理数字的数位问题时非常有效。熟练掌握数位DP，对于编程竞赛和算法解题是非常有帮助的。希望本文能为你在学习数位DP的道路上提供一些指导和帮助。
数位DP模板
RBS的专栏
08-06 1060
数位DP问题数位DP指一类问题：给定正整数区间[s, e]，问符合条件的数一共有多少个。例如hdu2089以及hdu3555等。 其中，hdu2089的条件为数字中不含4且不含62，hdu3555的条件为数字中包含49。一般而言，这类条件中至少有一个是与整个数的数值无关的，而是与每一位的数字有关。例如上面2道题的条件就与整个数的数值无关。 因此这类问题实际上是数位有关的问题，另一方面，这类问题通
数位dp
cccccccj
11-17 1万+
原文地址： https://blog.csdn.net/brazy/article/details/77427699 觉得写得很不错~~ ============================= 数位dp是一种计数用的dp，一般就是要统计一个区间[le,ri]内满足一些条件数的个数。所谓数位dp，字面意思就是在数位上进行dp咯。数位还算是比较好听的名字，数位的含义：一个数有个位、十位、百位、千位...
数位DP总结
DIDCJS的博客
04-03 1617
数位DP基于动态的思想，记录状态以至于不用重复的计算，能够处理大规模的数 其时间复杂度为O（状态数*转移数） //状态数是dp数组的大小，转移数是for循环大小（这个时间我也不是很想得通，某大佬讲的。。） 基本模板如下： 基本的三种题型： 1）： 求1~n数字中包含某些数字特征的数量和（如数字子串中是否有13等） 2）：求1~n数字中各个位数相加能够整除某个数的数量和（如123各
数位DP专题
DS-K的博客
03-19 614
数位DP专题 通过做题总结出两种方法 1、根据相邻数位之间的关系递推 Dp[i][j] 以j开头的i位数中所含答案的数量。 可以通过递推先预处理好，然后再分情况统计。 一般可以分两种情况统计： 1、最高位不达到上限，每一位可以取任意值 Ans+=dp[len][i] i = [ 0 , digit[len]-1 ] Tips：如果前导零会对答案造成影响，应该
数位dp总结 之 从入门到模板
热门推荐
努力
08-03 7万+
for(int i=le;i<=ri;i++) if(right(i)) ans++; 基础篇 数位dp是一种计数用的dp，一般就是要统计一个区间[le,ri]内满足一些条件数的个数。所谓数位dp，字面意思就是在数位上进行dp咯。数位还算是比较好听的名字，数位的含义：一个数有个位、十位、百位、千位......数的每一位就是数位啦！ 之所以要引入数位的概念完全就是为了dp。
数位dp入门详解
CillyB的博客
02-19 4792
基础篇 数位dp是一种计数用的dp，一般就是要统计一个区间[le,ri]内满足一些条件数的个数。所谓数位dp，字面意思就是在数位上进行dp咯。数位还算是比较好听的名字，数位的含义：一个数有个位、十位、百位、千位......数的每一位就是数位啦！ 之所以要引入数位的概念完全就是为了dp。数位dp的实质就是换一种暴力枚举的方式，使得新的枚举方式满足dp的性质，然后记忆化就可以了。
数位dp(算法篇)
hellmorning的博客
09-23 1400
数位dp也就是将动态规划的思想放入到对数的每一位进行，也是一种动态规划的一种，本篇文章将会带大家简单学习一下
动态规划之数位dp
小L的博客
07-21 921
本篇博客主要介绍数位DP算法及其应用，包括数位DP的基本思想、常用模板以及实例分析。数位DP是一种巧妙的动态规划思路，通常用于计算某个数的某些特定数位上的特征，例如数位和、数字个数等。在文章中，我们将详细介绍数位DP方法的实现过程，包括从高到低递推、预处理等技巧。此外，我们还会提供多个案例分析，包括计算二进制中1的个数、计算区间[L,R]内数位和等。通过本篇博客的学习，读者能够掌握数位DP的基础知识，并能够迅速理解和解决各种数位DP问题。
数位dp算法详细图文解答
02-13
举例来说，如果我们寻找[0, 123456]中满足特定条件的数，可以使用数位DP记录每个状态的解。比如在处理第五位时，如果前一位是0，我们记录下这一状态下的方案数。当我们再次遇到相同的状态（第五位，前一位仍是0），...
数位dp——某次队内分享任务
07-21
数位动态规划(Digit Dynamic Programming, 简称数位DP)是一种在处理与数字相关的动态规划问题时，通过分析每个数字位上的状态来优化算法的技术。它通常用于解决涉及数字序列特性的数学问题，例如计数特定类型的数...
DAY63||拓扑排序精讲 |dijkstra（朴素版）精讲
2301_79865280的博客
11-14 713
某个大型软件项目的构建系统拥有 N 个文件，文件编号从 0 到 N - 1，在这些文件中，某些文件依赖于其他文件的内容，这意味着如果文件 A 依赖于文件 B，则必须在处理文件 A 之前处理文件 B （0 <= A, B <= N - 1）。请编写一个算法，用于确定文件处理的顺序。第一行输入两个正整数 N, M。表示 N 个文件之间拥有 M 条依赖关系。后续 M 行，每行两个正整数 S 和 T，表示 T 文件依赖于 S 文件。输出共一行，如果能处理成功，则输出文件顺序，用空格隔开。
java计算文本相似度算法总结
sunsiny
11-14 947
计算两个字符串之间的最小单字符编辑（插入、删除、替换）次数。这是一种衡量字符串差异性的方法，常用于拼写检查和模糊匹配。：一种基于 Jaro 相似度的改进算法，特别适用于拼写检查和模糊匹配。：计算两个字符串之间的最长公共子序列长度，常用于文本差异比较。：通过计算两个字符串的 n-gram 向量的余弦夹角来评估它们的相似度。：基于子串的字符串相似度计算方法，计算它们共有的Q-gram（长度为Q的连续子串）的数量，然后将这个数量除以两个字符串中Q-gram数量较少的那个，得到相似度的比例。
7-6 图的存储-邻接矩阵
2401_85947543的博客
11-18 252
输出给定图的邻接矩阵。
【循环测试试题3】小X与数字三角形
Lonely_Boos的博客
11-16 286
共n行，第i行包含i个正整数，每个整数占五列。读入一个正整数n，输出一个n行的数字三角形。一行一个正整数n，2
算法学习笔记（一）：滑动窗口和双指针
最新发布
Ice166的博客
11-18 724
1.入： 下标为 i 的元素进入窗口，更新相关统计量(因为一个元素进入了，则相关统计的数据要更新，就是+)，然后进行判断，如果i < k - 1 则continue，继续进入窗口，因为定长窗口元素不足；满足 0
论文《基于现实迷宫地形的电脑鼠设计》深度分析（四）——现实迷宫算法
大摆王的博客
11-18 667
《基于现实迷宫地形的电脑鼠设计》是由吴润强、庹忠曜等人于2023年发表的一篇优秀期刊论文。其针对现阶段电脑鼠计算量庞大且不适用于现实迷宫地形的问题，特基于超声波测距与传统迷宫算法原理，设计出一款可在现实迷宫地形下自动寻找出口的电脑鼠。该适用于岔路数量与道路宽度不定、多死路弯道并且相对较大的迷宫地形，具有适应性强、计算量小、兼容性和可塑性强等优点，对于现实迷宫地形下的自动应用具有一定研究价值。该论文内容相对较多，特对其进行拆开分析，本文特围绕智能车设计方案进行展开分析。
算法刷题集合
Tsmall_的博客
11-17 333
CCF：CCF-CSP认证题解集1（较新）：题解2（较老）：洛谷刷题：NOIP：ICPC-约瑟夫环：POJ：题解：POJ和HDU：HDU与（acm）：
数位DP解决区间统计问题入门
"这篇PPT主要介绍了数位动态规划（数位DP）在解决数位类统计问题中的应用，涉及到二进制和异或运算。通过具体的题目实例，如Hdu2089，讲解了如何运用数位DP来解决这类问题。" 本文将深入探讨数位动态规划（数位DP）...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值