数位DP

最新推荐文章于 2023-11-18 11:51:35 发布
最新推荐文章于 2023-11-18 11:51:35 发布
阅读量163 收藏 1
点赞数
分类专栏： ACM训练
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-NC-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43822233/article/details/108743051
版权

定义数位dp数组为 f [ x ] [ s t 1 ] [ s t 2 ] . . . [ s t n ] f[x][st1][st2]...[stn] f[x][st1][st2]...[stn]表示第x位状态为 s t 1... s t n st1...stn st1...stn的值。不要把 l i m lim lim放到数组里面，因为当lim = 1时，对于每个x只会进入一次。有时候这样能避免dp数组的每次初始化。

Windy 数

Windy定义了一种 Windy 数：不含前导零且相邻两个数字之差至少为2的正整数被称为Windy数。Windy想知道，在A和B之间，包括A和B，总共有多少个 Windy 数？

#include<bits/stdc++.h>
using namespace std;
int f[12][12],digit[12],cnt;
int dfs(int x,int st,int op){  // x为当前为第几位 st为前缀状态 op表示前缀和当前求解的数字的关系，1为相同 0为小于
    if(!x)return 1;
    if(!op && ~f[x][st])return f[x][st]; // 记忆化
    int maxx=op ? digit[x] : 9;
    int res=0;
    for(int i=0;i<=maxx;++i){
        if(abs(i-st)<2)continue;
        if(st==11 && i==0)res+=dfs(x-1,11,op && i==maxx);
        else res+=dfs(x-1,i,op && i==maxx);
    }
    if(!op)f[x][st]=res;
    return res;
}
int solve(int n){
    cnt=1;
    while(n){
        digit[cnt++]=n%10;
        n/=10;
    }
    return dfs(cnt-1,11,1)-1;  // -1排除0
}
int main(){
    memset(f,-1,sizeof f);
    int a, b;
    while(cin>>a>>b)
        cout<<solve(b)-solve(a-1)<<endl;
}

数字计数

求a和b之间的整数，每个数码出现的数量。

#include<bits/stdc++.h>
using namespace std;
using ll=long long;
class DP{
public:
    ll nums;
    vector<ll> v;
    DP(ll n=-1):nums(n),v(10) {}
    DP operator+ (const DP &x) const{
        DP res(nums+x.nums);
        for(int i=0;i<10;++i)
            res.v[i] = v[i] + x.v[i];
        return res;
    }
    DP operator- (const DP &x) const{
        DP res(nums-x.nums);
        for(int i=0;i<10;++i)
            res.v[i] = v[i] - x.v[i];
        return res;
    }
};
DP f[15];
int dig[15],cnt;
DP dfs(int x,int st,int op){   // st表示有没有前导零 op表示前缀和要求的数的是否相同
    if(!x)return DP(1);
    if(!st && !op && ~f[x].nums)return f[x];
    int maxx = op ? dig[x] : 9;
    DP res(0);
    for(int i=0;i<=maxx;++i){
        if(st && i==0){  // 排除前导零
            res = res + dfs(x-1, 1, op && i==maxx);
        }else{
            DP tmp = dfs(x-1, 0, op && i==maxx);
            res = res + tmp;
            res.v[i] += tmp.nums;
        }
    }
    if(!st && !op)f[x] = res;
    return res;
}
DP solve(ll x){
    cnt = 1;
    for(int i=0;i<15;++i)
        f[i] = DP(-1);
    while(x){
        dig[cnt++] = x%10;
        x /= 10;
    }
    return dfs(cnt-1, 1, 1);
}
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0),cout.tie(0);
    ll a,b;
    while(cin>>a>>b){
        DP b_ans = solve(b), a_ans = solve(a-1);
        DP res = b_ans - a_ans;
        for(int i=0;i<10;++i){
            cout<<res.v[i]<<' ';
        }
        cout<<endl;
    }
}

同类分布

