数位DP合集

最新推荐文章于 2019-07-31 16:53:12 发布
最新推荐文章于 2019-07-31 16:53:12 发布
阅读量926 收藏
点赞数
分类专栏： ACM之路 文章标签： ACM C++ dp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013912596/article/details/45227829
版权

1.HDU 4722 good numbers：

题意：给出一个区间【A,B】，求出区间内有多少个数的各位的和加起来模10等于0的数有多少个。

解法：这是一个数位DP简单入门题，简单的DFS+数组记忆化搜索就可以。姿势是自己写的。。感觉略搓，做到第三个数位DP题的时候看到了别人的姿势，学习了。

代码：

#include <iostream>
#include <cstdio>
#include <stack>
#include <cstring>
#include <queue>
#include <algorithm>
#include <cmath>
//#include <unordered_map>
#define N 22
using namespace std;
typedef pair<long long,long long> PII;
const long long INF=0x3f3f3f3f;
void Open()
{
    #ifndef ONLINE_JUDGE
        freopen("D:/in.txt","r",stdin);
        //freopen("D:/my.txt","w",stdout);
    #endif // ONLINE_JUDGE
}

long long dit[N];
long long dp[N][N][3];
long long dfs(long long idx,long long mod,bool limit,long long edidx)
{
    if(dp[idx][mod][limit]!=-1)
        return dp[idx][mod][limit];
    if(idx==edidx+1)
    {
        if(mod%10==0)
        {
            //cout<<1<<endl;
            return dp[idx][mod][limit]=1;
        }
        return dp[idx][mod][limit]=0;
    }

    long long ret=0;

    for(long long i=0;i<= (limit?dit[edidx-idx]:9);i++)
    {
        ret+=dfs(idx+1,(mod+i)%10,limit && i==dit[edidx-idx],edidx);
    }
    return dp[idx][mod][limit]=ret;
}

long long getval(long long x)
{
    long long ditnum=0;
    memset(dp,-1,sizeof dp);
    while(x)
    {
        dit[ditnum++]=x%10;
        x/=10;
    }
    return dfs(1,0,1,ditnum);
}

int main()
{
    Open();
    long long T;
    scanf("%I64d",&T);
    int cas=1;
    while(T--)
    {
        long long a,b;
        scanf("%I64d%I64d",&a,&b);
        bool flag=false;
        long long ta=a;
        long long tmp=0;
        while(ta)
        {
            tmp+=(ta%10);
            ta/=10;
        }
        //cout<<tmp<<endl;
        if(tmp%10==0) flag=1;
        printf("Case #%d: %I64d\n",cas++,getval(b)-getval(a)+flag);
    }
    return 0;
}



2.HDU 3555 Bomb

题意："49"连在一起的数是good number，现在给你一个区间，让你找出区间中有多少个good number。

解法：仍然是一个简单数位DP，将上面一题的代码随便改改就可以过了。

代码：

#include <iostream>
#include <cstdio>
#include <stack>
#include <cstring>
#include <queue>
#include <algorithm>
#include <cmath>
//#include <unordered_map>
#define N 22
using namespace std;
typedef pair<long long,long long> PII;
const long long INF=0x3f3f3f3f;
void Open()
{
    #ifndef ONLINE_JUDGE
        freopen("D:/in.txt","r",stdin);
        //freopen("D:/my.txt","w",stdout);
    #endif // ONLINE_JUDGE
}

long long dit[N];
long long dp[N][3][3][3];
long long dfs(long long idx,bool ppre,long long pre,bool limit,long long edidx)
{
    if(dp[idx][ppre][pre][limit]!=-1)
        return dp[idx][ppre][pre][limit];

    if(idx==edidx+1)
    {
        if(ppre && pre == 1)
        {
            return dp[idx][ppre][pre][limit]=1;
        }
        return dp[idx][ppre][pre][limit]=0;
    }
    if(ppre && pre == 1)
    {
        long long cur=10;
        if(limit){
            int tmpidx=idx;
            cur=dit[edidx-idx];
            while(++tmpidx<=edidx)
            {
                cur*=10;
                cur+=dit[edidx-tmpidx];
            }
            cur++;
        }else{
            int tmpidx=idx;
            while(++tmpidx<=edidx)
            {
                cur*=10;
            }
        }
        return dp[idx][ppre][pre][limit]=cur;
    }

    long long ret=0;

    for(long long i=0;i <= (limit?dit[edidx-idx]:9);i++)
    {
        long long flag=0;
        if(i==4) flag=2;
        if(i==9) flag=1;
        ret+=dfs(idx+1,pre==2,flag,limit && i==dit[edidx-idx],edidx);
    }
    return dp[idx][ppre][pre][limit]=ret;
}

