数位DP（a，b跨度大）

最新推荐文章于 2024-11-11 20:03:56 发布

root_love_zc

最新推荐文章于 2024-11-11 20:03:56 发布

阅读量239

点赞数 2

文章标签：算法

本文链接：https://blog.csdn.net/2301_79067011/article/details/137499570

版权

文章介绍了如何使用递推模板和递归方法解决数位统计问题，包括预处理10的幂和计算不同位数中数字的分布，以及在两个数位统计问题中的应用实例。两种方法在减少枚举量上具有优势。

摘要由CSDN通过智能技术生成

代码（先看题，在看代码）

数位统计(递推模板--比较好理解）

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 15;

ll ten[N], dp[N];
ll cnta[N], cntb[N];
int num[N];

/*
1位数：每种数字有1个
2位数：每种数字有20个
3位数：每种数字有300个
4位数：每种数字有4000个
*/
void init() {  // 预处理10的n次方
    ten[0] = 1;
    for (int i = 1; i <= N; i++) {
        ten[i] = 10 * ten[i - 1];
        dp[i] = dp[i - 1] * 10 + ten[i - 1];
    }
}
void solve(ll x, ll *cnt) {
    // 分离数位
    int len = 0;
    while (x) {
        num[++len] = x % 10;
        x /= 10;
    } 
    // 遍历处理每个数位
    for (int i = len; i >= 1; i--) {
        // 4321 的 1000 * 4 带来的贡献
        for (int j = 0; j <= 9; j++) { // 处理每个数字的个数
            cnt[j] += dp[i - 1] * num[i]; // 每个数字的个数等于前面的贡献 乘 当前这个数位 比如： 1000 * 5
        }                                 // 1000 就是前面的贡献（1000里面有多少个这个数字） * 我有几个1000
        // 4321 的 4XXX 3XXX 2XXX 带来的贡献
        for (int j = 0; j < num[i]; j++) {
            cnt[j] += ten[i - 1];
        }
        // 4321 的 321 带来的贡献 322 个 4
        ll num2 = 0;
        for (int j = i - 1; j >= 1; j--) {
            num2 = num2 * 10  + num[j];
        }
        cnt[num[i]] += num2 + 1;
        // 减去 0XXX 中多的贡献
        cnt[0] -= ten[i - 1];
    }
}

int main() {
    init();
    ll a, b; cin >> a >> b;
    solve(a - 1, cnta), solve(b, cntb);
    for (int i = 0; i <= 9; i++) {
        cout << cntb[i] - cnta[i] << ' ';
    }
}

数位统计（递归模板，比较不好理解，但是很常用）

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 15;

ll dp[N][N];
int num[N], now; // now：当前统计0~9中的哪一个数字，相比于递推模板，它属于要算哪个调用哪个
                 // 而递推模板是一次性全部算出来的

// 递归模板的参数和递推模板的维度很像的，多多感悟。
// 而且递归都是先找到叶子节点，然后再迭代回来根节点进行操作的
ll dfs(int pos, int sum, bool lead, bool limit) {
    ll ans = 0;

    if (pos == 0) return sum; // 遍历到空节点，然后返回一路走来的now的个数

    // 不是领头的 没有被限制 统计过了
    if (!lead && !limit && dp[pos][sum] != -1) return dp[pos][sum];  // 记忆化搜索

    // 开始从小找到最高位，目的是得到他们的下一个数位的,下面以now = 2为例
    int up = (limit ? num[pos] : 9); 
    for (int i = 0; i <= up; i++) {
        // 计算 000 ——— 099 (这个数是0，并且领头，也就是说，后面00 - 99 的都可以加上来)
        if (i == 0 && lead) {
            ans += dfs(pos - 1, sum, true, limit && i == up); // 如果i是up的话，就说明后面的不能
        }
        // 计算200 —— 299 
        else if (i == now) {
            ans += dfs(pos - 1, sum + 1, false, limit && i == up);
        }
        // 计算 100 —— 199
        else if (i != now) {
            ans += dfs(pos - 1, sum, false, limit && i == up);
        }
    }
    // 状态记录:不是领头，没有限制
    if (!lead && !limit) dp[pos][sum] = ans;
    return ans;                     // dp[pos][sum]表示当前数位为pos，然后前面为now的数位有sum个的情况
}
/*
由于比较难理解，可以画一颗树，然后慢慢推导
1、dp是什么含义
    dp的pos表示深度，sum表示前面的贡献
2、状态转移方程
    dp[pos][sum] = dp[pos - 1][sum]的和 如果某一个pos的值==now，那么它的孩子的sum + 1，
*/

ll solve(ll x) {
    // 分离数位
    int len = 0;
    while (x) {
        num[++len] = x % 10;
        x /= 10; 
    } 
    // 初始化啊，因为一次只能统计一个
    memset(dp, -1, sizeof dp);
    // 开始
    return dfs(len, 0, true, true);
}

int main() {
    ll a; cin >> a;
    now = 2;
    cout << solve(a);
    // ll a, b; cin >> a >> b;
    // for (int i = 0; i < 10; i++) {
    //     now = i;
    //     cout << solve(b) - solve(a - 1) << ' ';
    // }
    return 0;
}

（另一份）

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 15;

ll dp[N][N][2][2];
int num[N], now; 
// 递归模板的参数和递推模板的维度很像的，多多感悟。
// 而且递归都是先找到叶子节点，然后再迭代回来根节点进行操作的

// sum的作用是贡献，pos的作用是定位，lead的作用是 023 和 1023 的情况  limit 是 324 和 224 的情况（最高时324，所以在百位为3时十位最高取2，224就没有限制）
ll dfs(int pos, int sum, bool lead, bool limit) {
    
    ll ans = 0;
    // 返回贡献
    if (pos == 0) return sum; 

    // 查询过这个，返回
    if (dp[pos][sum][limit][lead] != -1) return dp[pos][sum][limit][lead];  

    // 遍历所有的分支
    int up = (limit ? num[pos] : 9); 
    for (int i = 0; i <= up; i++) {
        
        if (i == 0 && lead) {
            ans += dfs(pos - 1, sum, true, limit && i == up); 
        }
       
        else if (i == now) {
            ans += dfs(pos - 1, sum + 1, false, limit && i == up);
        }
       
        else if (i != now) {
            ans += dfs(pos - 1, sum, false, limit && i == up);
        }
    }
    // 记忆化
    dp[pos][sum][limit][lead] = ans;    
    return ans;                     
}

// 得到数量
ll solve(ll x) {
    // 分离数位
    int len = 0;
    while (x) {
        num[++len] = x % 10;
        x /= 10; 
    } 
    // 初始化啊，因为一次只能统计一个
    memset(dp, -1, sizeof dp);
    // 开始
    return dfs(len, 0, true, true);
}

int main() {;
    // 输入数据
    ll a, b; cin >> a >> b;
    // 遍历搜索
    for (int i = 0; i < 10; i++) {
        now = i;
        cout << solve(b) - solve(a - 1) << ' ';
    }
    return 0;
}