HDU POJ 数位DP

最新推荐文章于 2019-10-13 20:31:29 发布
最新推荐文章于 2019-10-13 20:31:29 发布
阅读量746 收藏 3
点赞数
分类专栏： DP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012469987/article/details/41279885
版权

预处理求出所有答案，再根据具体数字求解，模板性较强。

DP版要想方程，所以还是记忆化搜索版容易，就是枚举每一位。

看http://blog.csdn.net/synapse7/article/details/21006265?utm_source=tuicoo的注释大概能懂。

递归版利用了bit从1计数，而参数按0计数。如

23则bit[1]=3,bit[2]=2，传len=2进去，然后for遍历bit[2]顺便把len-1递归下去，然后len=1时遍历bit[1]=3，继续传0进去，然后返回


HDU 3555 BOMB 不含49

#include <cstdio>
#include <cmath>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
#define ll long long
#define CLR( a , x ) memset ( a , x , sizeof (a) )
#define RE freopen("1.in","r",stdin)

ll dp[25][3];         //dp[i][j]:i长度j情况
//dp[i][0]  长度为i且不含49
//dp[i][1]  长度为i不含49但以9开头
//dp[i][2]  长度为i含49
int bit[25];
void init()
{
    CLR(dp,0);
    dp[0][0] = 1;
    for(int i=1;i<=20;i++)      //2^63次方在20位以内
    {
        dp[i][0] = dp[i-1][0]*10-dp[i-1][1];    //不含49*10-补上4组成的49
        dp[i][1] = dp[i-1][0];                  //补上9
        dp[i][2] = dp[i-1][2]*10+dp[i-1][1];    //已含49*10+补上4组成的49
    }
}
int main()
{
    //RE;
    int t;
    ll n;
    init();
    cin>>t;
    while(t--)
    {
        cin>>n;
        n++;
        int len = 0;
        ll ans = 0;
        while(n)
        {
            bit[++len] = n % 10;
            n /= 10;
        }
        bit[len+1] = 0;
        bool flag = false;
        for(int i=len;i>=0;i--)
        {
            ans += dp[i-1][2]*bit[i];     //低位含49的*该位数字
            if(flag)
                ans += dp[i-1][0]*bit[i];  //组成49后就+=低位*该位
            if(!flag && bit[i]>4)          //后一位是9，那么数字大于4的都包含49
                ans += dp[i-1][1];
            if(bit[i]==9 && bit[i+1]==4)    //组成49
                flag = true;
        }
        cout<<ans<<endl;
    }
}

递归版

#include <cstdio>
#include <cmath>
#include <cstring>
#include <string>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
#define ll long long
#define eps 10^(-6)
#define Q_CIN ios::sync_with_stdio(false);
#define REP( i , n ) for ( int i = 0 ; i < n ; ++ i )
#define FOR( i , a , b ) for ( int i = a ; i <= b ; ++ i )
#define CLR( a , x ) memset ( a , x , sizeof (a) );
#define RE freopen("1.in","r",stdin);
#define WE freopen("1.out","w",stdout);
#define MOD 10009
#define bug(x) cout<<#x<<":"<<(x)<<endl;
#define sf(a) scanf("%d",&a)
#define sff(a,b) scanf("%d%d",&a,&b)  
#define sfff(a,b,c) scanf("%d%d%d",&a,&b,&c)  

#define lson i<<1,l,m
#define rson i<<1|1,m+1,r

const int maxn=25;
const int maxm=1e6+5;
const int inf = 0x3f3f3f3f;

int bit[maxn];
ll dp[maxn][2][2];

