Codeforces Round #714 (Div. 2) C题

题目链接

Codeforces Round #714 (Div. 2) Problem C

分析

首先，可以想到一种能够保证正确性的方法：按照题意模拟。这种方法下，每个案例复杂度为$O(m)$即$10^5$数量级；但由于还有最多$2\times 10^5$个测试案例，总复杂度为$O(tm)$即$10^{10}$数量级，而且其中每步操作也较为复杂，需要维护每个数字（$0\sim 9$）的计数，所以应该会超时 ，实验证明确实如此。

发现任何一个数字在常数步操作（1~10步）后必定会转换为字符串"10"，于是就想到第二种方案：把"10"作为输入丢进模拟算法，记下它在第$i$步时字符串长度$l_i$，之后对于真实输入的每个字符$ch$，就只要考虑将$m$减去它本身变成"10"的步数$s$，然后去查$l_{m-s}$，就可以得出该字符最终变成的字符串长度；又因为各个字符之间变换可以看作是独立的，所以最终把所有长度加起来即可。（当然实际实现时此处还需考虑一些如$m-s<0$之类的边界情况。）

以下代码就是基于第二段的思路所写的（细节其实还有些差异，没有做到最优），已经能够通过本题：

#include <iostream>
#include <vector>
#include <array>

using namespace std;

using bucs = array<long long, 10>;

bucs st[200005];

constexpr int MOD = 1e9 + 7;

void solve() {
    const int m = 200000;
    const string n = "10";
    // cin >> n >> m;
    bucs b { 0 };
    for (auto ch : n) {
        b[ch - '0']++;
    }
    for (int i = 0; i < m; i++) {
        auto mem_9 = b[9];
        for (int j = 9; j >= 1; j--) {
            b[j] = b[j - 1];
        }
        b[0] = mem_9;
        b[1] += mem_9;
        for (auto& x : b) {
            x %= MOD;
        }
        st[i] = b;
    }
}

void real_solve() {
    string n;
    int m;
    cin >> n >> m;
    bucs b { 0 };
    long long ans = 0;
    for (auto ch : n) {
        b[ch - '0']++;
    }

    for (int i = 0; i < 10; i++) {
        auto num = b[i];
        long long std_ans = 0;
        if (m - 1 - (10 - i) == -1) {
            std_ans = 2;
        } else if (m - 1 - (10 - i) < -1) {
            std_ans = 1;
        } else {
            auto &rec = st[m - 1 - (10 - i)];
            for (int j = 0; j < 10; j++) {
                std_ans += rec[j];
                std_ans %= MOD;
            }
        }
        ans += std_ans * num;
        ans %= MOD;
    }
    cout << ans << '\n';
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    solve();
    int t;
    cin >> t;
    for (int i = 0; i < t; i++) {
        real_solve();
    }
    return 0;
}

但是，官方题解中给出了以下更加简洁的递推式：设$d{p}_i$为字符串"10"进行$i$次操作后形成的字符串长度，则有：
$$\{\begin{array}{ll}d{p}_i=2,& 0\le i\le 8,\\ d{p}_i=3,& i=9,\\ d{p}_i=d{p}_{i-10}+d{p}_{i-9},& i>9.\end{array}$$
有了这组递推式，就可以用简单的一维动态规划得出结果。其中第一条和第二条可以通过实验直接得出，但第三条的含义却不那么显而易见。以下给出这一条递推式的两种理解/推理方式。

方法一：观察

由于题目背景是数的十进制表示，再加上自己写的一些案例，可以想到10次操作可能有一些特殊含义。可以列举一下单个数字（0-9）组成的字符串进行10次操作后的结果：
$$\begin{gathered} 0\to 10 \\ 1\to 21 \\ 2\to 32 \\ ⋮ \\ 8\to 98 \\ 9\to 109 \end{gathered}$$
以上结果字符串被我认为用空格隔开了。这样看，任何单个数字进行10次操作，其结果都等于它的下一个数+它本身。而对于多于一个字符的输入，各个字符的“发展”也是独立的。这样，$d{p}_{i-10}+d{p}_{i-9}$的意义就显现了出来。

方法二：代数推导

可以把一开始模拟的过程也写成递推表达式的形式。

设$b_{i,j}$是第$i$次操作后，$j$这个数字出现的次数，其中 i ∈ N , j ∈ { 0 , 1 , … , 9 } i\in \mathbb{N},j\in\{0,1,\dots,9\} i∈N,j∈{0,1,…,9}。则可以写出：
$$\{\begin{array}{ll}{b}_{i,j}=b_{i-1,j-1},& 2\le j\le 9,\\ b_{i,0}=b_{i-1,9},& (j=0),\\ b_{i,1}=b_{i-1,0}+b_{i-1,9},& (j=1).\end{array}$$
又有
$$\begin{array}{rl}d{p}_i& =\sum _{j=0}^9{b}_{i,j}\\ & =\sum _{j=0}^9(b_{i-1,j})+b_{i-1,9}\\ & =d{p}_{i-1}+b_{i-1,9}\end{array}$$
我们希望得出$d{p}_i$与$d{p}_{i-1},d{p}_{i-2},\dots$之间的关系式。设$i\ge 10$，则可以进一步代换，得
$$\begin{array}{rl}d{p}_i& =d{p}_{i-1}+b_{i-1,9}\\ & =d{p}_{i-2}+b_{i-2,9}+b_{i-2,8}\\ & =\cdots \\ & =d{p}_{i-9}+b_{i-9,9}+b_{i-9,8}+\cdots +b_{i-9,1}\\ & =d{p}_{i-10}+b_{i-10,9}+b_{i-10,8}+\cdots +b_{i-10,0}+b_{i-10,9}\\ & =d{p}_{i-10}+d{p}_{i-10}+b_{i-10,9}\\ & =d{p}_{i-10}+d{p}_{i-9}.\end{array}$$
由此就推导出了这个递推式。