算法提高之动态规划：数位dp

已于 2022-01-27 21:28:53 修改
阅读量2.5k 收藏 1
点赞数 1
分类专栏： 算法提高 文章标签： 动态规划 算法 c++
于 2022-01-23 14:47:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37448336/article/details/122651504
版权

目录

1、度的数量

在这里插入图片描述
在这里插入图片描述

#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

const int N = 35;

int K, B;
//从a个数中选b个数的方案数
int f[N][N]; 

void init()
{
	f[0][0]=1;
    for (int i = 1; i < N; i ++ )
        for (int j = 0; j <= i; j ++ )
            if (!j) f[i][j] = 1;
            else f[i][j] = f[i - 1][j] + f[i - 1][j - 1];
}

int dp(int n)
{
    if (!n) return 0;
	//将边界 l-1，r 处理成b进制数 
    vector<int> nums;
    while (n) nums.push_back(n % B), n /= B;
	//记录满足情况的数据
    int res = 0;
    //假设枚举到了i-2位，i和i-1位中有几个1，由last记录
    int last = 0;
    for (int i = nums.size() - 1; i >= 0; i -- )
    {
        int x = nums[i];
        //x是否>0
        if (x)  // 求左边分支中的数的个数
        {
        //大于0就将i位为0的情况记录下来 
        //由于i=0,i-1~0 总共由i个数据 所以从i个数据中选
            res += f[i][K - last];
        //当x>1时，第i位可以为1
            if (x > 1)
            {
            	//判断k是否装满
            	//i个数据，k-last-1 是由于i位填写需要减1
                if (K - last - 1 >= 0) res += f[i][K - last - 1];
                //因为题目要求是由k个互不相等的b的整数次幂之和
                //数据表示成b进制只能含0，1 不能含 2~b-1
                //因此x>1只包含x=1一种情况
                break;
            }
            //x=1 需要判断右分支
            else
            {
                last ++ ;
                //last超过k就结束循环
                if (last > K) break;
            }
        }
		//特殊处理右分支的最后一个数 ！i 最后一个数  last==k 是恰好装满k
		//x=1,x>1的情况在以上分支被处理，x=0满足题目要求。
		//因为题目要求是由k个互不相等的b的整数次幂之和
        //数据表示成b进制只能含0，1 不能含 2~b-1
        if (!i && last == K) res ++ ;   // 最右侧分支上的方案
    }

    return res;
}

int main()
{
    init();

    int l, r;
    cin >> l >> r >> K >> B;

    cout << dp(r) - dp(l - 1) << endl;

    return 0;
}

2、数字游戏

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

//2^31 是20亿，一共10位数，写成15位正合适
const int N = 15;

int f[N][N];    // f[i, j]表示一共有i位，且最高位填j的数的个数

void init()
{
	//共1位，无论首位是几，都是1方案
    for (int i = 0; i <= 9; i ++ ) f[1][i] = 1;
	//从2位开始枚举
    for (int i = 2; i < N; i ++ )
    	//首位从0到9
        for (int j = 0; j <= 9; j ++ )
        	//k是枚举第二位是几
            for (int k = j; k <= 9; k ++ )
                f[i][j] += f[i - 1][k];
}

int dp(int n)
{
	//特判n为0，也是一种方案
    if (!n) return 1;
	//将数据拆开
    vector<int> nums;
    while (n) nums.push_back(n % 10), n /= 10;
	//记录结果
    int res = 0;
    //记录前一位是几
    int last = 0;
    //诸位枚举
    for (int i = nums.size() - 1; i >= 0; i -- )
    {
        int x = nums[i];
        //左侧计算 枚举最高为填last~an-1的方案
        for (int j = last; j < x; j ++ )
            res += f[i + 1][j];
		//右侧计算 判断当前一位能否为x 前一位比x大时 不行
        if (x < last) break;
        last = x;
		//判断最右侧分支，以上代码已将左最一层左侧分支计算完毕
		//并且保证每一个数都是大于等于前一个数
        if (!i) res ++ ;
    }

    return res;
}

int main()
{
    init();

    int l, r;
    while (cin >> l >> r) cout << dp(r) - dp(l - 1) << endl;

    return 0;
}

