Codeforces Round #752 (Div. 2)

A.Era

题目描述

​ 给一个长为 $n$ 的序列 $a_1,a_2,\cdots ,a_n$，你可以对序列做任意次如下所述的操作：选择一个数字 $k$（每次操作选择的数字可以不同），将其插入到序列 $a$ 的任意位置，比如：$a=[3,3,4]$，$k=2$，操作后可能的序列有 $[2,3,3,4],[3,2,3,4],[3,3,2,4],[3,3,4,2]$。

​ 操作尽可能少的次数，使序列 $a$ 满足：$\forall i,a_i\le i$，求这个最少的操作次数。

​ 数据范围：多组测试数据，$1\le n\le 100$，$1\le a_i\le 10^9$。

分析

​ 对于某个下标 $i$，如果 $a_i>i$，最少需要在位置 $i$ 前插入 $a_i-i$ 个数字。枚举所有的 $a_i-i$，其中的最大值即为答案，即 ans=max⁡i=1n{ai}ans=\max\limits_{i=1}^{n}\{a_i\}ans=i=1maxn​{ai​}。

代码

#include<bits/stdc++.h>

using namespace std;

int main() {
    int T;
    cin >> T;
    while (T--) {
        int n;
        cin >> n;
        int ans = 0;
        for (int i = 1; i <= n; i++) {
            int k;
            scanf("%d", &k);
            ans = max(ans, k - i);
        }
        cout << ans << endl;
    }
}

B.XOR Specia-LIS-t

题目描述

​ 给一个长为 $n$ 的序列 $a_1,a_2,\cdots ,a_n$，把它分成若干个不相交的子序列，第 $i$ 个子序列的最长递增子序列的长度定义为 $h_i$。比如我们把序列 $[2,5,3,1,4,3,2,2,5,1]$ 分割成 $[2,5,3,1,4],[3,2,2,5],[1]$，则 $h=[3,2,1]$。

​ 判断能否以某种方式分割 $a$ 序列，使得 $h$ 序列的异或和等于 $0$。

​ 数据范围：多组测试数据，$2\le n\le 10^5$，$1\le a_i\le 10^9$，$n$ 的总和不超过 $3\times 10^5$。

分析

​ 如果 $n$ 是偶数，把 $a$ 序列分割成长为 $1$ 的 $n$ 个子序列，答案一定是 YES。

​ 如果 $n$ 是奇数，我们考虑寻找满足 $a_i\ge a_{i+1}$ 的相邻的两个数字，把这两个数字作为一个子序列分割出来，最长递增子序列的长度为 $1$，如果找的到，答案为 YES，否则为 NO。

代码

#include<bits/stdc++.h>

using namespace std;
int a[300010];

int main() {
    int T;
    cin >> T;
    while (T--) {
        int n;
        cin >> n;
        bool flag = true;
        for (int i = 1; i <= n; i++) {
            scanf("%d", &a[i]);
        }
        for (int i = 1; i <= n - 1; i++)
            if (a[i] >= a[i + 1]) {
                flag = false;
            }
        if (n % 2 == 0 || flag == false) {
            puts("YES");
        } else {
            puts("NO");
        }
    }
    return 0;
}

C.Di-visible Confusion

题目描述

​ 给一个长为 $n$ 的序列 $a_1,a_2,\cdots ,a_n$， 进行如下操作：选择一个 $a_i$，要求 $(i+1)\nmid a_i$，将其从序列中移除。判断能否通过若干次操作使得序列变为空。

​ 数据范围：多组测试数据，$1\le n\le 10^5$，$1\le a_i\le 10^9$，$n$ 的总和不超过 $3\times 10^5$。

分析

​ 对于所有的 $i$，如果 $2$ ~ $i+1$ 中至少存在一个数字不整除 $a_i$，则答案为 YES，否则答案为 NO。

​ 使用数学归纳法来证明：如果 $a_n$ 前面的 $n-1$ 个数字都能被移除，则 $a_n$ 也能在其位置为 $1 $ ~ $n$ 中的某个位置时被移除（假设该位置为 $k$，$a_n$ 可以在序列中有 $k-1$ 个数字时被移除）。

