某大牛的数位DP

最新推荐文章于 2023-04-01 19:23:56 发布
最新推荐文章于 2023-04-01 19:23:56 发布
阅读量229 收藏
点赞数

出处：http://blog.youkuaiyun.com/ACM_cxlove?viewmode=contents 


HDU 2089 不要62

http://acm.hdu.edu.cn/showproblem.php?pid=2089

不能出现4，或者相邻的62，这题可以暴力打表解决

具体的在代码里都有解释

[cpp]  view plain  copy
  1. #include<iostream>  
  2. #include<cstring>  
  3. #include<queue>  
  4. #include<cstdio>  
  5. #include<cmath>  
  6. #include<algorithm>  
  7. #define N 55  
  8. #define inf 1<<29  
  9. #define MOD 9973  
  10. #define LL long long  
  11. #define eps 1e-7  
  12. #define zero(a) fabs(a)<eps  
  13. #define equal(a,b) zero(a-b)  
  14. using namespace std;  
  15. int dp[10][3];  
  16. //dp[i][0],表示不存在不吉利数字  
  17. //dp[i][1],表示不存在不吉利数字，且最高位为2  
  18. //dp[i][2],表示存在不吉利数字  
  19. void Init(){  
  20.     memset(dp,0,sizeof(dp));  
  21.     dp[0][0]=1;  
  22.     for(int i=1;i<=6;i++){  
  23.         dp[i][0]=dp[i-1][0]*9-dp[i-1][1];  //在最高位加上除了4之外的9个数字，但是可能在2之前加了6  
  24.         dp[i][1]=dp[i-1][0];    //就是在原先不含不吉利数字的最高位加2  
  25.         dp[i][2]=dp[i-1][2]*10+dp[i-1][0]+dp[i-1][1];  //在已经有不吉利数字最高位加任意数字，或者在无吉利数字前加4，或者在2前面加4  
  26.     }  
  27. }  
  28. int slove(int n){  
  29.     int len=0,bit[10];  
  30.     int tmp=n;  
  31.     while(n){  
  32.         bit[++len]=n%10;  
  33.         n/=10;  
  34.     }  
  35.     bit[len+1]=0;  
  36.     int ans=0;  
  37.     bool flag=false;  
  38.     for(int i=len;i;i--){  
  39.         ans+=dp[i-1][2]*bit[i];    
  40.         if(flag)   //高位已经出现4或者62，后面的就随意  
  41.             ans+=dp[i-1][0]*bit[i];  
  42.         if(!flag&&bit[i]>4)  //高位可能出现4的情况  
  43.             ans+=dp[i-1][0];  
  44.         if(!flag&&bit[i+1]==6&&bit[i]>2)  //高位是6，后面一位可能出现2，这步debug了很久  
  45.             ans+=dp[i][1];  
  46.         if(!flag&&bit[i]>6)  //高位可能出现6，要把后面最高位为2计入  
  47.             ans+=dp[i-1][1];  
  48.         if(bit[i]==4||(bit[i+1]==6&&bit[i]==2))  //高位已经出现4或者62  
  49.             flag=true;  
  50.     }  
  51.     return tmp-ans;  
  52. }  
  53. int main(){  
  54.     int l,r;  
  55.     Init();  
  56.     while(scanf("%d%d",&l,&r)!=EOF&&l+r)  
  57.         printf("%d\n",slove(r+1)-slove(l));  
  58.     return 0;  
  59. }  


HDU 3555 BOMB

http://acm.hdu.edu.cn/showproblem.php?pid=3555

不能出现相邻的49,和上一题类似

