Divide by Zero 2021 and Codeforces Round #714 (Div. 2)

A

1. 需要找到一个满足长度为n的含有k个峰的排列，直接将前k大的数都作为峰就好了；
2. 峰的位置为2，4，…这样安排就能安排最多的峰，剩下的按照顺序插入空余位置；
3. 不能满足的情况：n为奇数时，k > n / 2；n为偶数时，k >= n / 2（这里除法都是下取整）。

B

看题目第一眼感觉就是找规律，可是卡了好久，先过的C…

1. 先来证明一个推论:
   $$a_1=a_2\&a_3\&...\&a_n$$
   等价于对任意 $1<i<n$
   $$a_1\&a_2\&..\&a_i=a_{i+1}\&a_{i+2}\&...\&a_n$$

   我用的反证法，反正它是成立的…（狗头保命）
   开始。把第一个式子称为 ① 式，第二个式子称为 ② 式，假设①式成立时存在 $1<i<n$ 使得 ② 不成立，即
   $$\begin{gathered} ③a_1=a_2\&a_3\&...\&a_n \\ ④a_1\&a_2\&..\&a_i\ne a_{i+1}\&a_{i+2}\&...\&a_n \end{gathered}$$
   然后③式两边同时 $\&$ 上 $(a_2\&a_3\&...\&a_i)$ 这个数，那么 ③ 式左边就变得和 ④ 式左边一样了，但这时候 ③ 式右边还是不变的（想想为什么），变成下面这个
   $$⑤a_1\&a_2\&..\&a_i=a_2\&a_3\&...\&a_n$$
   对 ④ 式进行一样 的操作，两边同时 $\&$ 上 $(a_2\&a_3\&..\&a_i)$ 这个数，结果中左边是不变的，得到下面的结果
   $$⑥a_1\&a_2\&..\&a_i\ne a_2\&a_3\&...\&a_n$$
   ⑤ ⑥ 矛盾，所以假设不成立，即前面所说的推论是成立的。

2. 根据题目意思和上一步得到的推论，要使得
   $$a_1\&a_2\&..\&a_i=a_2\&a_3\&...\&a_n$$
   成立，就要满足下面两个式子
   $$\begin{gathered} a_1=a_2\&a_3\&...\&a_n \\ {a}_1\&a_2\&..\&a_{n-1}=a_n \end{gathered}$$
   所以只要能找到两个元素，把它们分别放在首位和末尾就可以了。

   假如我们找到 $k$ 个元素是满足可以放在首位或者末尾的，那么就从中选取两个，然后中间全排列，就是答案，乘2是因为首尾两个元素也有是顺序的
   $$ans=2\ast C_k^2\ast (n-2)!$$
   然后要做的就是找到这个 $k$ 值

3. 上面的式子可以换个写法，即
   $$a_1=a_2\&a_3\&...\&a_n$$
   可以写成（这里 $\wedge$ 是异或操作）
   $$a_1\wedge (a_2\&a_3\&...\&a_n)=0$$
   接下来就是判断每个元素，将它异或（剩下n - 1个元素进行 $\&$ 操作的结果）得到的结果，看是否为0。如果为0，k++.

   但是每次遍历元素时，对其他元素进行 $\&$ 操作求和时间复杂度大，我是用了一个 bit[32] 进行记录。将所有数的每个二进制位记录下来，bit[i]表示在二进制表示中，n个数的二进制表示在第 i 的1的数目。如数组 {1, 2, 3} 那么bit[0] = 2, bit[1] = 1，其他为0.

   这时候遍历到 第 i 个元素时，bit[] 数组先减去 第 i 个元素的记录，然后判断剩下的是否为 n - 1个1（说明剩下n - 1个元素进行 $\&$ 操作后这个二进制位仍为 1 ），为 1 则 $a_1\&a_2\&...\&a_{i-1}\&a_{i+1}\&...\&a_n$ 的二进制第 i 位 为 1，这样就能直接得到了。

C

一、打表+OEIS

1. 所有个位数都可以从 0 开始进行多次变化得到，所以尝试查看前面的结果有没有什么规律，OEIS说有（A103377），所以过了：点这里

二、DP思路