ll dfs(int len,bool is4,bool ok49,bool ismax){
    if(len<=0)    return ok49?1:0;
    if(!ismax && dp[len][is4][ok49] != -1)    return dp[len][is4][ok49];
    int pmax = ismax ? bit[len] : 9;
    ll cnt = 0;
    for (int i = 0; i <= pmax; ++i){
        cnt += dfs(len - 1,i == 4,ok49 || (is4 && i == 9),ismax && i == pmax);
    }
    return ismax ? cnt : dp[len][is4][ok49] = cnt;
}
ll solve(ll n){
    int cnt=0;
    while(n){
        bit[++cnt]=n%10;
        n/=10;
    }
    return dfs(cnt,false,false,true);
}
int main()
{
    #ifndef ONLINE_JUDGE
        freopen("1.in","r",stdin);
    #endif
    ll a,t;
    memset(dp,-1,sizeof(dp));
    cin>>t;
    while(t--){
        cin>>a;
        cout<<solve(a)<<endl;
    }
    return 0;
}


HDU 2089 不要62 不含4和相邻62的数

#include <cstdio>
#include <cmath>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
#define ll long long
#define Q_CIN ios::sync_with_stdio(false)
#define CLR( a , x ) memset ( a , x , sizeof (a) )
#define RE freopen("1.in","r",stdin)

int dp[10][3];
//dp[i][0]  长度为i，无不吉利且不以2开头
//dp[i][1]  长度为i，无但以2开头
//dp[i][2]  长度为i，有
int bit[10];
void init()
{
    CLR(dp,0);
    dp[0][0] = 1;
    for(int i=1;i<=10;i++)
    {
        dp[i][0] = dp[i-1][0]*9-dp[i-1][1]; //除4外的9个-后一位是2的情况
        dp[i][1] = dp[i-1][0];              //直接加2
        dp[i][2] = dp[i-1][2]*10+dp[i-1][1]+dp[i-1][0]; //原有的+加6的+加4的
    }
}
int solve(int n)
{
    int len = 0;
    int ans = 0;
    int tmp = n;
    while(n)
    {
        bit[++len] = n % 10;
        n /= 10;
    }
    bit[len+1] = 0;
    bool flag = false;

    for(int i=len;i>=0;i--)
    {
        ans += dp[i-1][2]*bit[i];
        if(flag)
            ans += dp[i-1][0]*bit[i];
        if(!flag && bit[i]>6)
            ans += dp[i-1][1];
        if(!flag && bit[i]>2&&bit[i+1]==6)//62x
           ans += dp[i][1]; //dp[i][1]
        if(!flag && bit[i]>4)
            ans += dp[i-1][0];
        if((bit[i]==2 && bit[i+1]==6)||bit[i]==4)
            flag = true;
    }
    return tmp-ans; //求没有不吉利的
}
int main()
{
//    RE;
    int n,m;
    init();
    while(cin>>n>>m,m||n)
    {
        CLR(bit,0);
        cout<<solve(m+1)-solve(n)<<endl;    //[n,m]=[1,m]-[1,n)
    }
    return 0;
}



#include <cstdio>
#include <cmath>
#include <cstring>
#include <string>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
#define ll long long
#define eps 10^(-6)
#define Q_CIN ios::sync_with_stdio(false);
#define REP( i , n ) for ( int i = 0 ; i < n ; ++ i )
#define FOR( i , a , b ) for ( int i = a ; i <= b ; ++ i )
#define CLR( a , x ) memset ( a , x , sizeof (a) );
#define RE freopen("1.in","r",stdin);
#define WE freopen("1.out","w",stdout);
#define MOD 10009
#define bug(x) cout<<#x<<":"<<(x)<<endl;
#define sf(a) scanf("%d",&a)
#define sff(a,b) scanf("%d%d",&a,&b)  
#define sfff(a,b,c) scanf("%d%d%d",&a,&b,&c)  

#define lson i<<1,l,m
#define rson i<<1|1,m+1,r

const int maxn=10;
const int maxm=1e6+5;
const int inf = 0x3f3f3f3f;

int bit[maxn];
int dp[maxn][2];