3、Windy数

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;
//最多的位数 总共有10位
const int N = 11;
//一共有i位，且最高位是j
int f[N][10];

void init()
{
//f[2][2] 一共有2位，最高位是2.f[1][0]=1时，f[2][2]中的f[2][0]才能迭代
    for (int i = 0; i <= 9; i ++ ) f[1][i] = 1;

    for (int i = 2; i < N; i ++ )
    	//j是高位
        for (int j = 0; j <= 9; j ++ )
        //k是高位的下一位
            for (int k = 0; k <= 9; k ++ )
                if (abs(j - k) >= 2)
                    f[i][j] += f[i - 1][k];
}



int dp(int n)
{
//0不是windy，因为0不在题目范围内
    if (!n) return 0;

    vector<int> nums;
    while (n) nums.push_back(n % 10), n /= 10;

    int res = 0;
    //为了让首位数字任意填，让首位数和0~9之间的任意数的差都>=2的数
    int last = -2;
    
    //循环是处理与最高位数字相关联的windy数
    for (int i = nums.size() - 1; i >= 0; i -- )
    {
        int x = nums[i];
        //枚举左边的分支 
        //j不是每一次都可以从0开始算
        //当j是最高位的时候，只能从1开始 
        for (int j = i == nums.size() - 1; j < x; j ++ )
            if (abs(j - last) >= 2)
            	//从i位到0位 i+1位数
                res += f[i + 1][j];

        if (abs(x - last) >= 2) last = x;
        else break;
		//右最后一个分支
        if (!i) res ++ ;
    }
	//低于n位的数，需要特判
    // 特殊处理有前导零的数
    //从第一位开始枚举

    
    //这一层特判是叠加比最高位位数低的windy数
    //例如1000 有四位数 则3位和2位以及1位所有windy数均在范围内
    for (int i = 1; i < nums.size(); i ++ )
    //枚举最高位填多少 由于是i位数，最高位不填0 
        for (int j = 1; j <= 9; j ++ )
            res += f[i][j];

    return res;
}

int main()
{
    init();

    int l, r;
    cin >> l >> r;
    cout << dp(r) - dp(l - 1) << endl;

    return 0;
}

4、数字游戏2

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;
//最多10位数  N表示位数 M表示取模的数字
const int N = 11, M = 110;
//取模
int P;
//f[i][j][k] 一共有i位，最高位是j，各位之和相对于M的余数是k
int f[N][10][M];
//c++取模比较特殊 负数取模是负数，整数取模是正数
//现在是想让负数和正数都取模变成正数
int mod(int x, int y)
{
    return (x % y + y) % y;
}

void init()
{
//多组测试数据 需要清空
    memset(f, 0, sizeof f);

    for (int i = 0; i <= 9; i ++ ) f[1][i][i % P] ++ ;
	//位数
    for (int i = 2; i < N; i ++ )
    //最高位的数据
        for (int j = 0; j <= 9; j ++ )
    //余数
            for (int k = 0; k < P; k ++ )
            //枚举次高位填什么
                for (int x = 0; x <= 9; x ++ )
        //f[i][j][k] 当有i位数，最高位是j，且余数是k
        //f[i-1][x][mod(k-j,P)] 当有i-1位数，最高位是x，且余数是
        //（k-j）含有最高位在内的所有位数之和取余的余数减去最高位 再取模得到
        //包含次高位在内的所有余数之和。也就是通过这个处理建立了最高位数据和次高位数据之间的关系
                    f[i][j][k] += f[i - 1][x][mod(k - j, P)];
}

int dp(int n)
{
    if (!n) return 1;

    vector<int> nums;
    while (n) nums.push_back(n % 10), n /= 10;

    int res = 0;
    //前边各位数字之和
    int last = 0;
    for (int i = nums.size() - 1; i >= 0; i -- )
    {
        //处理左边分支
        int x = nums[i];
        for (int j = 0; j < x; j ++ )
        //通过mod(-last，P)赖筛选需要相加的数据。
            res += f[i + 1][j][mod(-last, P)];
		//右边分支	
        last += x;
		//右侧分支最后一个数 ，如果是最后一个数，last已经将所有的数据累加完毕
        if (!i && last % P == 0) res ++ ;
    }

    return res;
}

