数位DP入门题目

最新推荐文章于 2023-03-11 17:31:29 发布
最新推荐文章于 2023-03-11 17:31:29 发布
阅读量161 收藏 3
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48344603/article/details/112969506
版权

数位DP通常是用来求解给你一个 [ l , r ] [l,r] [l,r]区间，求这个区间满足一定条件的数的个数。

个人认为数位DP最重要的两个点：
1、len==0时，即遍历完一个数后，返回什么？
2、dp方程，如何能确保DP的唯一性。

其余的都是套模板

1.Bomb

题目链接：点击此处

题意：求 [ 1 , n ] [1,n] [1,n]中含49的个数

数位DP往往用一个数组来记录 n n n中每一个位的值，这边用 d i g i t [ i ] digit[i] digit[i]表示从个位到最高位的第 i i i位为多少。

比如1234，则 d i g i t [ 1 ] = 4 , d i g i t [ 2 ] = 3 , d i g i t [ 3 ] = 2 , d i g i t [ 4 ] = 1 digit[1]=4,digit[2]=3,digit[3]=2,digit[4]=1 digit[1]=4,digit[2]=3,digit[3]=2,digit[4]=1

在这里，我们要知道，我们如果求到了[1,100]中49的个数，那么[101,200]中49的个数也知道了，同理，往下推，除了一个[401,500]中49的个数不同，其他都是相同的，原因是49可能出现在百位上是4，十位上是9的情况。那么这表示，遇到这种情况我们要特判。

其次，我们对于1234，我们容易通过一些状态得知[1001，1100]中含有49的个数，同理，对于[1101,1200]也是，但是对于[1201,1234]我们不能通过前面那2个得到，因为前面那两组求得的是间隔100的49的数量，但是这里间隔只有34，所以，我们要特殊处理。

从这里，我们也知道，对于上一位为4，这一位为9的情况，我们要特殊判断，对于我们遇到了相应位上有上限的情况（比如对于1234，千位为1，遇到了百位为2时，要开始特判），我们也要判断。

#include<iostream>
#include<vector>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iomanip>
#include<stdio.h>
#include<map>
#include<queue>
using namespace std;
#define Check(x) cout<<"x:"<<x<<" "
#define Min(x,y,z) min(x,min(z,y))
#define Max(x,y,z) max(x,max(z,y))
typedef long long ll;
const int MAXN =2e3 + 5;
const int MAXM = 1e6 + 5;
const ll mod = 1e9 + 7;
int digit[25];
ll dp[25][2];
ll dfs(int len, bool if4, bool limit) {//求得是不满足条件的数目
	if (len == 0)return 1;//例如对于1来讲，不满足条件，肯定就1这一个数，2也是，9也是，因为就一位怎么凑得齐49呢。
	if (!limit && dp[len][if4])return dp[len][if4];//dp表示长度为len中，有无4的不符合条件的个数
	ll cnt = 0, up = (limit ? digit[len] : 9);
	for (int i = 0;i <= up;i++) {
		if (if4 && i == 9)continue;
		cnt += dfs(len - 1, i == 4, limit && i == up);
	}
	if (!limit)dp[len][if4] = cnt;
	return cnt;
}
ll solve(ll num) {
	int k = 0;
	while (num) {
		digit[++k] = num % 10;
		num /= 10;
	}
	return dfs(k, false, true);
}
int main() {
	int t;
	cin >> t;
	while (t--) {
		ll n;
		cin >> n;
		cout << n + 1LL - solve(n) << endl;
	}
}

2.不要62

题目链接：点击此处

题意：给你一个 [ l , r ] [l,r] [l,r]区间，其中不包含4和62的多少。

和上一题有相似之处，对于不包含62，我们只要模仿上一个就行，那么对于4呢？

因为我们在dfs枚举的时候是枚举长度为len的所有情况，如果枚举到4了，那么只要continue就行，就可以把4去掉。