int dfs(int len,bool is6,bool ismax){
    if(len==0)    return 1;
    if(!ismax&&dp[len][is6]>=0)    return dp[len][is6];
    int cnt=0,pmax=(ismax?bit[len]:9);
    for (int i = 0; i <= pmax; ++i){
        if(i==4||(is6&&i==2))   continue;
        cnt+=dfs(len-1,i==6,ismax&&i==pmax);
    }
    return ismax?cnt:dp[len][is6]=cnt;
}
int solve(int n){
    int cnt=0;
    while(n){
        bit[++cnt]=n%10;
        n/=10;
    }
    return dfs(cnt,false,true);
}
int main()
{
    #ifndef ONLINE_JUDGE
        freopen("1.in","r",stdin);
    #endif
    int a,b;
    memset(dp,-1,sizeof(dp));
    while(cin>>a>>b,a||b){
        cout<<solve(b)-solve(a-1)<<endl;
    }
    return 0;
}


POJ 3252 Round Numbers

求[x,y]区间内“二进制表示0比1多的数”的个数。处理前导0，前导0不算0。
dp[len][num0][num1]:长度为len,0的数量为num0,1数量为num1的个数 
#include <cstdio>
#include <cmath>
#include <cstring>
#include <string>
#include <iostream>
#include <algorithm>
using namespace std;
#define ll long long
#define FOR( i , a , b ) for ( int i = a ; i <= b ; ++ i )
#define CLR( a , x ) memset ( a , x , sizeof (a) );

#define lson i<<1,l,m
#define rson i<<1|1,m+1,r

const int maxn=50;
const int maxm=1e6+5;
const int inf = 0x3f3f3f3f;

int bit[maxn];
int dp[maxn][maxn][maxn];

int dfs(int len,int num0,int num1,bool first,bool ismax){
    if(len==0)    return num0>=num1?1:0;
    if(!ismax && dp[len][num0][num1] != -1)    return dp[len][num0][num1];
    int pmax = ismax ? bit[len] : 1;
    int cnt = 0;
    for (int i = 0; i <= pmax; ++i){
        if(first){
            if(i==0)
                cnt += dfs(len-1,0,0,true,ismax&&i==pmax);
            else
                cnt += dfs(len-1,0,1,false,ismax&&i==pmax);
        }else{
            if(i==0)
                cnt += dfs(len-1,num0+1,num1,false,ismax&&i==pmax);
            else
                cnt += dfs(len-1,num0,num1+1,false,ismax&&i==pmax);
        }
    }
    return ismax ? cnt : dp[len][num0][num1] = cnt;
}

int solve(int n){
    int cnt=0;
    while(n){
        bit[++cnt]=n%2;
        n/=2;
    }
    return dfs(cnt,0,0,true,true);
}

int main()
{
    #ifndef ONLINE_JUDGE
        freopen("1.in","r",stdin);
    #endif
    int a,t,b;
    memset(dp,-1,sizeof(dp));

    while(cin>>a>>b)
        cout<<solve(b)-solve(a-1)<<endl;
    return 0;
}

弱校OJ 233数

#include <cstdio>
#include <cmath>
#include <cstring>
#include <string>
#include <map>
#include <queue>
#include <iostream>
#include <algorithm>
using namespace std;
#define ll long long
#define REP( i , n ) for ( int i = 0 ; i < n ; ++ i )
#define FOR( i , a , b ) for ( int i = a ; i <= b ; ++ i )
#define CLR( a , x ) memset ( a , x , sizeof (a) );
#define RE freopen("1.in","r",stdin);
#define WE freopen("1.out","w",stdout);
#define MOD 10009
#define bug(x) cout<<#x<<":"<<(x)<<endl;

#define lson i<<1,l,m
#define rson i<<1|1,m+1,r

const int maxn=50;
const int maxm=1e6+5;
const int inf = 0x3f3f3f3f;

int bit[maxn];
ll dp[maxn][2][2][2];   //长度，是不是1，是不是23，是不是233