给出两个数a,b，求出[a,b]中各位数字之和能整除原数的数的个数。
f[x][st][val]，x为当前所在位，st为前缀和数字和，val为前缀值模mod的值。

#include<bits/stdc++.h>
using namespace std;
#define endl '\n'
using ll = long long;
using pii = pair<int,int>;
const int maxn=3e5+3;
int mod, dig[20];
ll f[20][170][170];
ll dfs(int x,int st,int val,int lim){
    if(!x)return st == mod && val == 0;  // 当前缀为mod，值%mod为0时有贡献
    if(st>mod)return 0;
    if(!lim && ~f[x][st][val])return f[x][st][val];
    int maxx = lim ? dig[x] : 9;
    ll res=0;
    for(int i=0;i<=maxx;++i){
        res += dfs(x-1,st+i,(val*10+i)%mod,lim && i==maxx);
    }
    if(!lim)f[x][st][val] = res;
    return res;
}
ll solve(ll x){
    ll ans=0;
    int cnt=0;
    while(x){
        dig[++cnt] = x % 10;
        x /= 10;
    }
    for(int i=1;i<162;++i){
        memset(f,-1,sizeof f);
        mod = i;
        ans += dfs(cnt, 0, 0, 1);
    }
    return ans;
}
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0),cout.tie(0);
    ll a,b;
    cin>>a>>b;
    cout<<solve(b)-solve(a-1)<<endl;

}

Valley Numer

当一个数字，从左到右依次看过去数字没有出现先递增接着递减的“山峰”现象，就被称作 Valley Number。它可以递增，也可以递减，还可以先递减再递增。在递增或递减的过程中可以出现相等的情况。比如，1，10，12，212，32122都是 Valley Number。
求不大于N的Valley Number数有多少。
f[x][st][up][ish]，x为当前位，st为上一个数字的值，up为现在是否为递增，ish为现在是否为最高位。

#include<bits/stdc++.h>
using namespace std;
#define endl '\n'
using ll = long long;
using pii = pair<int,int>;
const int maxn=1e2+3;
const ll mod=1e9+7;
char dig[maxn];
int f[maxn][10][2][2],cnt=0;
ll dfs(int x,int st,bool up,bool ish,int lim){
    if(x==cnt){  return 1;}
    if(!lim && ~f[x][st][up][ish])return f[x][st][up][ish];
    int maxx = lim ? dig[x]-'0' : 9;
    ll res = 0;
    for(int i=0;i<=maxx;++i){
        if(ish && i==0){
            res = (res+dfs(x+1,9,0,1,lim && i==maxx))%mod;
        }else if(up){
            if(i<st)continue;
            res = (res+dfs(x+1,i,1,0,lim && i==maxx))%mod;
        }else{
            if(i<=st) res = (res+dfs(x+1,i,0,0,lim && i==maxx))%mod;
            else res = (res+dfs(x+1,i,1,0,lim && i==maxx))%mod;
        }
    }
    if(!lim)f[x][st][up][ish] = res;
    return res;
}
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0),cout.tie(0);
    int T;
    cin>>T;
    while(T--){
        cin>>dig;
        cnt = strlen(dig);
        memset(f,-1,sizeof f);
        cout<<dfs(0,9,0,1,1)-1<<endl;
    }
}

当数位dp数组中不放lim时，可以只memset一次。