#include<iostream>
#include<vector>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iomanip>
#include<stdio.h>
#include<map>
#include<queue>
using namespace std;
#define Check(x) cout<<"x:"<<x<<" "
#define Min(x,y,z) min(x,min(z,y))
#define Max(x,y,z) max(x,max(z,y))
typedef long long ll;
const int MAXN =2e3 + 5;
const int MAXM = 1e6 + 5;
const ll mod = 1e9 + 7;
int digit[25];
ll dp[25][2];
ll dfs(int len, bool if6, bool limit) {
	if (len == 0)return 1;
	if (!limit && dp[len][if6])return dp[len][if6];
	ll cnt = 0, up = (limit ? digit[len] : 9);
	for (int i = 0;i <= up;i++) {
		if (if6 && i == 2)continue;
		if (i == 4)continue;
		cnt += dfs(len - 1, i == 6, limit && i == up);
	}
	if (!limit)dp[len][if6] = cnt;
	return cnt;
}
ll solve(ll num) {
	int k = 0;
	while (num) {
		digit[++k] = num % 10;
		num /= 10;
	}
	return dfs(k, false, true);
}
int main() {
	ll n, m;
	while (cin >> n >> m) {
		if (n == 0 && m == 0)break;
		cout << solve(m) - solve(n-1) << endl;
	}
}

3.Windy 数

题目链接：点击此处

题目意思：
Windy 定义了一种 Windy 数：不含前导零且相邻两个数字之差至少为 2的正整数被称为 Windy 数。

Windy 想知道，在 [ l , r ] [l,r] [l,r]之间，总共有多少个 Windy 数？

这次我们要得到的数是差大于2的那些数，用st表示上一层的值，这一层老规矩枚举到最大值，如果这一层的值与st的差小于2，continue。

特殊情况就是如果上一层是0，即st==11时，这一层我们选0，那么我们这一层递归的st要是11，而不能是i，因为这表示下一层的数我们还是可以随便选。

#include<iostream>
#include<vector>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iomanip>
#include<stdio.h>
#include<map>
#include<queue>
using namespace std;
#define Check(x) cout<<"x:"<<x<<" "
#define Min(x,y,z) min(x,min(z,y))
#define Max(x,y,z) max(x,max(z,y))
typedef long long ll;
const int MAXN =2e3 + 5;
const int MAXM = 1e6 + 5;
const ll mod = 1e9 + 7;
int digit[25];
ll dp[25][15];
ll dfs(int len, int st, bool limit) {
	if (len == 0)return 1;
	if (!limit && dp[len][st])return dp[len][st];
	int maxx = limit ? digit[len] : 9;
	ll cnt = 0;
	for (int i = 0;i <= maxx;i++) {
		if (abs(st - i) < 2)continue;
		if (st == 11 && i == 0) {
			cnt += dfs(len - 1, 11, limit && i == maxx);
		}
		else {
			cnt += dfs(len - 1, i, limit && i == maxx);
		}
	}
	if (!limit)dp[len][st] = cnt;
	return cnt;
}
ll solve(ll num) {
	int k = 0;
	while (num) {
		digit[++k] = num % 10;
		num /= 10;
	}
	return dfs(k, 11, true);
}
int main() {
	ll n, m;
	cin >> n >> m;
	//cout << solve(m) << " " << solve(n - 1) << endl;
	cout << solve(m) - solve(n-1) << endl;
	
}

4.数字计数

题目链接：点击此处

题意：找出 [ l , r ] [l,r] [l,r]区间中0到9的个数

因为是要讨论0到9，不妨从头0到0-9一个个讨论分析。

首先数位DP肯定要知道有limit，并且在长度为0时要返回一个数，但是要返回多少，这个不确定，为何？其实数位DP从len递归到0，做的是对一个数的分解，也就是说我们递归到0，其实就是分析清楚了一个数的情况。上面几个题为何返回1，是因为他们是符合要求的一个数，这题为何不返回1，因为这题记录的是0到9的个数，返回的应该是这个数中目标数的个数。例如1124，讨论1的个数的话，就返回2，讨论2的个数的话就返回1，讨论3的个数的话就返回0。

其次 d p [ i ] [ j ] dp[i][j] dp[i][j]表示 i i i位数，其中 l e n len len到 i i i位中含有 j j j个含有对应位。

