Number of Beautiful Integers in the Range

Number of Beautiful Integers in the Range

You are given positive integers low, high, and k.

A number is beautiful if it meets both of the following conditions:

• The count of even digits in the number is equal to the count of odd digits.
• The number is divisible by k.

Return the number of beautiful integers in the range [low, high].

Example 1:

Input: low = 10, high = 20, k = 3
Output: 2
Explanation: There are 2 beautiful integers in the given range: [12,18]. 
- 12 is beautiful because it contains 1 odd digit and 1 even digit, and is divisible by k = 3.
- 18 is beautiful because it contains 1 odd digit and 1 even digit, and is divisible by k = 3.
Additionally we can see that:
- 16 is not beautiful because it is not divisible by k = 3.
- 15 is not beautiful because it does not contain equal counts even and odd digits.
It can be shown that there are only 2 beautiful integers in the given range.

Example 2:

Input: low = 1, high = 10, k = 1
Output: 1
Explanation: There is 1 beautiful integer in the given range: [10].
- 10 is beautiful because it contains 1 odd digit and 1 even digit, and is divisible by k = 1.
It can be shown that there is only 1 beautiful integer in the given range.

Example 3:

Input: low = 5, high = 5, k = 2
Output: 0
Explanation: There are 0 beautiful integers in the given range.
- 5 is not beautiful because it is not divisible by k = 2 and it does not contain equal even and odd digits.

Constraints:

• 0 < low <= high <= 10⁹
• 0 < k <= 20

 

解题思路

　　一碰到数位dp就谔谔，昨晚硬是磨了一个多小时都没做出来，然后今天调了一早上才过了，被傻逼lc的评测机制气乐了。

　　数位dp我一直都用递推去做的，记忆化搜索一直没学会。当时想状态定义的时候就想了很久，现在的总结就是其实只用关注从最高位往低位递推时会用到哪些特定的数，然后把需要的状态定义出来就好了，比如说最基本的数位的个数，最高位是哪一个数，然后是其他特性比如这题中奇偶数位分别有多少，整个数模$k$是多少。