int main()
{
    int l, r;
    while (cin >> l >> r >> P)
    {
        init();

        cout << dp(r) - dp(l - 1) << endl;
    }

    return 0;
}

5、不要62

在这里插入图片描述
在这里插入图片描述

#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

const int N = 10;

int f[N][10];

void init()
{
    for (int i = 0; i <= 9; i ++ )
        if (i != 4)
            f[1][i] = 1;

    for (int i = 2; i < N; i ++ )
        for (int j = 0; j <= 9; j ++ )
        {
            if (j == 4) continue;
            for (int k = 0; k <= 9; k ++ )
            {
                if (k == 4 || j == 6 && k == 2) continue;
                f[i][j] += f[i - 1][k];
            }
        }
}

int dp(int n)
{
    if (!n) return 1;

    vector<int> nums;
    while (n) nums.push_back(n % 10), n /= 10;

    int res = 0;
    int last = 0;
    for (int i = nums.size() - 1; i >= 0; i -- )
    {
        int x = nums[i];
        for (int j = 0; j < x; j ++ )
        {
            if (j == 4 || last == 6 && j == 2) continue;
            res += f[i + 1][j];
        }

        if (x == 4 || last == 6 && x == 2) break;
        last = x;

        if (!i) res ++ ;
    }

    return res;
}

int main()
{
    init();

    int l, r;
    while (cin >> l >> r, l || r)
    {
        cout << dp(r) - dp(l - 1) << endl;
    }

    return 0;
}

6、恨7不成妻

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
此处合法数是i-1位
在这里插入图片描述
此处的合法数是i位
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

typedef long long LL;
//N表示位数
const int N = 20, P = 1e9 + 7;

//f[i][j][a][b] 一共由i位数，最高位是j，数本身模7是a，所有数位之和模7是b
struct F
{
//含有i位的状态方程推出i-1位的状态方程
//s0 i-1位中合法状态数据个数 s1 i-1位中合法状态数据和  
//s2 i-1位中合法状态数据平方和
    int s0, s1, s2;
}f[N][10][7][7];
//10的多少幂模7  10的多少次幂模p的结果
int power7[N], power9[N];

int mod(LL x, int y)
{
    return (x % y + y) % y;
}

void init()
{
    for (int i = 0; i <= 9; i ++ )
    {
        if (i == 7) continue;
        auto& v = f[1][i][i % 7][i % 7];
        v.s0 ++, v.s1 += i, v.s2 += i * i;
    }

    LL power = 10;
    for (int i = 2; i < N; i ++, power *= 10)
        for (int j = 0; j <= 9; j ++ )
        {
            if (j == 7) continue;
            for (int a = 0; a < 7; a ++ )
                for (int b = 0; b < 7; b ++ )
                    for (int k = 0; k <= 9; k ++ )
                    {
                        if (k == 7) continue;
                        auto &v1 = f[i][j][a][b], &v2 = f[i - 1][k][mod(a - j * power, 7)][mod(b - j, 7)];
                        v1.s0 = mod(v1.s0 + v2.s0, P);
                        v1.s1 = mod(v1.s1 + v2.s1 + j * (power % P) % P * v2.s0, P);
                        v1.s2 = mod(v1.s2 + j * j * (power % P) % P * (power % P) % P * v2.s0 + v2.s2 + 2 * j * power % P * v2.s1, P);
                    }
        }

    power7[0] = 1;
    for (int i = 1; i < N; i ++ ) power7[i] = power7[i - 1] * 10 % 7;

    power9[0] = 1;
    //ll  long long
    for (int i = 1; i < N; i ++ ) power9[i] = power9[i - 1] * 10ll % P;
}

F get(int i, int j, int a, int b)
{
    int s0 = 0, s1 = 0, s2 = 0;
    for (int x = 0; x < 7; x ++ )
        for (int y = 0; y < 7; y ++ )
            if (x != a && y != b)
            {
                auto v = f[i][j][x][y];
                s0 = (s0 + v.s0) % P;
                s1 = (s1 + v.s1) % P;
                s2 = (s2 + v.s2) % P;
            }
    return {s0, s1, s2};
}