#include<bits/stdc++.h>
using namespace std;
#define endl '\n'
using ll = long long;
using pii = pair<int,int>;
const int maxn=1e2+3;
const ll mod=1e9+7;
char dig[maxn];
int f[maxn][10][2][2],cnt=0;
ll dfs(int x,int st,bool up,bool ish,int lim){
    if(x==-1)return 1;
    if(!lim && ~f[x][st][up][ish])return f[x][st][up][ish];
    int maxx = lim ? dig[x]-'0' : 9;
    ll res = 0;
    for(int i=0;i<=maxx;++i){
        if(ish && i==0){
            res = (res+dfs(x-1,9,0,1,lim && i==maxx))%mod;
        }else if(up){
            if(i<st)continue;
            res = (res+dfs(x-1,i,1,0,lim && i==maxx))%mod;
        }else{
            if(i<=st) res = (res+dfs(x-1,i,0,0,lim && i==maxx))%mod;
            else res = (res+dfs(x-1,i,1,0,lim && i==maxx))%mod;
        }
    }
    if(!lim)f[x][st][up][ish] = res;
    return res;
}
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0),cout.tie(0);
    int T;
    cin>>T;
    memset(f,-1,sizeof f);
    while(T--){
        cin>>dig;
        cnt = strlen(dig);
        reverse(dig,dig+cnt);  // 保持f数组下标0为个位
        cout<<dfs(cnt-1,9,0,1,1)-1<<endl;
    }
}

Beautiful numbers

求 9 e 18 9e18 9e18范围内，[a,b]之间的数中符合<每个非零数位都能整除这个数>的数的数量。思路：问题可转化为每个非零数位的lcm能整除这个数。由于2520是1-9的lcm，问题转化为每个非零数位的lcm能整除这个数取模2520.
f[x][st][op]，x为当前位，st为前缀lcm，op为当前的前缀取模2520.
特殊：由于f数组和lim无关，所以在不同次查询中都能用！只要初始化一次！ 否则会超时。

#include<bits/stdc++.h>
using namespace std;
//#define endl '\n'
using ll = long long;
using pii = pair<int,int>;
const int maxn=1e2+3;
const ll mod = 2520;
int arr[][4]={{1,2,4,8},{1,3,9},{1,5},{1,7}}, na[]={4,3,2,2};
ll f[20][50][2523];
int dig[20],ma[2523];
vector<int> num;
int gcd(int a,int b){
    return a%b ? gcd(b,a%b) : b;
}
void init(int x,int now){
    if(x&4){num.push_back(now);return;}
    for(int i=0;i<na[x];++i)
        init(x+1,arr[x][i]*now);
}
ll dfs(int x,int st,int op,int lim){
    if(!x)return op%st==0;
    if(!lim && ~f[x][ma[st]][op])return f[x][ma[st]][op];
    int maxx = lim ? dig[x] : 9;
    ll ans=0;
    for(int i=0;i<=maxx;++i){
        if(i==0 || st % i == 0)
            ans += dfs(x-1,st,(op*10+i)%mod,lim&&i==maxx);
        else
            ans += dfs(x-1,st*i/gcd(st,i),(op*10+i)%mod,lim&&i==maxx);
    }
    if(!lim)f[x][ma[st]][op]=ans;
    return ans;
}
ll solve(ll x){
    int cnt=0;
    while(x){
        dig[++cnt] = x % 10;
        x /= 10;
    }
    return dfs(cnt, 1, 0, 1);
}
int main(){
    memset(f,-1,sizeof f);
    ios::sync_with_stdio(false);
    cin.tie(0),cout.tie(0);
    init(0,1);
    for(int i=0;i<num.size();++i)
        ma[num[i]] = i;
    int T;
    cin>>T;
    while(T--){
        ll a,b;
        cin>>a>>b;
        cout<<solve(b)-solve(a-1)<<endl;
    }
}

P3286 [SCOI2014]方伯伯的商场之旅

题意：对于一个数 i i i，把它看成 k k k进制数，把所有位上的数移动到一个位上，代价是移动的石子数量 × 移动的距离。问把 [ L , R ] [L,R] [L,R]内每个数都进行一次合并，求最小合并代价。
思路：先假设所有数都合并到个位，很容易能得到总代价。然后考虑移动。当一个n位数的 s u m [ n . . . i ] > s u m [ i − 1...1 ] sum[n...i]>sum[i-1...1] sum[n...i]>sum[i−1...1] 时，它合并到的点必然 ≥ i ≥i ≥i，所以并且代价应该减少 s u m [ n . . . i ] − s u m [ i − 1...1 ] sum[n...i]-sum[i-1...1] sum[n...i]−sum[i−1...1]。所以可以贪心一位一位进行数位DP。