　　定义状态$f(i,j,u,v,w)$表示所有数位大小为$i$，最高位是$j$，奇数数位有$u$个，偶数数位有$v$个，整个数模$k$为$w$的数的个数。很明显数位大小为$i$的数可以转移到数位大小为$i+1$的数，因此当前状态$f(i,j,u,v,w)$可以转移到的状态就有 $$\left\{ \begin{array}{c} f \left(i+1, \ x, \ u+1, \ v, \ (x \cdot {10}^i + w) \bmod k \right) \quad x \in \{ 1,3,5,7,9 \}  \\ f \left(i+1, \ x, \ u, \ v+1, \ (x \cdot {10}^i + w) \bmod k \right) \quad x \in \{ 0,2,4,6,8 \} \end{array} \right.$$

　　然后递推的时候求的是$1 \sim x$中有多少个数满足条件，先把$x$中的每一个数分离出来，然后从最高位开始往底位枚举。只有$x$的数位大小为偶数时才能递推，因为要求奇偶数位相同，并且在递推时要保证没有前导$0$（前导$0$会印象奇偶数位的数目），最后再把那些含前导$0$的数补上即可。递推时需要开变量分别记录前面已确认的数的奇数数位和偶数数位有多少，以及组成的数在十进制中模$k$是多少。

　　最后因为lc的逆天评测机制，如果对于每个样例都跑dp预处理那么肯定会TLE，因此需要把预处理的结果记录到全局变量中，这样只用跑一次即可，不过需要把$1 \leq k \leq 20$所有情况都跑一遍，预处理的计算量大概是$20 \times 10 \times 10 \times 6 \times 6 \times 20 \times 10 \approx {10}^7$。

　　AC代码如下：

vector<vector<vector<vector<vector<vector<int>>>>>> f;

class Solution {
public:
    void init() {
        f = vector<vector<vector<vector<vector<vector<int>>>>>>(21, vector<vector<vector<vector<vector<int>>>>>(11, vector<vector<vector<vector<int>>>>(10, vector<vector<vector<int>>>(6, vector<vector<int>>(6, vector<int>(20))))));
        for (int k = 1; k <= 20; k++) {
            vector<int> p(10);
            p[0] = 1 % k;
            for (int i = 1; i < 10; i++) {
                p[i] = p[i - 1] * 10 % k;
            }
            for (int i = 0; i <= 9; i++) {
                if (i & 1) f[k][1][i][1][0][i % k] = 1;
                else f[k][1][i][0][1][i % k] = 1;
            }
            for (int i = 1; i < 10; i++) {
                for (int j = 0; j <= 9; j++) {
                    for (int u = 0; u <= 5; u++) {
                        for (int v = 0; v <= 5; v++) {
                            for (int w = 0; w < k; w++) {
                                for (int x = 0; x <= 9; x++) {
                                    if (x % 2 && u + 1 <= 5) f[k][i + 1][x][u + 1][v][(x * p[i] + w) % k] += f[k][i][j][u][v][w];
                                    else if (x % 2 == 0 && v + 1 <= 5) f[k][i + 1][x][u][v + 1][(x * p[i] + w) % k] += f[k][i][j][u][v][w];
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    
    int numberOfBeautifulIntegers(int low, int high, int k) {
        if (f.empty()) init();
        vector<int> p(10);
        p[0] = 1 % k;
        for (int i = 1; i < 10; i++) {
            p[i] = p[i - 1] * 10 % k;
        }
        function<int(int)> get = [&](int x) {
            if (!x) return 0;
            vector<int> q;
            while (x) {
                q.push_back(x % 10);
                x /= 10;
            }
            int ret = 0, odd = 0, even = 0, s = 0;
            if (~q.size() & 1) {
                int t = q.size() >> 1;
                for (int i = q.size() - 1; i >= 0; i--) {
                    for (int j = i == q.size() - 1; j < q[i]; j++) {
                        ret += f[k][i + 1][j][t - odd][t - even][(k - s) % k];
                    }
                    if (q[i] & 1) odd++;
                    else even++;
                    if (odd > t || even > t) break;
                    s = (s + q[i] * p[i]) % k;
                    if (!i && odd == even && !s) ret++;
                }
            }
            for (int i = 1; i < q.size(); i++) {
                if (~i & 1) {
                    for (int j = 1; j <= 9; j++) {
                        ret += f[k][i][j][i >> 1][i >> 1][0];
                    }
                }
            }
            return ret;
        };
        return get(high) - get(low - 1);
    }
};

　　这题还可以用暴搜，可以发现只有数位大小为偶数的数才能满足奇数数位和偶数数位的数目相同，因此可以暴搜出来这些数，实际上大概有$2 \times {10}^7$个左右。然后在暴搜的时候要保证搜到的数有序，对于$\text{low}$和$\text{high}$二分出可选数的区间，然后再逐个枚举是否模$k$为$0$即可。详细见参考资料，这里就不写了，比赛很少会这样做，一般都直接数位dp。

　　2023-08-27更新：

　　受F - Nim这题的启发，题解中用到了我没接触过的新的dp状态表示，这里把这种新的状态定义用到这题。之后再把atc这题的题解补上。

　　对$N$进行数位dp，在$1 \sim N$中求出所有满足条件的数的数量。定义状态$f(i,j,u,v,w,x)$表示满足以下条件的整数$n$（十进制）的数量：

• $n$的数位大小为$i$，或者说$0 \leq n < 10^i$。
• 若$n \leq N \bmod 10^i$，则$j=1$；否则$j=0$。其中$N \bmod 10^i$表示$N$在十进制下的最低有效$i$位数字构成的值，例如$123456789$的最低有效$6$位数字构成的值就是$456789$。
• $n$的$i$个数位中有$u$个数位是奇数，$v$个数位是偶数。
• $n \bmod k = w$。
• 若$n$的最高数位上的数是$0$，则$x=0$；否则$x=1$。

　　这里解释一下为什么要加一个表示最高位上的数是否为$0$的状态。这是因为在统计时数不能有前导$0$，因此加上这个状态以示区别。　　

　　对于当前确定的状态$f(i,j,u,v,w,x)$，我们可以转移到数位是$i+1$的状态，只需枚举数位是$i+1$的数的最高位是哪个数字即可（记作$y$），状态转移方程就是 $$\left\{ \begin{array}{c} f(i,j,u,v,w,x) \longrightarrow f\left(i+1, \ y < p_i \ \operatorname{or} \ y = p_i \ \operatorname{and} \ j, \ u+1, \ v, \ (y \cdot 10^i + w) \bmod w, \ \neg \neg y \right) \quad y \in \{ 0,2,4,6,8 \} \\ f(i,j,u,v,w,x) \longrightarrow f\left(i+1, \ y < p_i \ \operatorname{or} \ y = p_i \ \operatorname{and} \ j, \ u, \ v+1, \ (y \cdot 10^i + w) \bmod w, \ \neg \neg y \right) \quad y \in \{ 1,3,5,7,9 \} \end{array} \right.$$

　　其中$p_i$表示的是$N$在十进制下从低位开始的第$i$位上的数字。$\neg \neg y$表示的是，如果$y=0$，则结果为$0$；如果$y>0$，则结果为$1$。

　　AC代码如下，时间复杂度为$O(k \cdot \log^{3}{N})$：

class Solution {
public:
    int numberOfBeautifulIntegers(int low, int high, int k) {
        function<int(int)> get = [&](int x) {
            if (!x) return 0;
            vector<int> p;
            while (x) {
                p.push_back(x % 10);
                x /= 10;
            }
            int sz = p.size();
            vector<vector<vector<vector<vector<vector<long long>>>>>> f(sz + 1, vector<vector<vector<vector<vector<long long>>>>>(2, vector<vector<vector<vector<long long>>>>(sz / 2 + 2, vector<vector<vector<long long>>>(sz / 2 + 2, vector<vector<long long>>(k, vector<long long>(2))))));
            for (int i = 0; i <= 9; i++) {
                if (i & 1) f[1][i <= p[0]][1][0][i % k][!!i]++;
                else f[1][i <= p[0]][0][1][i % k][!!i]++;
            }
            vector<int> p10(sz);
            p10[0] = 1;
            for (int i = 1; i < sz; i++) {
                p10[i] = (p10[i - 1] * 10) % k;
            }
            for (int i = 1; i < sz; i++) {
                for (int j = 0; j <= 1; j++) {
                    for (int u = 0; u <= sz >> 1; u++) {
                        for (int v = 0; v <= sz >> 1; v++) {
                            for (int w = 0; w < k; w++) {
                                for (int x = 0; x <= 1; x++) {
                                    for (int y = 0; y <= 9; y++) {
                                        if (y & 1) f[i + 1][y < p[i] || y == p[i] && j][u + 1][v][(y * p10[i] + w) % k][!!y] += f[i][j][u][v][w][x];
                                        else f[i + 1][y < p[i] || y == p[i] && j][u][v + 1][(y * p10[i] + w) % k][!!y] += f[i][j][u][v][w][x];
                                    }
                                }
                            }
                        }
                    }
                }
            }
            int ret = 0;
            for (int i = 2; i <= sz; i += 2) {  // 只考虑位数个数是偶数的数
                ret += f[i][1][i >> 1][i >> 1][0][1];   // 在位数为i的数中，值不超过N的最低i位，且最高位不为0的数的个数
                if (i < sz) ret += f[i][0][i >> 1][i >> 1][0][1];   // 由于数位长度不到sz，故高位用0补充，低位的部分可以超过N的最低i位，而总体（高位补0后长度为sz的数）不超过N，故这部分的数需要加上
            }
            return ret;
        };
        return get(high) - get(low - 1);
    }
};

 

参考资料

　　久违的力扣周赛讲解来啦~第111场双周赛：https://www.bilibili.com/video/BV1P44y1F7EG/

　　F - Nim Editorial：https://atcoder.jp/contests/abc317/editorial/7047