【动态规划の数位 DP】数位 DP 的经典运用

题目描述

这是 LeetCode 上的「1012. 至少有 1 位重复的数字」，难度为「困难」。

Tag : 「动态规划」、「数位 DP」、「容斥原理」

给定正整数 n ，返回在 [1, n] 范围内具有 至少 1 位 重复数字的正整数的个数。

示例 1：

输入：n = 20

输出：1

解释：具有至少 1 位重复数字的正数（<= 20）只有 11 。

示例 2：

输入：n = 100

输出：10

解释：具有至少 1 位重复数字的正数（<= 100）有 11，22，33，44，55，66，77，88，99 和 100 。

示例 3：

输入：n = 1000

输出：262

提示：

• 1 <= n <= 10^9

数位 DP

首先 [1, n] 共有 n 个数，而求解[1, n] 范围内有多少个「至少有 1 位重复数字」的数的个数，等价于「总数 n 」减去「没有重复数的数的个数」。

于是问题转换为：如何求解「没有重复数」的数的个数，同时为了更具一般性，我们将求解 [1, n] 范围内「没有重复数」的数的个数，修改为求解 [0, n] 范围内「没有重复数」的数的个数。

❝即将问题转换为 (题解) 357. 统计各位数字都不同的数字个数 中的进阶部分。 ❞

假定我们存在函数 int dp(int x) 函数，能够返回区间 [0, x] 内合法数的个数，那么配合「容斥原理」我们便能够回答任意区间合法数的查询：ans_{(l, r)} = dp(r) - dp(l - 1) 然后考虑如何实现 int dp(int x) 函数，我们将组成 [0, x] 的合法数分成三类：

• 位数和 x 相同，且最高位比 x 最高位要小的，这部分统计为 res1；
• 位数和 x 相同，且最高位与 x 最高位相同的，这部分统计为 res2；
• 位数比 x 少，这部分统计为 res3。

其中 res1 和 res3 求解相对简单，重点落在如何求解 res2 上。

对 x 进行「从高到低」的处理（假定 x 数位为 n ），对于第 k 位而言（k 不为最高位），假设在 x 中第 k 位为 cur ，那么为了满足「大小限制」关系，我们只能在 [0, cur - 1] 范围内取数，同时为了满足「相同数字只能使用一次」的限制，我们需要使用一个 int 变量 s 来记录使用情况（用 s 的低十位来代指数字 [0, 9] 是否被使用），统计 [0, cur - 1] 范围内同时符合两个限制条件的数的个数，记为 cnt 。

当第 k 位有 cnt 种合法选择之后，后面的位数可以在满足「相同数字只能使用一次」的限制条件下任意选择（因为大小关系已经由第 k 位保证），为了快速知道剩下的 n - k 位有多少种方案，我们还需要预处理乘积数组，其中 f[l][r] 代表 l * (l + 1) * ... * (j - 1) * j 的乘积之和。

❝上述讲解若是觉得抽象，我们可以举个 🌰，假设x = 678 ，我们该如何求解 res2：由于限定了 res2 为「位数和 x 相同，且最高位与 x 最高位相同的」的合法数个数，因此最高位没有选，只能是 6 ，然后考虑处理次高位，次高位在 x 中为 7 ，为了满足大小关系，我们只能在 [0, 6] 范围内做限制，同时由于 6 已用过，因此次高位实际只有 [0, 5] ，共 6 种选择，当确定次高位后，后面的位数任意取，由于前面已经填充了 p = 2 位（即消耗了 p 个不同数字），因此从后面的位数开始应该是 a = 10 - p 开始往后自减累乘到 b = (10 - p) - (n - p) + 1 为止，即此时方案数为 cnt * f[b][a] （当前位不是最低位）或者 cnt （当前位是最低位）。按照此逻辑循环处理所有位数即可，直到遇到重复数值或正常结束。 ❞

需要说明的是，上述的举例部分只是为方便大家理解过程，看懂了举例部分不代表理解了数位 DP 做法成立的内在条件，阅读的重点还是要放在前面加粗字体部分，只会使用样例理解算法永远不是科学的做法。

其他细节：乘积数组的预处理与样例无关，我们可以使用 static 进行打表优化，同时可以将 res1 和 res2 两种情况进行合并。

代码：

class Solution {
    // f[l][r] 代表 i * (i + 1) * ... * (j - 1) * j
    static int[][] f = new int[10][10];
    static {
        for (int i = 1; i < 10; i++) {
            for (int j = i; j < 10; j++) {
                int cur = 1;
                for (int k = i; k <= j; k++) cur *= k;
                f[i][j] = cur;
            }
        }
    }
    int dp(int x) {
        int t = x;
        List<Integer> nums = new ArrayList<>();
        while (t != 0) {
            nums.add(t % 10);
            t /= 10;
        }
        int n = nums.size();
        if (n <= 1) return x + 1; // [0, 9]
        // 位数和 x 相同（res1 + res2）
        int ans = 0;
        for (int i = n - 1, p = 1, s = 0; i >= 0; i--, p++) {
            int cur = nums.get(i), cnt = 0;
            for (int j = cur - 1; j >= 0; j--) {
                if (i == n - 1 && j == 0) continue;
                if (((s >> j) & 1) == 0) cnt++;
            }
            int a = 10 - p, b = a - (n - p) + 1;
            ans += b <= a ? cnt * f[b][a] : cnt;
            if (((s >> cur) & 1) == 1) break;
            s |= (1 << cur);
            if (i == 0) ans++;
        }
        // 位数比 x 少（res3）
        ans += 10;
        for (int i = 2, last = 9; i < n; i++) {
            int cur = last * (10 - i + 1);
            ans += cur; last = cur;
        }
        return ans;
    }
    public int numDupDigitsAtMostN(int n) {
        return (n + 1) - dp(n);
    }
}

• 时间复杂度：O(\log{n})
• 空间复杂度：O(C)

总结

相同的总结在 第一篇数位 DP 系列文章 中也讲过了，考虑到有新同学是第一次看到这个系列，再提一次：

数位 DP 的难度取决于「限制条件」的多少，而 LC 上仅有的几道数位 DP 题目限制条件都很少，且不需要引入额外的数据结构来记录状态，因此都属于数位 DP 的入门难度（LC 难度均为 Hard）。

几乎所有的数位 DP 问题都可以归纳到上述的解法 :「将问题抽象为求解一个 [0, x]/[1, x] 范围方案数的方法」->「对方案数统计根据 位数 来分情况讨论：数位相等的情况 + 数位不等情况」->「统计数位相等的方案数时，需要按位处理，并根据限制条件做逻辑；统计数位不等的方案数时，通常要做一些预处理，然后配合乘法原理直接算得」。

在还没卷到数位 DP 烂大街的现在，掌握此类求解方式单一，普遍定位为「困难」的数位 DP 类型，还是极具性价比的。

在「动态规划の数位 DP」这个系列，我会带大家把 LC 上所有「数位 DP」类型的题目都做一遍。

最后

这是我们「刷穿 LeetCode」系列文章的第 No.1012 篇，系列开始于 2021/01/01，截止于起始日 LeetCode 上共有 1916 道题目，部分是有锁题，我们将先把所有不带锁的题目刷完。

在这个系列文章里面，除了讲解解题思路以外，还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。

为了方便各位同学能够电脑上进行调试和提交代码，我建立了相关的仓库：https://github.com/SharingSource/LogicStack-LeetCode 。

在仓库地址里，你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。