1. 对于从0开始的数列{0，1，2，…，9，10，21，32，…}，用 $dp[i]$ 表示第几个数的位数，我这里 $i$ 从0开始。
2. $dp[i]$ 相比 $dp[i-1]$$ 增加多少，是由 $dp[i-1]$ 对应的数中数字9的数量来决定的：9->10，数位+1.所以可以得到
   $$dp[i]=dp[i-1]+num(dp[i-1]对应数字中9的数量）$$
   然后就将问题转化为求 $dp[i-1]$ 对应数字中9的数量。
3. 第 $k$ 个数字中 9 的数量等价于第 $k-8$ 个数的 1 的数量，来看一下 1 的来源：9+1=10，0+1=1。所以分别求出这两个贡献，和就是结果。
4. 首先是 9+1=10。意思就是看前一个数有多少个9。前一个数到当前数，位数增加，只有 9 是有贡献的。位数增加多少，说明上一个数有多少个 9，也就是当前数有多少个这样产生的 1。所以第 $k-8$ 位这样的 1 的数量为
   $$dp[k-8]-dp[k-9]$$
5. 然后是 0 + 1，原来的 0 必定是非前缀 0。特殊的只有第一个数是0，dp[0] = 1，其他数的有效 0 都是由 9 + 1 = 10 得到的，所以关注 前一个数有多少个 0 就好了。而这里的 0 和上一步所讨论的“这样的 1”，性质是一样的，都是由 9 + 1 = 10 产生。因为这里求的 0 是上一位的，所以对应的 9 是上上位的，所以第 $k-8$ 中 0 + 1 = 1 得到的 1 的数量，等价于上一个数 9 + 1 = 10 得到的 0 的数量，等价于上上个数中 9 的数量，即
   $$dp[k-9]-dp[k-10]$$
6. 所以得到
   $$\begin{gathered} num(dp[k]对应数字中9的数量）=dp[k-8]-dp[k-9]+dp[k-9]-dp[k-10] \\ =dp[k-8]-dp[k-10] \end{gathered}$$
7. 当 $k=i-1$ 时，就有
   $$dp[i]=dp[i-1]+dp[i-9]-dp[i-11]$$
   预处理前十几个数，后面就可以递推打表了

#include<bits/stdc++.h>
using namespace std;

#define int long long

const int N = 2e5 + 17;
const int mod = 1e9 + 7;
int dp[N];

void init(){
    for(int i = 0; i < 10; ++i)
        dp[i] = 1;
    for(int i = 10; i < 13; ++i)
        dp[i] = 2;
    for(int i = 13; i < N; ++i){
        dp[i] = (dp[i - 1] + dp[i - 9] - dp[i - 11] + mod) % mod;
    }
}

void solve(){
    int n, m;
    cin >> n >> m;
    int ans = 0;
    while(n){
        int x = n % 10;
        n /= 10;
        ans += dp[m + x];
        ans %= mod;
    }
    cout << ans << endl;
}

signed main(){
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    init();
    // for(int i = 1; i <= 1000; i += 1)
    //     cout << i << ' ' << dp[i] << endl;
    int t;
    cin >> t;
    while(t--){
        solve();
    }
    return 0;
}

8. 状态转移方程可以进一步修改，变成OEIS中给的式子。现在，直接列出来！
   $$\begin{gathered} dp[i]=dp[i-1]+dp[i-9]-dp[i-11] \\ dp[i-1]=dp[i-2]+dp[i-10]-dp[i-12] \\ dp[i-2]=dp[i-3]+dp[i-11]-dp[i-13] \\ dp[i-3]=dp[i-4]+dp[i-12]-dp[i-14] \\ dp[i-4]=dp[i-5]+dp[i-13]-dp[i-15] \\ ... \\ dp[14]=dp[13]+dp[5]-dp[3] \\ dp[13]=dp[12]+dp[4]-dp[2] \\ dp[12]=dp[11]+dp[3]-dp[1] \\ dp[11]=dp[10]+dp[2]-dp[0] \end{gathered}$$
   对，没错，累加，消去，最后得到
   $$dp[i]=dp[i-9]+dp[i-10]+dp[10]-dp[1]-dp[0]$$
   而dp[10] = 2, dp[1] = dp[0] = 1，所以得到最终式子
   $$dp[i]=dp[i-9]+dp[i-10]$$
   再用最终式子交一遍

#include<bits/stdc++.h>
using namespace std;

#define int long long

const int N = 2e5 + 17;
const int mod = 1e9 + 7;
int dp[N];

void init(){
    for(int i = 0; i < 10; ++i)
        dp[i] = 1;
    for(int i = 10; i < 13; ++i)
        dp[i] = 2;
    // for(int i = 13; i < N; ++i){
    //     dp[i] = (dp[i - 1] + dp[i - 9] - dp[i - 11] + mod) % mod;
    // }
    for(int i = 13; i < N; ++i){
        dp[i] = (dp[i - 9] + dp[i - 10]) % mod;
    }
}

void solve(){
    int n, m;
    cin >> n >> m;
    int ans = 0;
    while(n){
        int x = n % 10;
        n /= 10;
        ans += dp[m + x];
        ans %= mod;
    }
    cout << ans << endl;
}

signed main(){
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    init();
    // for(int i = 1; i <= 1000; i += 1)
    //     cout << i << ' ' << dp[i] << endl;
    int t;
    cin >> t;
    while(t--){
        solve();
    }
    return 0;
}

这里是我的一个错误思路，或许可以得到修正。
容易想到，第 $k$ 个数字中 9 的数量也等价于第 $k-9$ 个数中 0 的数量。而有效 0 的来源只有 9 + 1 = 10，所以直接得到
$$dp[i]=dp[i-1]+dp[i-9]-dp[i-10]$$
影响正确性的，是前缀0.
意思就是，第 k 个数字中的一个 9 ，在第 k - 9 中对应的 0 是无效的，即前缀0。如第18个数是 98，第9个数是9。