#include<iostream>
#include<vector>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iomanip>
#include<stdio.h>
#include<map>
#include<queue>
using namespace std;
#define Check(x) cout<<"x:"<<x<<" "
#define Min(x,y,z) min(x,min(z,y))
#define Max(x,y,z) max(x,max(z,y))
typedef long long ll;
const int MAXN =2e5 + 5;
const int MAXM = 1e6 + 5;
const ll mod = 1e9 + 7;
int arr[MAXN];
int digit[20];
ll dp[20][20];
ll ans[10] = { 0 };

ll dfs(int len, bool lead, bool limit, int tar, ll sum) {
	if (len == 0)return sum;
	if ( !limit && ~dp[len][sum])return dp[len][sum];
	ll cnt = 0;
	int maxx = limit ? digit[len] : 9;
	for (int i = 0;i <= maxx;i++) {
		cnt += dfs(len - 1, lead || i, limit && i == maxx, tar, sum + ((lead || i) && (tar == i)));
	}
	if (!limit && lead)dp[len][sum] = cnt;
	return cnt;
}
ll solve(ll num,int tar) {
	memset(dp, -1, sizeof dp);
	int k = 0;
	while (num) {
		digit[++k] = num % 10;
		num /= 10;
	}
	return dfs(k, false, true, tar, 0);
	
}
int main() {
	ll n, m;
	cin >> n >> m;
	solve(m, 1);
	solve(n, -1);
	for (int i = 0;i <= 9;i++) {
		cout <<solve(m,i)-solve(n-1,i) << " ";
	}
	cout << endl;
}

5.同类分布

题目链接：点击此处

给 [ l , r ] [l,r] [l,r]，找出区间中的各位数字之和能整除原数的数的个数。

数位DP， d p [ l e n ] [ s u m ] [ s t ] dp[len][sum][st] dp[len][sum][st]，其中 l e n len len表示我们剩下未遍历的位数， s u m sum sum表示我们已遍历的数总和， s t st st表示已遍历的数取模 m o d mod mod的结果。这样 d p [ l e n ] [ s u m ] [ s t ] dp[len][sum][st] dp[len][sum][st]表示的结果具有唯一性。即可以使用记忆化搜索。因为假如我们未处于 l i m i t limit limit状态，我们对于已经遍历的得到的 s u m sum sum和 s t st st，后序不管遍历得到哪一个数字， s u m sum sum和 s t st st都是一一对应着变化的。所以我们只要这3个值一确定，如果 d p dp dp有记录，那么就可以得到答案。

最后 l e n = 0 len=0 len=0时返回结果1的条件必须是 s u m = m o d 且 s t = 0 sum=mod 且st=0 sum=mod且st=0


#include<iostream>
#include<vector>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iomanip>
#include<stdio.h>
#include<map>
#include<queue>
using namespace std;
#define Check(x) cout<<"x:"<<x<<" "
#define Min(x,y,z) min(x,min(z,y))
#define Max(x,y,z) max(x,max(z,y))
typedef long long ll;
const int MAXN = 2e5 + 5;
const int MAXM = 1e6 + 5;
ll n, m;
ll dp[20][200][200];
int digit[20];
ll mod = 0;
ll dfs(int len, ll sum, ll st, bool limit) {
    if (len == 0) {
        if (sum == mod)return st==0?1:0;
        else return 0;
    }
    if (!limit&&~dp[len][sum][st])return dp[len][sum][st];
    int res = limit?digit[len] : 9;
    ll ret = 0;
    for (int i = 0;i <= res;i++) {
        ret += dfs(len - 1, sum + i, (10ll * st + i) % mod, i == res && limit);
    }
    if (!limit)dp[len][sum][st] = ret;
    return ret;
}
ll solve(ll num) {
    int k = 0;
    while (num) {
        digit[++k] = num % 10;
        num /= 10;
    }
    ll ans = 0;
    for (ll i = 1;i <= 9 * k;i++){
        mod = i;
        memset(dp, -1, sizeof dp);
       ans += dfs(k, 0, 0, true);
    }
    return ans;
}
int main() {
    cin >> n >> m;
    cout << solve(m) - solve(n-1) << endl;
}

6.萌数