[cpp]  view plain  copy
  1. #include<iostream>  
  2. #include<cstring>  
  3. #include<queue>  
  4. #include<cstdio>  
  5. #include<cmath>  
  6. #include<algorithm>  
  7. #define N 55  
  8. #define inf 1<<29  
  9. #define MOD 9973  
  10. #define LL long long  
  11. #define eps 1e-7  
  12. #define zero(a) fabs(a)<eps  
  13. #define equal(a,b) zero(a-b)  
  14. using namespace std;  
  15. LL dp[21][3],n;   
  16. int len,bit[21];  
  17. //dp[i][0]表示长度为i，包括49的个数  
  18. //dp[i][1]表示长度为i，没有49但是开头为9的个数  
  19. //dp[i][2]表示长度为i，没有49  
  20. void Init(){  
  21.     memset(dp,0,sizeof(dp));  
  22.     dp[0][2]=1;  
  23.     for(int i=1;i<20;i++){  
  24.         dp[i][0]=(LL)dp[i-1][0]*10+dp[i-1][1];  
  25.         dp[i][1]=dp[i-1][2];  
  26.         dp[i][2]=(LL)dp[i-1][2]*10-dp[i-1][1];  
  27.     }  
  28. }  
  29. int main(){  
  30.     Init();  
  31.     int t;  
  32.     scanf("%d",&t);  
  33.     while(t--){  
  34.         scanf("%I64d",&n);  
  35.         len=0;  
  36.         n++;  
  37.         while(n){  
  38.             bit[++len]=n%10;  
  39.             n/=10;  
  40.         }  
  41.         bit[len+1]=0;  
  42.         LL ans=0;  
  43.         bool flag=false;  
  44.         for(int i=len;i;i--){  
  45.             ans+=(LL)dp[i-1][0]*bit[i];  
  46.             if(flag)  
  47.                 ans+=(LL)dp[i-1][2]*bit[i];  
  48.             if(!flag&&bit[i]>4)  
  49.                 ans+=dp[i-1][1];  
  50.             if(bit[i]==9&&bit[i+1]==4)  
  51.                 flag=true;  
  52.         }  
  53.         printf("%I64d\n",ans);  
  54.     }  
  55.     return 0;  
  56. }  


UESTC 1307 WINDY 数

http://acm.uestc.edu.cn/problem.php?pid=1307

要求相邻的数差大于等于2

[cpp]  view plain  copy
  1. #include<iostream>  
  2. #include<cstring>  
  3. #include<queue>  
  4. #include<cstdio>  
  5. #include<cmath>  
  6. #include<algorithm>  
  7. #define N 100005  
  8. #define inf 1<<29  
  9. #define MOD 9973  
  10. #define LL long long  
  11. #define eps 1e-7  
  12. #define zero(a) fabs(a)<eps  
  13. #define equal(a,b) zero(a-b)  
  14. using namespace std;  
  15. int dp[15][10];  
  16. //dp[i][j]表示考虑i位的数中，最高为j的windy数  
  17. void Init(){  
  18.     memset(dp,0,sizeof(dp));  
  19.     for(int i=0;i<=9;i++)  
  20.         dp[1][i]=1;  
  21.     for(int i=2;i<=10;i++){  
  22.         for(int j=0;j<10;j++){  
  23.             for(int k=0;k<10;k++)  
  24.                 if(abs(j-k)>=2)  
  25.                     dp[i][j]+=dp[i-1][k];  
  26.         }  
  27.     }  
  28. }  
  29. int slove(int n){  
  30.     int len=0,bit[15];  
  31.     while(n){  
  32.         bit[++len]=n%10;  
  33.         n/=10;  
  34.     }  
  35.     bit[len+1]=0;  
  36.     int ans=0;  
  37.     //先把长度为1至len-1计入  
  38.     for(int i=1;i<len;i++)  
  39.         for(int j=1;j<10;j++)  
  40.             ans+=dp[i][j];  
  41.     //确定最高位  
  42.     for(int j=1;j<bit[len];j++)  
  43.         ans+=dp[len][j];  
  44.     for(int i=len-1;i;i--){  
  45.         for(int j=0;j<bit[i];j++)  
  46.             if(abs(j-bit[i+1])>=2)  
  47.                 ans+=dp[i][j];  
  48.         //如果高位已经出现非法，直接退出  
  49.         if(abs(bit[i]-bit[i+1])<2)  
  50.             break;  
  51.     }  
  52.     return ans;  
  53. }  
  54. int main(){  
  55.     Init();  
  56.     int l,r;  
  57.     while(scanf("%d%d",&l,&r)!=EOF)  
  58.         printf("%d\n",slove(r+1)-slove(l));  
  59.     return 0;  
  60. }  