int dp(LL n)
{
    if (!n) return 0;
	//原数
    LL backup_n = n % P;
    vector<int> nums;
    while (n) nums.push_back(n % 10), n /= 10;

    int res = 0;
    //a前边数的本身   b前边数的各位数之和
    LL last_a = 0, last_b = 0;
    for (int i = nums.size() - 1; i >= 0; i -- )
    {
        int x = nums[i];
        for (int j = 0; j < x; j ++ )
        {
            if (j == 7) continue;
            int a = mod(-last_a * power7[i + 1], 7);
            int b = mod(-last_b, 7);
            //题目的性质
            //一共i+1位，最高位是j，且模7后，不为a，不为b
            auto v = get(i + 1, j, a, b);
            res = mod(
                res + 
                (last_a % P) * (last_a % P) % P * power9[i + 1] % P * power9[i + 1] % P * v.s0 % P + 
                v.s2 + 
                2 * last_a % P * power9[i + 1] % P * v.s1,
            P);
        }

        if (x == 7) break;
        last_a = last_a * 10 + x;
        last_b += x;
		//last_a%7!=0
        if (!i && last_a % 7 && last_b % 7) res = (res + backup_n * backup_n) % P;
    }

    return res;
}

int main()
{
    int T;
    cin >> T;

    init();

    while (T -- )
    {
        LL l, r;
        cin >> l >> r;
        cout << mod(dp(r) - dp(l - 1), P) << endl;
    }

    return 0;
}
素位明哲
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
动态规划----Amous_of_degrs
硕鼠的博客
03-22 376
/* * 题目大意: * 求给定区间[X,Y]中满足下列条件的整数个数：这个数恰好等于K个互不相等的B的整 * 数次幂之和。例如，设X=15，Y=20，K=2，B=2，则有且仅有下列三个数满足题意： * 17 = 2^4+2^0 * 18 = 2^4+2^1 * 20 = 2^4+2^2 * 输入：第一行包含两个整数X和Y。接下来两行包含整数K和B。
数位dp算法详细图文解答
02-13
数位动态规划（Digital Dynamic Programming, 简称数位DP）是一种用于解决与数字的组成有关的问题的算法。它通常涉及到对数字的每一位进行操作，通过递推和记忆化搜索来优化计算效率。数位DP的核心思想是将问题分解...
hdu4507——数位dp（计数求和）
mumei的博客
03-23 432
题目链接：https://vjudge.net/problem/HDU-4507 题目大意： 如果一个整数符合下面3个条件之一，那么我们就说这个整数和7有关—— 　　1、整数中某一位是7； 　　2、整数的每一位加起来的和是7的整数倍； 　　3、这个整数是7的整数倍； 求一定区间内与7无关的数的平方和。 题解： 这个题约束条件很常见，但是要求的不是数的个数，而是平方和就有点恶心了。...
GDSOI2019 D2 高中生数学题 （计算组合数中的质数幂次、库默尔定理、数位dp）
一位蒟蒻的小博客
05-04 720
库默尔定理： C(n,m)C(n,m)C(n,m)中含有的质数p幂次 = n−mn - mn−m在p进制下的借位次数 = m+(n−m)m + (n - m)m+(n−m)在p进制下的进位次数。 原理： Ans=∑k&gt;0npk−(n−mpk+mpk)Ans = \sum_{k&gt;0}\frac n {p^k}-(\frac{n-m}{p^k} + \frac{m}{p^...
AcWing1081.度的数量(数位DP)题解
逐梦er的博客
06-18 2714
题目传送门 求给定区间 [X, Y] 中满足下列条件的整数个数：这个数恰好等于 K 个互不相等的 B 的整数次幂之和。 例如，设 X=15,Y=20,K=2,B=2X=15,Y=20,K=2,B=2，则有且仅有下列三个数满足题意： 17=24+2017=24+20 18=24+2118=24+21 20=24+2220=24+22 输入格式 第一行包含两个整数 X 和 Y，接下来两行包含整数 K 和 B。 输出格式 只包含一个整数，表示满足条件的数的个数。 数据范围 1≤ X ≤ Y ≤2 ^31−1 1
一个正整数k(3≤k≤ 15),把所有k的方幂及所有有限个互不相等的k的方幕之和构成个通增的序列
二月鸟
11-04 5178
提供一个算法,其实由于是将有限个互不相等的k,所以我们这里考察第n项的时候,能取到的最大的k的幂次,不妨设次数是p,那么与之相关的很显然应该有2^p个,于是就想到了其实an与k的次数是和n的二进制有关的. 假设n=∑bk2k,bk=1或0.于是我们有an=∑(bk*k(k-1)). 比如说k=3,第7项,因为7对应的二进制数是111(2),所以a7=132+1*31+13^0=13. 若为第11项...
算法-动态规划- 数位 DP（包含源程序）.rar
09-16
这个压缩包“算法-动态规划- 数位 DP（包含源程序）.rar”很可能包含了关于数位DP的理论讲解以及相关的编程实现。 数位DP的基本思想是将一个大问题分解为若干个规模较小、相互关联的子问题，并逐个解决这些子问题，...
[宫水三叶的刷题日记]：数位DP1
08-03
【数位动态规划（DP）】是...通过不断练习和理解数位DP的原理，可以提高解题能力和算法素养，这对于程序员特别是Java开发者来说是非常重要的技能。在LeetCode等平台持续训练，可以加深对数位DP的理解，并提升编程能力。
数位dp——某次队内分享任务
07-21
数位动态规划(Digit Dynamic Programming, 简称数位DP)是一种在处理与数字相关的动态规划问题时，通过分析每个数字位上的状态来优化算法的技术。它通常用于解决涉及数字序列特性的数学问题，例如计数特定类型的数...
初探数位dp.pdf
09-16
lazycal的集训队报告：初探数位DP 以HDU 2089，HDU 3652, URAL 1057等题目为例，介绍了数位DP的算法
算法提高课第一章数位dp
csdn_ggboy的博客
11-19 69
减法求出区间答案，用树的思想来思考
【18】输出字符菱形
2301_78786609的博客
07-19 287
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
Held-Karp算法的C++代码
最新发布
m0_61862494的博客
07-19 108
Held-Karp算法是动态规划的一种应用，用于解决旅行商问题 (TSP)。该算法通过记录部分路径的最小成本来避免重复计算，从而有效地降低计算复杂度。Held-Karp算法使用一个状态压缩动态规划表。表示从起点出发，访问过所有由。表示的集合中的节点，并以节点。结束的最小路径长度。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 186
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
常见的排序算法，复杂度
m0_61544805的博客
07-16 516
稳定 / 非稳定排序：两个相等的数 排序前后 相对位置不变。 插入排序（希尔排序）： 每一趟将一个待排序记录，按其关键字的大小插入到已排好序的一组记录的适当位置上，直到所有待排序记录全部插入为止。稳定，O(n)，O(1)。 把记录按下标增量（模）分组，对每组进行直接插入排序，每次排序后减小增量，当增量减至 1 时排序完毕。不稳定，不知道（有个实验结论），O(1)。 冒泡排序： 比较相邻的元素，如果第一个比第二个大就进行交换，对每一对相邻元素做同样的工作。稳定，O(n)，O(1)。 选择
代码随想录学习 54day 图论 A star算法
qq_40445763的博客
07-17 386
【代码】代码随想录学习 54day 图论 A star算法。
树与二叉树
2201_76027754的博客
07-15 797
树和二叉树
完全二叉树的节点个数-递归
qq_45031559的博客
07-19 201
完全二叉树的节点个数-递归
【java】力扣 H指数
qq_55846232的博客
07-17 276
java 力扣 H指数
数位动态规划在区间统计问题中的应用
数位DP常用于解决包含数位之和、指定数码个数等条件的限制问题，需要逐位确定并可能涉及预处理。资料提供了多个在线博客和竞赛题目的链接作为进一步学习和实践的参考。" 数位动态规划（Digital Dynamic Programming...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值