ll dfs(int len,bool is2,bool is23,bool ok,bool ismax){
    if(len<=0)    return ok?1:0;
    if(!ismax && (dp[len][is2][is23][ok] != -1))    return dp[len][is2][is23][ok];
    int pmax = ismax ? bit[len] : 9;
    ll cnt = 0;
    for (int i = 0; i <= pmax; ++i){
        cnt += dfs(len - 1,i==2,is2&&i == 3,ok||(is23&&i==3),ismax && i == pmax);
    }
    return ismax ? cnt : dp[len][is2][is23][ok] = cnt;
}
ll solve(ll n){
    int cnt=0;
    while(n>0){
        bit[++cnt]=n%10;
        n/=10;
    }
    return dfs(cnt,false,false,false,true);
}
int main()
{
    // #ifndef ONLINE_JUDGE
        // freopen("1.in","r",stdin);
        // freopen("1.out","w",stdout);
    // #endif
    ll a,t;
    memset(dp,-1,sizeof(dp));
    cin>>t;
    while(t--){
        cin>>a;
        cout<<solve(a)<<endl;
    }
    return 0;
}


#include <cstdio>
#include <cmath>
#include <cstring>
#include <string>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
#define ll long long
#define eps 10^(-6)
#define Q_CIN ios::sync_with_stdio(false);
#define REP( i , n ) for ( int i = 0 ; i < n ; ++ i )
#define FOR( i , a , b ) for ( int i = a ; i <= b ; ++ i )
#define CLR( a , x ) memset ( a , x , sizeof (a) );
#define RE freopen("1.in","r",stdin);
#define WE freopen("1.out","w",stdout);
#define MOD 10009
#define bug(x) cout<<#x<<":"<<(x)<<endl;
#define sf(a) scanf("%d",&a)
#define sff(a,b) scanf("%d%d",&a,&b)  
#define sfff(a,b,c) scanf("%d%d%d",&a,&b,&c)  

#define lson i<<1,l,m
#define rson i<<1|1,m+1,r

const int maxn=20;
const int maxm=1e6+5;
const int inf = 0x3f3f3f3f;

int bit[maxn];
ll dp[maxn][2][2][13]; //dp[i][j][k][k]:长度为i，是否以1结尾，有无13，模13的结果

ll dfs(int len,bool end1,bool have13,int mod,bool ismax){
    if(len==0)    return (!mod && have13);
    if(!ismax && (dp[len][end1][have13][mod] != -1))    return dp[len][end1][have13][mod];
    int pmax = ismax ? bit[len] : 9;
    ll cnt = 0;
    for (int i = 0; i <= pmax; ++i){
        int tmod = (mod*10+i) % 13;
        cnt += dfs(len-1,i==1,have13||(end1&&i==3),tmod,ismax && i == pmax);
    }
    return ismax ? cnt : dp[len][end1][have13][mod] = cnt;
}

ll solve(ll n){
    int cnt=0;
    while(n>0){
        bit[++cnt]=n%10;
        n/=10;
    }
    return dfs(cnt,false,false,0,true);
}
int main()
{
    ll a,t;
    memset(dp,-1,sizeof(dp));
    while(cin>>a){
        cout<<solve(a)<<endl;
    }
    return 0;
}