long long getval(long long x)
{
    long long ditnum=0;
    memset(dp,-1,sizeof dp);
    while(x)
    {
        dit[ditnum++]=x%10;
        x/=10;
    }
    return dfs(1,0,0,1,ditnum);
}

int main()
{
    Open();
    long long T;
    scanf("%I64d",&T);
    while(T--)
    {
        long long a;
        scanf("%I64d",&a);
        printf("%I64d\n",getval(a));
    }
    return 0;
}


3.HDU 2089 不要62

题意：数字中有“4”或者“62”的数字是不吉利数字，仍然是给出一个区间，让我们求出有多少个吉利的数字。

解法：仍然是简单的数位DP。改改代码就过了。。

代码：

#include <iostream>
#include <cstdio>
#include <stack>
#include <cstring>
#include <queue>
#include <algorithm>
#include <cmath>
//#include <unordered_map>
#define N 22
using namespace std;
typedef pair<long long,long long> PII;
const long long INF=0x3f3f3f3f;
void Open()
{
    #ifndef ONLINE_JUDGE
        freopen("D:/in.txt","r",stdin);
        //freopen("D:/my.txt","w",stdout);
    #endif // ONLINE_JUDGE
}

long long dit[N];
long long dp[N][4][4][2];
long long dfs(long long idx,bool ppre,long long pre,bool limit,long long edidx)
{
    if(dp[idx][ppre][pre][limit]!=-1)
        return dp[idx][ppre][pre][limit];

    if(idx==edidx+1)
    {
        if((ppre && pre == 1) || pre==3)
        {
            //cout<<"1idx,ppre,pre,limit val "<<idx<<" "<<ppre<<" "<<pre<<" "<<limit<<" "<<1<<endl;
            return dp[idx][ppre][pre][limit]=1;
        }
        ///cout<<"2idx,ppre,pre,limit val "<<idx<<" "<<ppre<<" "<<pre<<" "<<limit<<" "<<0<<endl;
        return dp[idx][ppre][pre][limit]=0;
    }
    if((ppre && pre == 1) || pre==3)
    {
        long long cur=10;
        if(limit){
            int tmpidx=idx;
            cur=dit[edidx-idx];
            while(++tmpidx<=edidx)
            {
                cur*=10;
                cur+=dit[edidx-tmpidx];
            }
            cur++;
        }else{
            int tmpidx=idx;
            while(++tmpidx<=edidx)
            {
                cur*=10;
            }
        }
        //cout<<"3idx,ppre,pre,limit val "<<idx<<" "<<ppre<<" "<<pre<<" "<<limit<<" "<<cur<<endl;
        return dp[idx][ppre][pre][limit]=cur;
    }

    long long ret=0;

    for(long long i=0;i <= (limit?dit[edidx-idx]:9);i++)
    {
        long long flag=0;
        if(i==6) flag=2;
        if(i==2) flag=1;
        if(i==4) flag=3;
        ret+=dfs(idx+1,pre==2,flag,limit && i==dit[edidx-idx],edidx);
        //ret+=dfs(idx+1,pre,i,limit && i==dit[edidx-idx],edidx);
    }
    //cout<<"4idx,ppre,pre,limit val "<<idx<<" "<<ppre<<" "<<pre<<" "<<limit<<" "<<ret<<endl;
    return dp[idx][ppre][pre][limit]=ret;
}