题目链接：点击此处
只有满足“存在长度至少为2的回文子串”的数是萌的——也就是说，101是萌的，因为101本身就是一个回文数；110是萌的，因为包含回文子串11；但是102不是萌的，1201也不是萌的。

现在想知道从l到r的所有整数中有多少个萌数。

由于答案可能很大，所以只需要输出答案对1000000007（10^9+7）的余数。

整数的长度为1到1000。

这题考了一个思维，就是如果存在4位回文，那么必定存在2位回文。比如1001中，00必定是回文。

所以本题只要看遍历的那个数和前面2个数是否组成回文就行。

个人认为数位DP其实难点在于如何确定唯一条件。

本题 d p [ l e n ] [ p r e 1 ] [ p r e 2 ] [ h a v e ] dp[len][pre1][pre2][have] dp[len][pre1][pre2][have]，首先 l e n len len表示剩余未访问的位数长度, p r e 1 pre1 pre1表示前面2位的值， p r e 2 pre2 pre2表示前面1位的值， h a v e have have表示到现在是否存在回文。这DP就已经有了唯一性了。因为 p r e 1 pre1 pre1和 p r e 2 pre2 pre2和 h a v e have have已经完全表示前面数的状态。

然后 l e n = 0 len=0 len=0时，如果 h a v e = 1 have=1 have=1返回1， h a v e = 0 have=0 have=0返回0.


#include<iostream>
#include<vector>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iomanip>
#include<stdio.h>
#include<map>
#include<queue>
using namespace std;
#define Check(x) cout<<"x:"<<x<<" "
#define Min(x,y,z) min(x,min(z,y))
#define Max(x,y,z) max(x,max(z,y))
typedef long long ll;
const int MAXN = 2e5 + 5;
const int MAXM = 1e6 + 5;
ll n, m;
ll dp[1005][11][11][2];
int digit[1005];
ll mod = 1e9 + 7;;
ll dfs(int len,int pre1,int pre2,bool have, bool limit) {
    if (len == 0) {
        if (!have)return 0;
        else return 1;
    }
    if (!limit && ~dp[len][pre1+1][pre2+1][have])return dp[len][pre1+1][pre2+1][have]%mod;
    int maxx = limit ?  digit[len] : 9;
    ll res = 0;
    for (int i = 0;i <= maxx;i++) {
        bool f = false;
        if (pre1 == i || pre2 == i) {
            f = true;
        }
        if (pre1 == -1 && pre2 == -1 && i == 0)res += dfs(len - 1, -1, -1, 0, limit && i == maxx);
        else res += dfs(len - 1, pre2, i, f || have, limit && i == maxx);
        res %= mod;
    }
    if (!limit)dp[len][pre1+1][pre2+1][have] = res % mod;
    return res%mod;
}
ll solve(string num) {
    int len = num.length();
    for (int i = len - 1;i >= 0;i--)digit[len - i] = num[i] - '0';
    memset(dp, -1, sizeof dp);
    return dfs(len, -1, -1, 0, 1);
}
int main() {
    string a, b;
    cin >> a >> b;
    int pre1 = -1, pre2 = -1;
    bool f = false;
    for (int i = 0;i < a.length();i++) {
        int u = a[i] - '0';
        if (u == pre1 || u == pre2) { f = true;break; }
        pre1 = pre2;
        pre2 = u;
    }
    ll now = (solve(b) - solve(a) + mod) % mod;
    if (f)now++;
    now %= mod;
    cout << now << endl;
}

7.Valley Numer

题目链接：点击此处

求１－ｒ中无山峰的数的个数。

这题很明显的知道我们要用一个标记标记是否存在上坡，不然哪来的山峰。这里我们用 u p up up标记。

之后我们还要有个标记记录上坡后是否存在下坡。这里我们用 h a v e have have来标记。

当然我们比较肯定需要有前一个数字的信息。这里我们用 p r e pre pre记录。

那么DP就很容易写了（要确保唯一性）, d p [ l e n ] [ p r e ] [ u p ] [ h a v e ] dp[len][pre][up][have] dp[len][pre][up][have]，这里的 p r e ， u p ， h a v e pre，up，have pre，up，have已经确保了当前的状态的唯一性了，后面即不会表示多于等于2个不同的状态。