​ 下面考虑如何快速判断 $2$ ~ $ i+1$ 中是否至少有一个数字不整除 $a_i$。如果 $a_i$ 能被 $2$ ~ $ i+1$ 的所有数字整除，这代表 $a_i$ 也能被 $\text{LCM}(2,3,\cdots ,i+1)$ 整除，但是当 $n=22$ 时，$\text{LCM}(2,3,\cdots ,23)>10^9>a_i$。所以当 $i\ge 22$ 时，必然存在一个数字不整除 $a_i$，不需要逐一判断；当 $i<22$ 时，暴力检验。时间复杂度 $O(n+21^2)$。

代码

#include<bits/stdc++.h>

using namespace std;

int main() {
    int T;
    cin >> T;
    while (T--) {
        int n;
        cin >> n;
        bool flag = true;
        for (int i = 1; i <= n; i++) {
            int x;
            scanf("%d", &x);
            bool f = false;
            for (int j = i + 1; j >= 2; j--) {
                if (x % j != 0) {
                    f = true;
                    break;
                }
            }
            flag = flag & f;
        }
        if (flag == true) {
            puts("YES");
        } else {
            puts("NO");
        }
    }
    return 0;
}

D.Moderate Modular Mode

题目描述

​ 有两个偶数 $x,y(2\le x,y\le 10^9)$，找到一个数字 $n(2\le n\le 10^{18})$，使得 $n\mathrm{m}\mathrm{o}\mathrm{d}x=y\mathrm{m}\mathrm{o}\mathrm{d}n$。

分析

​ 如果 $x>y$，则 $(x+y)\mathrm{m}\mathrm{o}\mathrm{d}x=y\mathrm{m}\mathrm{o}\mathrm{d}x=y\mathrm{m}\mathrm{o}\mathrm{d}(x+y)=y$，即 $n=x+y$。

​ 如果 $x\le y$：

​ 结论一：$n\ge x$。

​ 证明：使用反证法证明，存在某个 $n<x$ 使得 $n\mathrm{m}\mathrm{o}\mathrm{d}x=y\mathrm{m}\mathrm{o}\mathrm{d}n$ 成立。则 $n\mathrm{m}\mathrm{o}\mathrm{d}x=n$，但 $y\mathrm{m}\mathrm{o}\mathrm{d}n<n$，与假设矛盾，因此结论一正确。

​ 结论二：$n\le y$。

​ 证明：使用反证法证明，存在某个 $n>y$ 使得 $n\mathrm{m}\mathrm{o}\mathrm{d}x=y\mathrm{m}\mathrm{o}\mathrm{d}n$ 成立。则 $n\mathrm{m}\mathrm{o}\mathrm{d}x<x$，但 $y\mathrm{m}\mathrm{o}\mathrm{d}n=y\ge x$，与假设矛盾， 因此结论二正确。

​ 所以 $x\le n\le y$，下面考虑如何求出 $n$ 确切的值。

​ 假设有一个 $X$ 轴，一开始在 $0$ 点，从 $0$ 点跳到 $y$ 点，每次跳跃的距离为 $x$。有可能在最后一次跳跃后跳过点 $y$，设最后一次跳跃前的位置为 $p=y-y\mathrm{m}\mathrm{o}\mathrm{d}x$，从位置 $p$ 跳跃到 $y$ 点需要两个步骤。因为 $y-p$ 是偶数，所以我们需要跳跃 $\frac{y-p}{2}$ 个单位，此时跳到了位置 $t=p+\frac{y-p}{2}$，可以发现 $t$ 就是我们要求的 $n$，因为 $t\mathrm{m}\mathrm{o}\mathrm{d}x=\frac{y-p}{2}$ 且 $y\mathrm{m}\mathrm{o}\mathrm{d}t=(y-p)-\frac{y-p}{2}=\frac{y-p}{2}$，即 $n=t=y-\frac{y\mathrm{m}\mathrm{o}\mathrm{d}x}{2}$。

代码

#include<bits/stdc++.h>

using namespace std;

int main() {
    int T;
    cin >> T;
    while (T--) {
        int x, y;
        cin >> x >> y;
        if (x <= y) {
            cout << y - y % x / 2 << endl;
        } else {
            cout << x + y << endl;
        }
    }
    return 0;
}

E.Extreme Extension

题目描述