long long getval(long long x)
{
    long long ditnum=0;
    memset(dp,-1,sizeof dp);
    while(x)
    {
        dit[ditnum++]=x%10;
        x/=10;
    }
    return dfs(1,0,0,1,ditnum);
}

int main()
{
    Open();
    long long n,m;
    while(~scanf("%I64d%I64d",&n,&m) && (n||m))
    {
        //cout<<a<<endl;
        printf("%I64d\n",m-n+1-getval(m)+getval(n-1));
    }
    return 0;
}

4.HDU 4734 F(x)

题意：定义： F(x) = A  n  * 2  n-1  + A  n-1  * 2  n-2  + ... + A  2  * 2 + A  1  * 1.   给出A，B，问0~B中有多少个数不大于F(A)。
解法：注意到此题的数据组数非常巨大（10000组），所以我们如果再用上面两种方法的时候就会T，因为在上面的方法中，dp记忆化搜索数组将“limit”这个值也计算进 去了，也就是说，每一组数据的dp数组我们都要重新初始化，重新计算。当我观察了别的菊苣的代码之后，发现原来数位DP正确的姿势应该不是我那样的，而是 DP数组能够利用在不同的数据组中，也就是说多组数据的时候，我们也不用每次都将DP数组初始化。如此，我们的复杂度便到了可接受的地步。

回到正题，我们要求0~B中有多少个数小于F(A)的话，当然首先得将F(A)算出来，在DFS过程中，我们记录idx,sum,limit，idx表示当前是第几位，sum表示前idx位 的和，而limit的作用不再赘述，大家都懂。此时的复杂度比较小。O(idx*sum)是可以接受的。
代码： 
#include <iostream>
#include <cstdio>
#include <stack>
#include <cstring>
#include <queue>
#include <algorithm>
#include <cmath>
//#include <unordered_map>
#define N 21
using namespace std;
typedef pair<long long,long long> PII;
const long long INF=0x3f3f3f3f;
void Open()
{
    #ifndef ONLINE_JUDGE
        freopen("D:/in.txt","r",stdin);
        //freopen("D:/my.txt","w",stdout);
    #endif // ONLINE_JUDGE
}
long long valA;
long long dit[N];
long long dp[N][11110];
long long dfs(long long idx,long long sum,bool limit)
{
    if(sum<0) return 0;

    if(idx == -1)
    {
        return sum>=0;
    }

    if(!limit && dp[idx][sum]!=-1)
        return dp[idx][sum];

    long long ret=0;

    int ed=limit?dit[idx]:9;
    for(long long i=0;i <= ed;i++)
    {
        ret+=dfs(idx-1,sum-i*(1<<idx),limit && i==dit[idx]);
    }
    if(!limit)
        return dp[idx][sum]=ret;
    return ret;
}

long long getval(long long x)
{
    long long ditnum=0;
    while(x)
    {
        dit[ditnum++]=x%10;
        x/=10;
    }
    return dfs(ditnum-1,valA,1);
}

int main()
{
    Open();
    long long T;
    scanf("%I64d",&T);
    long long n,m;
    long long cas=1;
    memset(dp,-1,sizeof dp);
    while(T--)
    {
        scanf("%I64d%I64d",&n,&m);
        valA=0;
        int dig=0;
        while(n)
        {
            valA+=(n%10)*(1<<dig);
            dig++;
            n/=10;
        }
        printf("Case #%I64d: %I64d\n",cas++,getval(m));
    }
    return 0;
}


5.HDU 4389 X mod f(x)

题意：还是给出一个区间【A,B】，求出区间内有多少个数x满足 X mod f(X) ==0。其中F(x)表示X十进制表示下的各位数位的数的和。

解法：此题与前四个题目比起来难了一些。在这里DFS的方法并不好想，所以用了数位DP直推的方法写。定义dp[len][i][j][k];表示len位的数 F(x)==i 的数模 j 的结果为k的数有多少个。这样的话，我们首先预处理出dp数组。递推方程式比较容易出的。然而问题是预处理了dp数组之后我们该怎么得到结果。

具体见代码注释：