l e n = = 0 len==0 len==0时，如果 h a v e have have返回0，否则返回1。


#include<iostream>
#include<vector>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iomanip>
#include<stdio.h>
#include<map>
#include<queue>
using namespace std;
#define Check(x) cout<<"x:"<<x<<" "
#define Min(x,y,z) min(x,min(z,y))
#define Max(x,y,z) max(x,max(z,y))
typedef long long ll;
const int MAXN = 2e5 + 5;
const int MAXM = 1e6 + 5;
ll n, m;
ll dp[105][11][2][2];
int digit[105];
ll mod = 1e9 + 7;;
ll dfs(int len,int pre,bool up,bool have, bool limit) {
    if (len == 0) {
        if (have)return 0;
        else return 1;
    }
    if (!limit && ~dp[len][pre][up][have])return dp[len][pre][up][have];
    ll ans = 0;
    int maxx = limit ? digit[len] : 9;
    for (int i = 0;i <= maxx;i++) {
        if (pre == -1 && i == 0)ans += dfs(len - 1, -1, 0, 0, limit && i == maxx);
        else  if (pre == -1 && i != 0)ans += dfs(len - 1, i, 0, 0, limit && i == maxx);
        else if (pre != -1) {
            ans += dfs(len - 1, i, i > pre || up, have || (up && i < pre), limit && i == maxx);
        }
        ans %= mod;
    }
    if (!limit)dp[len][pre][up][have] = ans%mod;
    return ans%mod;
}
ll solve(string num) {
    int len = num.length();
    for (int i = len - 1;i >= 0;i--)digit[len - i] = num[i] - '0';
    memset(dp, -1, sizeof dp);
    return dfs(len, -1,0, 0, 1);
}
int main() {
    int t;
    cin >> t;
    while (t--) {
        string a, b;
        cin >> b;
        ll res = (solve(b) -1)% mod;
        cout << res << endl;
    }
}

8. Beautiful numbers

题目链接:点击此处

求[l,r]中一个数能被组成该数的所有非零数整除个数。

很容易知道被一个数的组成数整除，就相当于一个数能被组成数的LCM整除。

那么我们现在想我们上文的2个重要状态。

一个是DP的唯一性，一个len=0时返回什么。

如何定义DP能够让DP唯一标识一个数呢。

d p [ l e n ] [ l c m ] [ s t ] dp[len][lcm][st] dp[len][lcm][st]表示剩余 l e n len len个，哪些遍历过的数的 L C M = l c m LCM=lcm LCM=lcm，一个数取余2520= s t st st。为何取余2520，因为1到9的 L C M LCM LCM为2520，我们一个数能被2520取余为0，那么肯定可以被lcm取余为0。我们这样取可以表示唯一状态而且空间利用小。

l e n = 0 len=0 len=0时，如果 s t % l c m = 0 st\%lcm=0 st%lcm=0，返回1，否则返回0。


#include<iostream>
#include<vector>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iomanip>
#include<stdio.h>
#include<map>
#include<queue>
using namespace std;
#define Check(x) cout<<"x:"<<x<<" "
#define Min(x,y,z) min(x,min(z,y))
#define Max(x,y,z) max(x,max(z,y))
typedef long long ll;
const int MAXN = 2e5 + 5;
const int MAXM = 1e6 + 5;
ll n, m;
ll dp[20][50][2520];
ll digit[105];
ll mod = 0;
int cnt = 0;
inline ll read() {
    ll X = 0, w = 1; char c = getchar();
    while (c < '0' || c>'9') { if (c == '-') w = -1; c = getchar(); }
    while (c >= '0' && c <= '9') X = X * 10 + c - '0', c = getchar();
    return X * w;
}
int GCD(int a, int b) {
    return b == 0 ? a : GCD(b, a % b);
}
int LCM(int a, int b) {
    return a / GCD(a, b) * b;
}
int tong[2521] = { 0 };
void init() {
    for (int i = 1;i <= 2520;i++) {
        if (2520 % i == 0) {  tong[i] = ++cnt; }
    }
}
ll dfs(int len,int lcm,int st,bool limit) {
    if (len == 0) {
        return st % lcm == 0;
    }
    if (!limit && ~dp[len][tong[lcm]][st])return dp[len][tong[lcm]][st];
    int maxx = limit ? digit[len] : 9;
    ll ans = 0;
    for (int i = 0;i <= maxx;i++) {
         int L = (i == 0 ? lcm : LCM(lcm, i));
         ans += dfs(len - 1, L, (st * 10 + i) %2520, limit && i == maxx);
    }
    if (!limit)dp[len][tong[lcm]][st] = ans;
    return ans;
}
ll solve(ll num) {
    int k = 0;
    while (num) {
        digit[++k] = num % 10;
        num /= 10;
    }
    
    return dfs(k,1,0,1);
}
int main() {
    ll t;
    t=read();
    init();
    memset(dp, -1, sizeof dp);
    while(t--){
        ll a,b;
        a = read(), b = read();
        printf("%I64d\n", solve(b) - solve(a - 1)); 
    }
}