#include<bits/stdc++.h>
using namespace std;
//#define endl '\n'
#define IOS ios::sync_with_stdio(false); cin.tie(0), cout.tie(0)
typedef long long LL;
const int N = 5e4 + 5, K = 105;
const int inf = 1e9;
const long long mod = 1e9 + 7;
using LD = long double;
using LL = long long;
using PII = pair<int, int>;
/*
* long long !!!
* array size !!!
*/
int dig[1005];
LL f[105][1505], pos, k;
LL dfs(int x, int st, int lim){
    if(pos > 1 && st < 0)return 0;
    if(!x)return st;
    if(!lim && ~f[x][st])return f[x][st];
    int maxx = lim ? dig[x] : k - 1;
    LL res = 0;
    for(int i = 0; i <= maxx; ++i){
        if(pos == 1)res += dfs(x-1, st + i * (x - 1), lim && i == dig[x]);
        else if(x >= pos)res += dfs(x-1, st + i, lim && i == dig[x]);
        else res += dfs(x-1, st - i, lim && i == dig[x]);
    }
    if(!lim)f[x][st] = res;
    return res;
}
LL solve(LL n){
    int cnt = 0;
    while(n){
        dig[++cnt] = n % k;
        n /= k;
    }
    pos = 1;
    memset(f, -1, sizeof(f));
    LL ans = dfs(cnt, 0, 1);
    for(pos = 2; pos <= cnt; ++pos){
        memset(f, -1, sizeof(f));
        //cout << ans << endl;
        ans -= dfs(cnt, 0, 1);
    }
    return ans;
}