#include <iostream>
#include <cstdio>
#include <stack>
#include <cstring>
#include <queue>
#include <algorithm>
#include <cmath>
//#include <unordered_map>
#define N 11
using namespace std;
typedef pair<int,int> PII;
const int INF=0x3f3f3f3f;
void Open()
{
    #ifndef ONLINE_JUDGE
        freopen("D:/in.txt","r",stdin);
        //freopen("D:/my.txt","w",stdout);
    #endif // ONLINE_JUDGE
}
int valA;
int dit[N];
//int dp[N][4][4][2];
int dp[N][91][91][91];//dp[len][i][j][k]前len位数和为i模j结果为k的数的个数

void init()
{
    for(int i=1;i<=81;i++)
        dp[0][0][i][0]=1;
    for(int len=0;len<9;len++)
        for(int i=0;i<=9*len;i++)
            for(int j=1;j<=81;j++)
                for(int k=0;k<j;k++)
                    for(int dig=0;dig<10;dig++){
                        dp[len+1][i+dig][j][(k*10+dig)%j] += dp[len][i][j][k];
                        //cout<<dp[len][i][j][k];
                    }
}

int ten[12]={1,10,100,1000,10000,100000,1000000,10000000,100000000,1000000000};

int getval(int x)
{
    int ditnum = 0;
    int ans = 0;
    int tmpx = x;
    //得到x的十进制数组
    while(tmpx)
    {
        dit[ditnum++]=tmpx%10;
        tmpx /= 10;
    }
    
    int presum=0;
    int preNum=0;
    
    for(int i=ditnum-1;i>=0;i--)//遍历x的各个数位。
    {
        int ret=0;
        for(int j=0;j<dit[i]+(i==0);j++)//对小于x的每个数都进行处理
        {
            //cout<<i<<","<<j<<endl;
            for(int k=j+presum;k<=81;k++)//枚举每一个可作为mod的数。从j+presum开始，(j+presum)表示当前位之前的数的和。
            {
                if(!k)//如果k==0，表示不符合条件。
                    continue;
                int r=preNum%k; //得到前面几位数字%k说得到的余数。
                r=(k-r)%k;      //这样的(r+(preNum%k))%k==0 一定成立
                ans+=dp[i][k-j-presum][k][r];
            }
            preNum+=ten[i]; //更新preNum
            //cout<<"here:"<<preNum<<endl;
        }
        presum+=dit[i]; //更新presum
    }
    return ans;
}

int main()
{
    Open();
    int T;
    scanf("%d",&T);
    int n,m;
    int cas=1;
    init();//预处理出dp数组
    //memset(dp,-1,sizeof dp);
    while(T--)
    {
        scanf("%d%d",&n,&m);
        printf("Case %d: %d\n",cas++,getval(m)-getval(n-1));
    }
    return 0;
}