9.Magic Number

题目链接：点击此处

这个对于不满足条件的直接continue就行，因为一旦不满足条件，后续不管怎么变都不满足条件。

对于存在前导0的话，我们不能记录dp值。

d p [ l e n ] [ i s e v e n ] [ s t ] dp[len][iseven][st] dp[len][iseven][st]表示了唯一性， l e n len len表示还剩下的位数， i s e v e n iseven iseven表示现在遍历的奇数位还是偶数位， s t st st表示前面所有位的组成数取余 m m m得到的结果。首先前导0肯定不会得到DP值，所以能得到DP的都是非前导0。然后我们不满足条件的 c o n t i u e contiue contiue掉了，所以要DP的值的话，前面肯定是满足条件的。所以，在前面满足条件的情况下，通过看这个数是不是偶数位以及前面数的取模和可以唯一确定DP状态。

l e n = 0 len=0 len=0时，如果 s t = 0 st=0 st=0返回1，否则返回0。


#include<iostream>
#include<vector>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iomanip>
#include<stdio.h>
#include<map>
#include<queue>
using namespace std;
#define Check(x) cout<<"x:"<<x<<" "
#define Min(x,y,z) min(x,min(z,y))
#define Max(x,y,z) max(x,max(z,y))
typedef long long ll;
const int MAXN = 2e5 + 5;
const int MAXM = 1e6 + 5;
int m, d;
ll dp[2005][2][2000];
ll digit[2005];
ll mod = 1e9+7;
ll dfs(int len,int iseven,int topzero,int st,bool limit) {
    if (len == 0) {
        if (st == 0)return 1;
        else return 0;
    }
    if (!limit && !topzero&&~dp[len][iseven][st])return dp[len][iseven][st];
    int maxx = limit ? digit[len] : 9;
    ll ans = 0;
    for (int i = 0;i <= maxx;i++) {
        if (topzero && i == 0)ans += dfs(len - 1, 0, 1, 0, i == maxx && limit);
        else if (topzero && i != 0) {
            if (i == d)continue;
            else {
                ans += dfs(len - 1, 1, 0, i % m, i == maxx && limit);
            }
        }
        else if (!topzero) {
            if ((iseven && i != d) || (!iseven && i == d)) {
                continue;
            }
            ans += dfs(len - 1, iseven ^ 1, 0, (st * 10 + i) % m, i == maxx && limit);
            
        }
        ans %= mod;
    }
    if (!limit&&!topzero)dp[len][iseven][st] = ans;
    return ans;
}
ll solve(string num) {
    int k = 0;
    for (int i = num.length()-1;i >= 0;i--) {
        digit[++k] = num[i]-'0';
    }
    return dfs(k,0,1,0,1);
}
int main() {
    memset(dp, -1, sizeof dp);
    cin >> m >> d;
    string a, b;
    cin >> a >> b;
    ll ans = (solve(b)-solve(a)+mod)%mod;
    int st = 0;
    bool f = true;
    for (int i = 0;i < a.length();i++) {
        int now = a[i] - '0';
        if (((i + 1) % 2 == 0 && now != d) || ((i + 1) % 2 == 1 && now == d)) { f = false;break; }
        st = (st * 10 + now) % m;
    }
    if (st != 0)f = false;
    if (f)ans++;
    ans %= mod;
    cout << ans << endl;
}
抱抱仓鼠叭
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数位DP入门
08-22
数位DP入门思想，包括详细的思考过程以及一些习题的讲解
数位dp思路总结及洛谷例题讲解
m0_51531927的博客
02-14 497
文章目录数位dp例题讲解例题1 数位dp 一般问题描述： 求区间lll到rrr之间符合限制条件的数字个数。lll和rrr都是达到 long long 级别的数，无法直接枚举求答案；要求数字的限制条件一般是针对数字的数位的（数位指一个数中每一个数字所占的位置，这些位置，都叫做数位。从右端算起，第一位是“个位”，第二位是“十位”…），所以解决这种问题，不会一个数字一个数字看，而是枚举数位后捕获一大把合法的数字。 一般问题求解思路： dfs+dpdfs+dpdfs+dp，也就是记忆化搜索。这可以理解成一颗树，
深度干货 | 万字长文详解数位dp，超详细题集汇总
qq_45832461的博客
03-11 413
史上最通俗易懂，最简单，最全面的数位dp习题集，帮你扫清各种数位dp难题，背诵一套模板秒杀各种数位dp！！！
数位DP(包含例题和模板)
m0_51678367的博客
11-23 567
如上题所示意: f®-f(l-1)就是答案. 那么f(n)要怎么求呢? 先把n分解为m进制的l位.那么对于第i位来说,就只有0或者1,因为题目里面没有系数.如181818=242^424+212^121.而没有282828=242^424+3∗223*2^23∗22. 从最高位到最低位,那么对于第i位来说如果第i位>1那么第i位可以是0(组合数学,第i位下面的i-1位可以填k-last(已经填了的1的个数)个1,即C[i-1][k-last] (下标从1开始,若是从零开始就是C[i][k-last..
数位dp笔记(详解+例题+解析)
qq_49494204的博客
11-12 1686
数位dp笔记 简单介绍 数位：把一个数字按照个、十、百、千等等一位一位地拆开，关注它每一位上的数字。如果拆的是十进制数，那么每一位数字都是 0~9，其他进制可类比十进制。 数位 DP：用来解决一类特定问题，这种问题比较好辨认，一般具有这几个特征： ​ 1.要求统计满足一定条件的数的数量（即，最终目的为计数）； ​ 2.这些条件经过转化后可以使用「数位」的思想去理解和判断； ​ 3.输入会提供一个数字区间（有时也只提供上界）来作为统计的限制； ​ 4.上界很大（比如 1018），暴力枚举验证会超时。 考虑人类
数位DP入门题
weixin_30478757的博客
03-20 75
站点一览： hdu 2089"不要62" hdu 4734"F(X)" poj 3252"Round Numbers" hdu 3709"Balanced Number" 1.hdu 2089"不要62" 题解： 　　题目过于简单，不再赘述。 AC代码： 1 #include<iostream> 2 #include<cst...
数位dp算法详细图文解答
02-13
PPT图片结合文字讲述数位dp
数位DP.pdf
07-12
数位DP整理的模板和一些题目的题解。QAQ没钱下载资源了只好上传点东西。
初探数位dp.pdf
09-16
lazycal的集训队报告：初探数位DP 以HDU 2089，HDU 3652, URAL 1057等题目为例，介绍了数位DP的算法
数位dp——某次队内分享任务
07-21
好不容易做的，放在电脑中不小心删了咋整
动态规划（7）数位dp
weixin_64197656的博客
09-23 206
简单数位dp
Leetcode第306场周赛（附数位DP总结）
qq_44805233的博客
08-18 401
LeetCode第306周赛，附数位DP学习总结
数位DP问题
Boring_Firecar的博客
09-11 300
数位DP问题 数位DP问题一般都是问在 小于等于 n 的数里面, 有多少个数是满足条件的, 当然问题也可以转换为问一个区间里面[a, b] 是满足某种条件的, 当然对于这种区间的问题, 我们可以将其转化为前缀和问题, 例如转化为求 0 ~ b里满足的个数 - 0 ~ a - 1 里面满足条件的个数, 一般做法分两步: (1) 预处理 (一般情况) (2) 按位进行处理 例题 题目链接: 600. 不含连续1的非负整数 题目描述: 给定一个正整数 n，找出小于或等于 n 的非负整数中，其二进制表示不包含 连续
数位Dp习题集
scanner
10-03 167
数位Dp习题集
数位DP训练 例题
qq_43710979的博客
05-11 212
前几天被数位DP搞崩了，开始重新学(......) ① HDU 3555 Bomb [http://acm.hdu.edu.cn/showproblem.php?pid=3555] Description：计算1~n之间的数中含有‘49’的数的个数 一种解法：记录之前‘49’是否出现和前一位数的状态，板子题 #include<cstdio> #include<cstring&gt...
数位dp总结 之 从入门到模板
热门推荐
努力
08-03 7万+
for(int i=le;i<=ri;i++) if(right(i)) ans++; 基础篇 数位dp是一种计数用的dp，一般就是要统计一个区间[le,ri]内满足一些条件数的个数。所谓数位dp，字面意思就是在数位上进行dp咯。数位还算是比较好听的名字，数位的含义：一个数有个位、十位、百位、千位......数的每一位就是数位啦！ 之所以要引入数位的概念完全就是为了dp。
数位dp入门
05-18 230
数位dp，一般的题意是要求把某个区间的符合某种特征的数的个数求出来，一般的思路就是把最大数按位分解，然后dfs依次判断每一位相应的数是否满足要求。 把以前做过的几道简单数位dp的题总结一下，可以作为入门题做做。 1. hdu 2089 不要62 题意：给定一个区间[a,b]，问在这个区间中的数字，不包含4和62的数有多少个？ 分析：数据范围小于1e6，如果暴...
数位DP问题整理（一）
08-13 2万+
第一题：Amount of degrees (ural 1057) 题目链接：http://acm.timus.ru/problem.aspx?space=1&num=1057 题意：[x,y]范围内的数，可以拆分成k个b进制的不同幂的和 的数字有多少。 我们可以将x转换成二进制来讨论。那么问题就变成了求[0,x]范围内，二进制表示中含有k个1的数字有多少个。 求[x,y]区间相减。我们可
数位DP入门+数位DP模板
receiling的博客
08-20 9805
数位dp是一种计数用的dp，一般就是要统计一个区间[le,ri]内满足一些条件数的个数。所谓数位dp，字面意思就是在数位上进行dp咯。数位还算是比较好听的名字，数位的含义：一个数有个位、十位、百位、千位......数的每一位就是数位啦！ 之所以要引入数位的概念完全就是为了dp。数位dp的实质就是换一种暴力枚举的方式，使得新的枚举方式满足dp的性质，然后记忆化就可以了。 两种不同的枚举：对...
力扣中数位dp经典题目
最新发布
07-12
在LeetCode上，数位动态规划（Digit Dynamic Programming）是一类经典的问题，其中涉及数字的处理和计算。以下是一些常见的数位DP问题： 1. 整数拆分（Integer Break）：给定一个正整数n，将其拆分为至少两个正整数的和，使得这些整数的乘积最大化。求最大乘积。 2. 数字1的个数（Number of Digit One）：给定一个非负整数n，计算从1到n之间所有整数中数字1出现的次数。 3. 超级丑数（Super Ugly Number）：给定一个正整数n和一个长度为m的质数数组，求第n个超级丑数。超级丑数是指其所有质因数都在给定的质数数组中。 4. 数字转换为16进制数（Convert a Number to Hexadecimal）：给定一个整数，将其转换为对应的16进制数表示。 5. 找出缺失的数字（Missing Number）：给定一个包含0到n之间所有整数的数组nums，其中有一个数字缺失。求出缺失的数字。 这只是一小部分LeetCode上的数位DP问题，还有许多其他有趣的问题等待你去探索。你可以在LeetCode上搜索这些问题的详细描述和解答。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值