角落的秋天
关注
专栏目录
HDU POJ 树状数组 (Binary Indexed Tree) 教程 大牛讲解，超简单~~
ACM训练
12-15 2826
poj2481 poj3067 poj2299 poj1195 hdu1541 hdu1166 poj2155 hdu3548 hdu1934 hdu2838
数位dp进阶题目——较复杂的状态刻画
启人zhr的博客
03-06 917
前言 The Counting Problem Round Numbers Fx X mod fx前言在前一节链接里，我们讨论了数位dp的基础应用，从数位dp的简单状态刻画状态方程的给出，以及之后给出了较为统一的记忆化模板来解决大多数问题，在这一节里首先给出一个较复杂的状态方程求解问题，剩下3个用记忆化解决的问题来加深印象。The Counting ProblemPOJ 2282 题目链接 Giv
poj4507（数位dp）
weixin_33882443的博客
05-08 106
题目链接：https://vjudge.net/problem/HDU-4507 题意：定义如果一个整数符合下面3个条件之一，那么我们就说这个整数和7有关—— 　　1、整数中某一位是7； 　　2、整数的每一位加起来的和是7的整数倍； 　　3、这个整数是7的整数倍； 　　给定l，r，求[l,r] 区间与7无关的数的平方和。 思路：这3条定义都是常规的数位dp，但题目求的并不是与7无...
poj1351 Number of Locks(数位dp)
zark721的博客
07-22 234
题意：某工厂生产一种锁，锁上面有n条槽，现要求生产出来的锁，满足下述条件： 1. 槽深 一定是{1,2,3,4}中的某个值 2. 至少存在 一对相邻的槽，两槽的深度差等于3 3. 至少存在 3种不同深度的槽。 问：已知n，求有多少中排列组合方式满足上述条件 样例: 2：0    因为只有2个槽，不满足条件3； 3：8   3个槽满足的方案有 ： 142 、143、 241 、214 ...
poj2282（数位dp）
xiefubao的专栏
05-12 1348
题意：计算a-b中各个数字出现的个数； 解法：数位dp（思想都是先算1-b的个数，然后减掉1-a中的个数），1-9数字的计算和前边计算1的那一篇数位dp差不多，计算0时候要加一维表示前缀是否全是0； 代码：/****************************************************** * author:xiefubao *****************
POJ-3208 Apocalypse Someday （数位DP）
weixin_30699741的博客
07-30 97
只要某数字的十进制表示中有三个6相邻，则该数字为魔鬼数，求第X小的魔鬼数\(X\le 5e7\) 这一类题目可以先用DP进行预处理，再基于拼凑思想，用“试填法"求出最终的答案 \(F[i,3]\)表示由 \(i\) 位数字构成的魔鬼数有多少个，\(F[i,j](0\le j\le 2)\) 表示由 \(i\) 位数字构成的，开头已经有连续 \(j\) 个6的非魔鬼数有多少个。（允许...
数位DP专题
Untersee-boot XXI
10-13 263
CF55D 这个题的核心要素是：某个数n被它的所有非零数位整除的同时，也是整除了所有非零数位的最小公倍数。所以在分析数位的同时需要照顾已经分析的所有非零数位的最小公倍数，和这些数位组成的这个数取余它的模。 所以dfs过程就有了三维数据：当前数位，余数，最小公倍数。然而余数和最小公倍数可能很大，在记忆化过程中较难实现，所以需要优化一下。可以发现1~9的最小公倍数为2520，如果一个数被2520整...
数位DP小结_记忆化搜索版
pikachu_777的专栏
07-28 980
之前写数位dp是用dp方程递推形式写，接触记忆化搜索版后，发现使用dfs更加清晰明了，思路很顺，代码简洁的多W。 首先上模板，以HDU 2089 不要62为例     #define _CRT_SECURE_NO_DEPRECATE #include &lt;stdio.h&gt; #include &lt;string.h&gt; #include &lt;stdlib.h&gt; #...
数位dp简单题目汇总
ten_three
12-03 2333
地址：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):
数位DP——小结及模板
Plus Ultra！
07-12 392
一、数位DP 用于解决 范围 [L, R] 内满足某些条件的数有多少 的问题，所谓数位，就是指数的个位、十位、百位、千位… 一般会将先将求ans [L, R] 转化为求 ans [0, R] - ans [0, L-1] ，从而问题就变为数位DP求解 ans [0, X] 数位DP最重要的是状态的构建，而具体DP的过程则是利用DFS+记忆化搜索实现，这样更好理解并实现，而状态的构建则更像是状态的压...
poj 2089 数位DP
JIBANCANYANG
05-30 743
题意：给你一个区间，求这个区间内所有满足不含数字2，不含连续数字62的数字的个数。（本题核心思想见代码注解） 题并非水，然而大部分人还是水过的，对1到10,000,000内数字转化为字符串打表处理即可水过。然而做这个题主要是为了掌握数位DP。 数位DP常见知识点： 求区间[l, r]之间的数常常转化为求区间[0 ,r] - [0, l]之间的数，因为l，r上界下界并不好做。 数位DP的核心就是无后效
poj3208启示录——数位DP
aodan5477的博客
03-27 200
题目：http://poj.org/problem?id=3208 数位DP，首先按位数预处理出每一种位数的情况，包括有多少个魔鬼数和有多少个以6开头的非魔鬼数，以便递推、累加等等； 然后先找出第X个魔鬼数的位数，再一位一位从0开始填数； 写法有些技巧，详见代码及注释。 代码如下： #include<iostream> #include<cstdio&g...
poj 3971 Scales (数位dp，好题)
ACM之梦
04-02 791
题意： 给出一个二进制形式的重量的物品，现在有n个砝码分别是2^0、2^1....2^(n-1)。现在问如何在天平上放砝码可以使得天平平衡。 题解： 我们分析，假设我们左边放的砝码重量总和为x，右边放的重量总和为y（左边还有放物品）。 那么问题就转化重量为w的物品加砝码能变成那些可行重量的问题。我们根据物品的重量的二进制来求解，按位dp。dp[i][2]，0表示进位，1表示不进位。这样分两
POJ-2282题解&数位DP总结
weixin_33896069的博客
08-09 220
一、题意 给定一个区间[a, b]（注意输入的时候可能a > b，所以，在数据输入后，要先比较a和b，如果a > b，交换a和b的值），统计这个区间里面，数位上有多少个0、多少个1、……、多少个9。 二、思路 第一种：数位DP。dfs函数的参数列表为： int pos：当前处理的数位所在的位置； int val：当前统计的数值（0——9）； int amt：从最高位开始到当前位置的...
poj 3208 Apocalypse Someday （数位dp）
To be what you what to be!
08-25 1198
Apocalypse Someday Time Limit: 1000MS   Memory Limit: 131072K Total Submissions: 1490   Accepted: 686 Description The number 666 is considered to be the occult “number
POJ - 3252 数位dp
Bahuia的博客
01-13 696
题意： 一个数x是round number，要求x写成二进制形式的时候数位上0的个数要大于等于1的个数，题目要求求出给定范围内的round number个数。 思路： 既然求的是二进制，那么自然要用二进制的数位dp来判断，模式基本不变，另外保存两个变量one，zero分别表示搜索中1和0出现的个数，另外还有一个flag变量清除前导零的影响。 代码： #include #include
POJ2282：The Counting Problem(数位DP)
ACM！荣耀之路！
08-16 3231
Description Given two integers a and b, we write the numbers between a and b, inclusive, in a list. Your task is to calculate the number of occurrences of each digit. For example, if a = 1024 and b =
POJ 3986 数位dp
Tczxw的专栏
11-19 812
#include #include #include using namespace std; const int mod = 1000000003; const int maxn = 1 << 6; int n, k, inp[maxn], dp[maxn][maxn][2], pw[maxn]; long long solve(int i, int pre, int len) { lo
POJ 1850 Code （数位DP）
scf0920
01-22 680
题目地址：POJ 1850 简单数位DP，只需要多处理一下0的时候。 代码如下： #include #include #include #include #include #include #include #include #include using namespace std; #define LL __int64 #define pi acos(-1.0) cons
数位DP入门解析与应用实例
除了HDU 2089，数位DP还可以应用于其他类似问题，例如： - HDU 3652：可能涉及更复杂的数位约束和统计条件。 - Ural 1057：可能会考察对数位的异或操作。 - test-09-07-p1：可能需要结合其他算法或数据结构进行综合...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值