朽弈
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数位DP（数字和与倍数，uva 11361）
xl2015190026的博客
11-09 1593
这道题拖了一整天，WA了无数发，感觉自己数位DP特别弱，其实可能就是因为自己数学比较弱，或者说在推导和代入繁杂的公式以及边界很粗糙的讨论上太不够严谨了，总是觉得大概对就对了，这在数学题上是非常致命的缺点，因为公式错一点点就直接WA，讨论一遗漏也直接WA。然而这道题真蛋疼，明明公式错了，然而样例甚至自己生成的大部分数据都能过。。。 数位DP还需要大量的练习，太不够熟练了。 然后是
数位dp算法详细图文解答
02-13
数位动态规划（Digital Dynamic Programming, 简称数位DP）是一种用于解决与数字的组成有关的问题的算法。它通常涉及到对数字的每一位进行操作，通过递推和记忆化搜索来优化计算效率。数位DP的核心思想是将问题分解...
数位DP
K键盘里的青春K
10-24 2880
基础篇 数位dp是一种计数用的dp，一般就是要统计一个区间[le,ri]内满足一些条件数的个数。所谓数位dp，字面意思就是在数位上进行dp咯。数位还算是比较好听的名字，数位的含义：一个数有个位、十位、百位、千位......数的每一位就是数位啦！ 之所以要引入数位的概念完全就是为了dp。数位dp的实质就是换一种暴力枚举的方式，使得新的枚举方式满足dp的性质，然后记忆化就可以了。
数位dp合集
Eliot的博客
09-04 303
HDU - 3652 - B-number 题目链接&lt;http://acm.hdu.edu.cn/showproblem.php?pid=3652&gt; 题意： 输出1~n中包含“13”且能被13整除的个数。(1 &lt;= n &lt;= 1000000000) 题解： 数位dp的关键就是状态的选取。 这道题的“13”是否被包含很好处理。要保证被13整除只需再添加一维记录余数...
数位dp合集w
weixin_30672295的博客
02-15 104
【BZOJ1026】【SCOI2009】windy数 传送门~:http://www.lydsy.com/JudgeOnline/problem.php?id=1026 数位dp傻题QaQ 1 #include <cstdio> 2 #include <cstdlib> 3 #include <cstring> 4 #include ...
数位DP.pdf
07-12
数位DP可以应用于多种题目，包括求解数字的特征数量、区间内满足特定条件的数字数量等。 在数位DP中，我们通常采用深度优先搜索（DFS）的方式递归地解决问题，同时利用记忆化搜索来存储已经计算过的中间状态，以...
数位DP入门
08-22
数位DP入门思想，包括详细的思考过程以及一些习题的讲解
数位dp——某次队内分享任务
07-21
数位动态规划(Digit Dynamic Programming, 简称数位DP)是一种在处理与数字相关的动态规划问题时，通过分析每个数字位上的状态来优化算法的技术。它通常用于解决涉及数字序列特性的数学问题，例如计数特定类型的数...
4数位DP1
08-08
然后通过三重循环更新`dp`数组，分别对序列长度、和以及当前数位进行迭代。 总结来说，这个题目涉及到的IT知识点包括： 1. 动态规划（DP）及其记忆化搜索 2. 深度优先搜索（DFS）用于位枚举 3. 状态转移和状态设计...
初探数位dp.pdf
09-16
lazycal的集训队报告：初探数位DP 以HDU 2089，HDU 3652, URAL 1057等题目为例，介绍了数位DP的算法
数位dp与ac自动机
07-08
数位dp与ac自动机算法
总结数位DP算法.doc
10-08
数位DP算法总结 数位DP算法是一种计数用的DP算法，常用于统计一个区间[le,ri]中满足某些条件的数的个数。例如，在[1,10000]中统计不含有4的数。数位DP的思想是从最低位起，一位一位地递推，记忆化一下，累加一下。 ...
第3章 数位动态规划-2020.04.22.pdf
05-26
数位动态规划（简称数位DP），是一种在解决与数位相关的问题时采用的一种特殊形式的动态规划方法。这类问题通常涉及对数字串的分析，比如数位之和、特定数字出现的次数等。数位DP的关键在于将原问题划分为多个子问题...
浅谈数位类统计问题
10-01
数位动态规划（Digital Dynamic Programming, 简称数位DP）是计算机科学，特别是算法设计与分析领域中的一种重要技巧，尤其在解决数学和编程竞赛问题时非常常见。数位DP通常应用于处理与整数的各个数位相关的计算...
数位dp模板+理解
Falcon的博客
07-31 643
// pos = 当前处理的位置(一般从高位到低位) // pre = 上一个位的数字(更高的那一位) // state = 要达到的状态,如果为1则可以认为找到了答案,到时候用来返回, // 　　 给计数器+1。 // limit = 是否受限,也即当前处理这位能否随便取值。如567,当前处理6这位, // 　　 如...
数位DP模板详解
Kiritow的学园
08-08 551
为公主殿下而战！转自http://www.cnblogs.com/xz816111/p/4809913.html
模板
DrWells的博客
08-31 346
快速读入 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解析
"这篇资源主要介绍了数位动态规划（数位DP）在解决数位类统计问题中的应用，包括基本概念、思想与方法，并通过具体的HDU2089题目进行了实例解析。" 数位动态规划（数位DP）是一种在计算机科学，特别是算法竞赛中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值