yellow_hzy
关注
【c++提高1】优化DP专题：状压DP & 倍增优化DP & 环形DP的单调队列优化DP
小学生蒟蒻
07-11 981
这是c++提高的第一讲动态规划是解决“多阶段决策最优化问题”的一种算法思想。阶段的划分决定了状态的定义，状态定义的一个重要特性就是要确保**“无后效性”。** 很多DP问题在定义状态的时候，为了确保无后效性，需要在状态中加入多个维度，如果每个维度都用一维数组来表示的话，当维度较多时会导致占用的空间太大。 很多时候状态的维度虽然很多，但是决策非常少，特别的很多时候只有两种决策。例如背包问题中每个物品只有0和1两种决策。对于这种情况，没有必要为每个维度都分配一维空间，而是用一个二进制数来存储所有维度，每个二进制
牛客网 subsequence 1 【线性DP + 组合数】
独钓门前月
08-04 346
给你两个字符串s和t由数字组成（字符'0'〜\ sim~'9'）。 s的长度为n，t的长度为m。 s和t的第一个字符都不是'0'。如果被视为正整数，请计算大于t的s的有效子序列的数量。当且仅当其第一个字符不为“0”时，子序列才有效。如果两个子序列由原始字符串中的不同位置组成，则它们是不同的。例如，字符串“1223”具有2个不同的子序列“23”。因为答案可能很大，请输出模数998244353的答案...
几个基础数位DP (hdu 2089,hdu 3555 ,uestc 1307 windy 数)
java开发指南博客 【转载】
08-01 146
转载请注明出处，谢谢http://blog.youkuaiyun.com/ACM_cxlove?viewmode=contents by---cxlove 做了几个非常基础的数位DP，很水。弱爆了，接下来要进行进阶训练了 HDU 2089 不要62 http://acm.hdu.edu.cn/showproblem.php?pid=2089 不能出现4，或者相邻的62，这题可以暴力打表解决 具体...
数位DP
K键盘里的青春K
10-24 2996
基础篇 数位dp是一种计数用的dp，一般就是要统计一个区间[le,ri]内满足一些条件数的个数。所谓数位dp，字面意思就是在数位上进行dp咯。数位还算是比较好听的名字，数位的含义：一个数有个位、十位、百位、千位......数的每一位就是数位啦！ 之所以要引入数位的概念完全就是为了dp。数位dp的实质就是换一种暴力枚举的方式，使得新的枚举方式满足dp的性质，然后记忆化就可以了。
数位dp总结 之 从入门到模板
热门推荐
努力
08-03 7万+
for(int i=le;i<=ri;i++) if(right(i)) ans++; 基础篇 数位dp是一种计数用的dp，一般就是要统计一个区间[le,ri]内满足一些条件数的个数。所谓数位dp，字面意思就是在数位上进行dp咯。数位还算是比较好听的名字，数位的含义：一个数有个位、十位、百位、千位......数的每一位就是数位啦！ 之所以要引入数位的概念完全就是为了dp。
数位dp
fyh2944163240的博客
08-21 261
数位dp 数位dp是一种计数用的dp，一般就是要统计一个区间[le,ri]内满足一些条件数的个数。所谓数位dp，字面意思就是在数位上进行dp咯。数位还算是比较好听的名字，数位的含义：一个数有个位、十位、百位、千位…数的每一位就是数位啦！ 之所以要引入数位的概念完全就是为了dp。数位dp的实质就是换一种暴力枚举的方式，使得新的枚举方式满足dp的性质，然后记忆化就可以了。 新的枚举：控制上界枚举，从最高位开始往下枚举，例如：ri=213，那么我们从百位开始枚举：百位可能的情况有0,1,2(觉得这里枚举0有问题的
方格取数（四维dp）
peizhecpp的博客
06-12 864
链接：https://ac.nowcoder.com/acm/problem/16759 来源：牛客网 题目描述 设有N*N的方格图(N ≤ 10,我们将其中的某些方格中填入正整数,而其他的方格中则放入数字0。如下图所示(见样例)： 某人从图的左上角的A 点出发，可以向下行走，也可以向右走，直到到达右下角的B点。在走过的路上，他可以取走方格中的数(取走后的方格中将变为数字0)。 此人从A点到B 点共走两次，试找出2条这样的路径，使得取得的数之和为最大。 输入描述: 输入的第一行为一个整数N(表示N*N的方格
【DFS回溯】2022年蓝桥杯真题之最大数字
未见花闻的博客
04-01 551
对于DFS的具体实现，由于数字太大，并且如果直接使用数字，需要手动枚举每一位进行操作，不方便，然后字符串字典序满足数字大小关系，所以对于数字n和操作后的最大值ans，我们采取字符串的形式进行储存。
牛客网 [编程题] 牛牛的数列 （DP）
blanKey的博客
05-20 2788
时间限制：1秒 空间限制：32768K 牛牛现在有一个n个数组成的数列,牛牛现在想取一个连续的子序列,并且这个子序列还必须得满足:最多只改变一个数,就可以使得这个连续的子序列是一个严格上升的子序列,牛牛想知道这个连续子序列最长的长度是多少。  输入描述: 输入包括两行,第一行包括一个整数n(1 ≤ n ≤ 10^5),即数列的长度; 第二行n个整数a_i, 表示数列中的每个数(
模板
DrWells的博客
08-31 435
快速读入 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 ==
游游的整数切割 牛客网c++
最新发布
08-11
### 问题解析 在牛客网的编程题中，“游游的整数切割”问题要求将一个整数按照某种方式切割成若干部分，使得这些部分满足特定的条件，通常是数学性质，例如每一部分都是某个数的倍数、满足回文性质、或者满足某种动态规划结构。 该问题通常属于**动态规划**或**贪心算法**范畴，具体解法取决于题目设定。假设题目要求将一个大整数切割成若干子串，使得每个子串构成的数字满足某种条件（如能被某个数整除），那么可以采用如下策略： - 将整数转换为字符串进行处理。 - 使用动态规划记录当前位置之前可以切割出的合法子串个数。 - 对于每个可能的切割点，检查子串是否满足条件。 下面是一个假设题意的 C++ 示例代码，假设题目要求找出能被3整除的所有子串组合方式数目： ```cpp #include <iostream> #include <vector> #include <string> using namespace std; int countDivisibleSubstrings(string num) { int n = num.size(); vector<int> dp(n + 1, 0); dp[0] = 1; // 空字符串视为一种方式 for (int i = 1; i <= n; ++i) { long long current = 0; for (int j = i - 1; j >= 0; --j) { current = current + (num[j] - '0') * pow(10, i - j - 1); if (current % 3 == 0) { dp[i] += dp[j]; } } } return dp[n]; } int main() { string num; cin >> num; cout << countDivisibleSubstrings(num) << endl; return 0; } ``` ### 算法说明 - 上述代码使用动态规划思想，`dp[i]`表示前`i`位数字可以被切割成若干个能被3整除的子串的方式数目。 - 内层循环尝试从位置`j`到`i`构成一个子串，并判断是否能被3整除。 - 如果可以，则将`dp[j]`加到`dp[i]`中，表示从`j`到`i`切割后的方式数。 ### 优化策略 - 若整数长度较长，可使用前缀和技巧加速子串数值计算。 - 对于非常大的整数，建议使用字符串处理而非转换为整型，以避免溢出问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值