​ 给一个长为 $n(1\le n\le 10^5)$ 的序列 $a_1,a_2,\cdots ,a_n(1\le a_i\le 10^5)$，每次操作可以选择序列中的一个数字 $a_i$，将其拆分为两个数字之和并代替 $a_i$ 加入到序列中。定义一个序列的 极值 为使得数组单调不下降所需的最少操作次数，求序列 $a$ 的所有子序列的 极值 之和，答案对 $998244353$ 取模。

分析

​ 对于 $a_i>a_{i+1}$ 的情况，需要将 $a_i$ 拆成 $k$ 个数字：$1\le b_1\le b_2\le \cdots \le b_k\le a_{i+1}$ 且 $b_1+b_2+\cdots +b_k=a_i$。由于 $b_k\le a_{i+1}$，所以 $k\ge \lceil \frac{a_i}{a_{i+1}}\rceil$ 。显然 $b_1$ 越大操作的次数就越少（比如 $[4,4,4,5]$ 比 $[3,3,3,3,5]$ 要好），所以令 $k=\lceil \frac{a_i}{a_{i+1}}\rceil$。注意到 $b_1\le \lfloor \frac{a_i}{k}\rfloor$，令 $b_1=\lfloor \frac{a_i}{k}\rfloor =\lfloor \frac{a_i}{\lceil \frac{a_i}{a_{i+1}}\rceil }\rfloor$。经过 $k-1$ 次操作即可将 $a_i$ 拆分成 $[b_1,b_2,\cdots ,b_k]$。

​ 按照如下步骤求出 极值：

• 倒序遍历 $i=n-1$ ~ $1$。
• 答案加 $\lceil \frac{a_i}{a_{i+1}}\rceil -1$。
• 令 $a_i=\lfloor \frac{a_i}{\lceil \frac{a_i}{a_{i+1}}\rceil }\rfloor$

时间复杂度为 $O(n)$，求出所有子序列的 极值 之和的时间复杂度为 $O(n^2)$，考虑如何用更优地时间复杂度解决此题。

令 $dp(i,x)$ 为第 $i$ 个数被拆分为最小元素为 $x$ 的若干个数，而且以 $x$ 为开头的非递减数列的数量。

我们只考虑 $x$ 有多少种可能的值（实际只有 $O(\sqrt{10^5})$，后面会提到）。对于 $x=1$ ~ $10^5$，需要进行如下的状态转移：$dp(i,\lfloor \frac{a_i}{\lceil \frac{a_i}{x}\rceil }\rfloor )+=dp(i+1,x)$。

实际上 $x$ 最多只有 $2\sqrt{10^5}$ 种不同的值（$\lfloor \frac{m}{1}\rfloor ,\lfloor \frac{m}{2}\rfloor ,\cdots ,\lfloor \frac{m}{m}\rfloor$，整除分块的思想）。因此我们可以在 $O(n\sqrt{10^5})$ 的时间复杂度内解决此题，而且转移方程之和 $i,i+1$ 有关，可以使用滚动数组优化掉一维。

最后根据 $dp$ 数组计算答案，对于 $dp(i+1,x)$，它对答案的贡献为 $i\times dp(i+1,x)\times (\lceil \frac{a_i}{a_{i+!}}\rceil -1)$，这是因为有 $i\times dp(i+1,x)$ 个序列，每个序列都对 $a_i$ 进行这样的拆分。

时间复杂度 $O(n\sqrt{10^5})$，空间复杂度 $O(n)$。

代码

#include<bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/hash_policy.hpp>

using namespace std;
using namespace __gnu_pbds;
const int mod = 998244353;
int a[300010];

int main() {
    int T;
    cin >> T;
    while (T--) {
        int n;
        cin >> n;
        for (int i = 1; i <= n; i++)
            scanf("%d", &a[i]);
        gp_hash_table<int, int> dp;
        long long ans = 0;
        for (int i = n; i >= 1; i--) {
            gp_hash_table<int, int> &&dp2 = {};
            dp2[a[i]] = 1;
            for (auto it:dp) {
                int t = (a[i] + it.first - 1) / it.first;
                dp2[a[i] / t] += it.second;
                ans = ans + ((long long) i * it.second) * (t - 1);
            }
            ans = ans % mod;
            dp = move(dp2);
        }
        cout << ans << endl;
    }
    return 0;
}