int main(){
    IOS;
    LL l, r;
    cin >> l >> r >> k;
    cout << solve(r) - solve(l - 1) << endl;
}
mr.chen116
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数位dp
nowting的博客
11-06 206
先看一道题目： 不要62 Time Limit: 1000/1000 MS (Java/Others)Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 59667Accepted Submission(s): 23557 Problem Description 杭州人称那些傻乎乎粘嗒嗒的人为62...
【总结】数位DP
XSC062 的博客
12-29 190
填坑进度（3/4） 边听歌边写博客，我可真是个天才。 I’m lost inside your deep blue.\texttt{I'm lost inside your deep blue.}I’m lost inside your deep blue. 数位DP 简称暴搜（误 前置芝士 暴搜，记忆化搜索 导入 众所周知，我们可以用 dfsdfsdfs 搜每一个数位来遍历 1∼999991\sim9
c++数位dp——超实用的数据结构
最新发布
yzc_qiuse的博客
11-18 293
今天的文章就到这里啦，三连必回qwq！
[C++]洛谷：数字计数 数位dp算法详解
weixin_62712365的博客
07-30 1930
数字计数：数位dp算法详解，简单易懂！
数位DP(预处理, 倍增的拼凑思想, 试填法 或者 记忆化搜索)
CK1513710764的博客
04-06 503
数位DP是一种特殊的计数DP, 与数字统计有关,一般求满足限制条件的第K小的数是多少,或者求在区间[L, R]内有多少满足条件的数字. 解决方法:先用动态规划进行预处理,基于"拼凑"思想,用"试填法"求出最终的答案. (动态规划预处理部分的作用充当记忆作用,事实上这就是动态规划的本质) 例题一: 直接从前向后枚举答案的每一位数(从小到大枚举)是多少,计算在这样的前缀下,后面的总排列数,如果加起来大于等于C, 说明当前的一位数就是这个枚举的数,我们继续讨论下一位即可. 我们先用动态规划预处理出木
数位dp介绍
08-13 531
不了解dp的可以先看一下dp 数位dp含义： 数位：一个数有个位，十位，百位，千位等等，数的每一位都是数位。 数位dp归为计数dp，是在数位上进行操作的dp。 数位dp的实质是一种快速枚举的方式，它满足dp的性质，然后进行记忆化搜索。 用途： 有两个数，两个数范围很大(例如1e9，甚至更大)，求这两个数符合限定条件的个数。纯暴力不行，就要用数位dp。 例子：求从0到n,（n...
数位DP.pdf
07-12
数位DP整理的模板和一些题目的题解。QAQ没钱下载资源了只好上传点东西。
数位dp——某次队内分享任务
07-21
数位动态规划(Digit Dynamic Programming, 简称数位DP)是一种在处理与数字相关的动态规划问题时，通过分析每个数字位上的状态来优化算法的技术。它通常用于解决涉及数字序列特性的数学问题，例如计数特定类型的数...
数位dp算法详细图文解答
02-13
PPT图片结合文字讲述数位dp
数位DP入门
08-22
数位DP入门思想，包括详细的思考过程以及一些习题的讲解
4数位DP1
08-08
然后通过三重循环更新`dp`数组，分别对序列长度、和以及当前数位进行迭代。 总结来说，这个题目涉及到的IT知识点包括： 1. 动态规划（DP）及其记忆化搜索 2. 深度优先搜索（DFS）用于位枚举 3. 状态转移和状态设计...
数位dp(记忆化和循环两种写法都有)
xumingyang0的博客
05-17 242
Beautiful numbers //https://www.cnblogs.com/xcw0754/p/4854539.html #include&amp;lt;bits/stdc++.h&amp;gt; using namespace std; typedef long long ll; const int M=2520; int p[49]={0,1,2,3,4,5,6,7,8,9,10,12,14...
数位DP学习整理（数位DP看完这篇你就会了）
热门推荐
pursuit的博客
05-12 3万+
文章目录数位DP数位DP介绍数位DP解法数位DP经典例题例题1：度的数量例题2：计数问题例题3：数字游戏例题4：windy数数位DP总结 数位DP 数位DP介绍 数位DP往往都是这样的题型，给定一个闭区间[l,r][l,r][l,r]，让你求这个区间中满足某种条件的数的总数。而这个区间可能很大，简单的暴力代码如下： int ans=0; for(int i=l;i<=r;i++){ if(check(i))ans++; } 我们发现，若区间长度超过1e81e81e8，我们暴力枚举就会超时了，
【C++】数位DP的模板(找到小于n的数字的每位组成)
小黑同学的博客
10-18 631
数位DP的思想介绍与模板
788. 旋转数字
yungezier的博客
11-02 995
788. 旋转数字 我们称一个数 X 为好数, 如果它的每位数字逐个地被旋转 180 度后，我们仍可以得到一个有效的，且和 X 不同的数。要求每位数字都要被旋转。 如果一个数的每位数字被旋转以后仍然还是一个数字， 则这个数是有效的。0, 1, 和 8 被旋转后仍然是它们自己；2 和 5 可以互相旋转成对方（在这种情况下，它们以不同的方向旋转，换句话说，2 和 5 互为镜像）；6 和 9 同理，除了这些以外其他的数字旋转以后都不再是有效的数字。 现在我们有一个正整数 N, 计算从 1 到 N 中有多少个数 X
dp 就 dp ，数位dp是什么意思 ？
仰望天空，妳我亦是行人.
03-28 2223
🐬初学一门技术时，总有些许的疑惑，别怕，它们是我们学习路上的点点繁星，帮助我们不断成长。🦄文章粗浅，希望对大家有帮助！
图转树，边化点
Mr.chen116的博客
02-25 2236
文章目录[2016-2017 ACM-ICPC CHINA-Final G. Pandaria](https://codeforces.com/gym/101194/problem/G)\[AMPPZ2014\]Petrol 2016-2017 ACM-ICPC CHINA-Final G. Pandaria 题意：给一个nnn个点，mmm条有权边的无向图。每个点有一个颜色。多次查询在线查询x wx\ wx w，从xxx出发，只能走边权小于等于www的边，可以到达的所有点中数量最多的颜色

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值