Codeforces Round #701 (Div. 2) A ~ F ，6题全，超高质量良心题解【每日亿题】2021/2/13

整理的算法模板合集： ACM模板

点我看算法全家桶系列！！！

实际上是一个全新的精炼模板整合计划
正文更新啦：《算法竞赛中的初等数论》正文 0x00整除、0x10 整除相关（ACM / OI / MO）（十五万字符数论书）

---

怎么这么多人AK呀 … 确实挺简单的 (●ˇ∀ˇ●) 考到了很多常用技巧，一堆智商检测题，简直好评hhh
不过怎么全是签到题呀，确实比较考察思维hhh但是比赛过的人却很少 ~ 以前前几题都是能过一万五来着，这次只有几千…

比赛链接：https://codeforces.com/contest/1485

A - Add and Divide

Problem A Add and Divide

Translation
给定两个正整数 $a$, $b$ ，你可以进行两种操作：

• 使得 $a=\lfloor \frac{a}{b}\rfloor$
• 使得 $b=b+1$

请问最少多少次操作，使得 $a=0$。

Word

Solution

签到题 ~

之前做过这种题目，链接：2021年洛谷一月月赛（Div1、Div2，6题）全部题解 C题，比这个难多了 ~

但是万变不离其宗，那道题同样有两个操作，加一或者 $\times 2$ ，最小费用修改，使得整个序列满足一个条件，需要套一个二分加DP。

中心思想还是分析性质。我们发现 $+$ 操作前期比 $\times$ 收益更大，后期 $\times$ 操作比 $+$ 操作收益更大，由于乘的话是指数级增长，所以那么数据是 $10^9$ ，实际的操作次数也是常数级别的，所以我们可以暴力。这道题仅要求将 $a$ 除到 $0$，我们仅需将 $b$ 加到 $10$ 即可，然后暴力计算。

其实可以简单地证明一下，为什么到 $10$ 一定ok，实际上一次加操作，最后的总贡献是你乘的次数，如果当你乘一次的贡献就已经超过了乘的次数，也就是说乘的贡献此时一定超过了加的贡献，所以简单算一下，我们发现 ${\log }_{10}10^9=9$， 所以只需要加到10即可 ~

Code

#include 
#include 
#include 
#include 
#include 

using namespace std;
typedef long long ll;
typedef int itn;
const int N = 5007;
const ll INF = 4e18;

int n, m, t;
ll a, b;

void solve()
{
     
    scanf("%lld%lld", &a, &b);
    if(a == 0) {
     
        puts("0");
        return ;
    }
    ll res = INF, ans;
    ll cnt = 0;
    ll B = b;
    if(b == 1) b ++ , cnt ++ ;
    for(; b <= 10; ++ b) {
     

        ans = 0;
        cnt ++ ;
        ll tmp_a = a;
        while(tmp_a) {
     
            tmp_a /= b;
            ans ++ ;
        }
        ans += cnt;
        ans -- ;
        if(ans < res) res = ans;
    }
    if(B > 10) {
     
        ans = 0;
        while(a) {
     
            a /= B;
            ans ++ ;
        }
    }
    res = min(res, ans);
    printf("%lld\n", res);
    return ;
}

int main()
{
     
    scanf("%d", &t);
    while(t -- ) {
     
        solve();
    }
}

B - Replace and Keep Sorted

Problem B Replace and Keep Sorted

Translation

对于一个正整数 $k$ ，规定两个序列是 “$k$ 相似序列” 需要满足以下要求：

• 两个序列严格递增
• 两个序列有相同的长度
• 两个序列的元素的取值 $\in [1,k]$
• 两个序列仅有一个位置的元素不同

给定一个正整数 $k$，一个严格递增的序列 $a$ ，将会有 $q$ 次询问，每次询问一个区间 $l$ ，$r$ ，你的任务是每次输出有多少种 $b$ 序列是序列 $a_l,a_{l+1},a_{l+2}\cdots ,a_r$ 的 “$k$ 相似序列” 。

Word

Solution

签到题 ~

注意一个重要的性质：严格递增

因为元素的取值只能是 $[1,k]$ ，并且两个序列必须只能有一个不同的元素，由于序列一定严格递增，求总的方案数，实际上对于每一个序列来说，每次只能有一个位置不同，而对于这个位置来说，手算一下发现，对于每一个区间里的数，一共有 $a[i+1]-a[i-1]-2$ 种选法，对于区间的边界来说，一共有 $a[i+1]-a[i-1]-2$ 种选法，设每一个位置 $i$ 的选法就是 $i$ 的权值，由加法原理可知，总方案数就是区间权值和，所以我们直接使用一个前缀和维护一下即可。

Code

#include 
#include 
#include 
#include 
#include 

using namespace std;
typedef long long ll;
typedef int itn;
const int N = 2e5 + 7;
const ll INF = 4e18;

int n, m, t, q, k;

ll val[N], a[N];
ll sum[N];

int main()
{
     
    scanf("%d%d%d", &n, &q, &k);
    for(int i = 1; i <= n; ++ i) {
     
        scanf("%d", &a[i]);
    }
    a[0] = 1, a[n + 1] = k;
    for(int i = 1; i <= n; ++ i) {
     
        val[i] = a[i + 1] - a[i - 1] - 2;
        sum[i] = sum[i - 1] + val[i];
    }
    while(q -- ) {
     
        int l, r;
        scanf("%d%d", &l, &r);
        ll ans = sum[r - 1] - sum[l];
        ans += a[l + 1] - 1 - 1;
        ans += k - a[r - 1] - 1;
        printf("%lld\n", ans);
    }
    return 0;

}

C - Floor and Mod

Problem C Floor and Mod

Translation

定义一对数 $(a,b)$ 是特殊的，当且仅当 $\lfloor \frac{a}{b}\rfloor =a\mathrm{m}\mathrm{o}\mathrm{d}b$

给定 $x$ 和 $y$ ，求一共有多少对特殊的数 $(a,b)$ ，当 $1\le a\le x,1\le b\le y$。

Solution

签到$\cdots$

反正不是太难hhh

不就是推柿子嘛，我DNA动了

$\lfloor \frac{a}{b}\rfloor =a\mathrm{m}\mathrm{o}\mathrm{d}b$
$\lfloor \frac{a}{b}\rfloor =a-\lfloor \frac{a}{b}\rfloor \times b$
$a=\lfloor \frac{a}{b}\rfloor \times (b+1)$
$\frac{a}{b+1}=\lfloor \frac{a}{b}\rfloor$

因为$\lfloor \frac{a}{b}\rfloor$ 一定是整数，所以 $\frac{a}{b+1}$ 一定是整数，所以 $b+1|a$。

分类讨论：

若 $\lfloor \frac{a}{b}\rfloor <b$

则等式两边同除以 $b$ ：

$\frac{a}{b+1}=\frac{\lfloor \frac{a}{b}\rfloor }{b}$

$\frac{\frac{a}{b+1}}{b}=\lfloor \frac{\frac{a}{b}}{b}\rfloor$

$\frac{a}{b^2+b}=0$

显然 $a<b^2+b$

即 $a\in [0,b^2+b-1]$。那么问题就变成了在这个区间里一共多少个 $a$，使得 $b+1|a$ ，答案很显然就是 $\frac{b^2+b-1}{b+1}$ ，可以理解为区间 $[0,b^2+b-1]$ 内， $b-1$ 的倍数的个数（因为$b+1|a$）。

我们考虑枚举 $b$ ，则最终的答案为：

$\sum _{b=1}^{y}ans=\frac{min\{x,b^2+b-1\}}{b+1}$

那么分析：$min\{x,b^2+b-1\}$，很明显当 $b\le \sqrt{x}$ 的时候， $b^2+b-1>x$，也就是说我们仅需要枚举到 $\sqrt{x}$ 即可。剩余的情况 $min\{x,b^2+b-1\}$ 均为 $x$ ，也就是说我们就可以使用整除分块解决，整体时间复杂度为 $O(\sqrt{n})$ 。

整除分块又称数论分块，详见我的学习笔记：https://fanfansann.blog.csdn.net/article/details/110579001

Code

#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
typedef int itn;
const int N = 5e6 + 7, M = 1e6 + 7, mod = 1e9 + 7;
const int INF = 1e9 + 7;

int n, m, t, k, q;
ll x, y;

void solve()
{
     
    scanf("%lld%lld", &x, &y);
    ll a, b = 1;
    ll ans = 0;
    for(; b * b + b - 1 <= x && b <= y; ++ b) {
     
        ans += (b * b + b - 1) / (b + 1);
    }
    ll l = b + 1, r;
    for(; l <= x && l <= y + 1; l = r + 1) {
     
        r = x / (x / l);
        if(r > y + 1) break;
        ans += x / l * (r - l + 1);
    }
    if(l <= x) {
     
        r = y + 1;
        ans += x / l * (r - l + 1);
    }
    /*
    int k = min(x, y);
    for(int l = b + 1, r; l <= k; l = r + 1) {
        r = min(k, min(x / (x / l), y / (y / l)));
        ans += x / l * (r - l + 1);
    }*/
    printf("%lld\n", ans);
}

int main()
{
     
    scanf("%d", &t);
    while(t -- ) {
     
        solve();
    }
    return 0;
}

D - Multiples and Power Differences

Problem D Multiples and Power Differences

Word

Solution

签到题

先手玩样例

1 2 
2 3
···
6 2 
2 6

16 16 16
16 16 16
···
16 32 16 
32 16 32

发现首先要考虑的是位置对应，所以我们按照奇数偶数分开，奇行偶列，奇行奇列，偶行奇列，偶行偶列，使用位运算可以将他们分开：

1 ^ 1 = 0    1 ^ 0 = 1
         ↖ ↗
         ↙ ↘
0 ^ 1 = 1    0 ^ 0 = 0

解决了位置放置的问题，再来思考如何求矩阵 $b$。

首先每一个 $b_{i,j}$ 必须是 $a_{i,j}$ 的倍数，并且 $b_{i,j}\le 10^6$，

首先乱搞肯定不行，$b$ 种的每一个数都有要求，必须和相邻的格子差值的绝对值为 $k^4$ ，但是 $k$ 仅需大于 $1$ 即可，没有其他的要求，啥都行，而 $1\le a_{i,j}\le 16$ 所以这就给我们了一个提示， $k$ 的取值根据当前的 $a$ 来决定。

所以我们必须要同时满足：

首先必须是 $a$ 的倍数，然后差值还必须是 $k^4$。

因为要的是差值，我们不好控制这个差值，只有当一个数是固定的，这样我们将另一个数加上 $k^4$ ，这样我们就可以控制这个差值了，再结合上面我们分析样例，发现确实有一些数是可以不变的，所以我们考虑有没有一个数一定是 $a_{i,j}$ 的倍数？而 $b$ 还有限制 ， $b_{i,j}\le 10^6$，需要尽量的小，还要一定是全部的倍数 —— 最小公倍数LCM。其实关键在于 $1\le a_{i,j}\le 16$，给定一个很小的小范围， $b$ 也有范围，这些都是提示呀各位。我们计算发现 $1$ ~ $16$ 的 $LCM=720720\le 10^6$，这样还满足了一定是 $a_{i,j}$ 的倍数，而且还是一个固定的值，这样我们就可以控制两个数的差值，完美！

最后如何控制差值，我们仅需根据最开始奇偶分类，$1$ 为 $LCM$ 。$0$ 呢，想要 $1$ 和$0$ 的差值是 $k^4$ ，而 $k$ 任意，所以我们取 $0$ 位置上的 $a_{i,j}$ 即可，$0$ 的值就是 $LCM+(a_{i,j}{)}^4$。

Code

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
typedef long long ll;
typedef int itn;
typedef pair<int, int> PII;
const int N = 3e4 + 7, M = 6e6 + 7, mod = 1e9 + 7;
const ll INF = 1e18 + 7;

int lcm(itn a, int b)
{
     
    return a / __gcd(a, b) * b;
}
itn n, m, x;
itn main()
{
     
    scanf("%d%d", &n, &m);
    int LCM = 1;
    for(int i = 1; i <= 16; ++ i) {
     
        LCM = lcm(LCM, i);
    }
    for(int i = 1; i <= n; ++ i) {
     
        for(int j = 1; j <= m; ++ j) {
     
            scanf("%d", &x);
            if(((i ^ j) & 1) == 0)//其实无所谓
                printf("%d ", LCM);
            else printf("%d ", LCM + x * x * x * x);
        }
        puts("");
    }
    return 0;
}

E - Move and Swap

待更…

F - Copy or Prefix Sum

Problem F Cpoy or Prefix Sum

Translation

给定一个 $b$ 数组，一个 $a$ 是合法的指对于每一个 $i$ 都有 $b_i=a_i$ $b_i=\sum _{j=1}^i{a}_j$ 。问合法的 $a$ 有多少个。

$1\le t\le 10^4,1\le \sum n\le 2\times 10^5,-10^9\le b_i\le 10^9$

Word

Solution

看着这个式子，很明显就是一个DP。

因为题目中 $a$ 可以等于 $b_i=\sum _{j=1}^i{a}_j$，所以DP考虑维护前缀和。$f[i][j]$ 表示前 $i$ 个数中，前缀和为 $j$ 的方案数。初始化经典 $f[0][0]=1$ ，最终的答案很明显就是 $\sum _{j=min}^{max}f[n][j]$。
有了边界，答案，开考虑转移方程。

因为有两种情况，所以分类讨论。

当 $a[i]$ 等于 $b[i]$ 时：

对于 $j\in [min,max]$ 很明显

• 有 $f[i][j]=f[i-1][j-b[i]]$

当 $a[i]$ 等于 $b_i=\sum _{j=1}^i{a}_j$ 时，我们计算前缀和 $sum[i]$，即此时 $a[i]=b[i]-sum[i-1]$：

• 有 $f[i][b[i]]=\sum _{j=-min}^{max}f[i-1][j]$

不过由于数据过大，我们不能直接开数组，但是数据量小，所以我们可以使用 map 来代替数组，进行转移。

但是我们这样暴力循环递推，并且因为使用到了 map ，所以总的时间复杂度为$O(n^{2}logn)$，而 $1\le n\le 2\times 10^5$，所以考虑如何优化。

我们发现实际上第一个转移方程就是所有的元素全部向右移动 $b[i]$ ，所以对于第一种转移，我们只需要记录一下最终向右移动了多少，然后每次 $O(1)$ 转移。

对于第二个转移方程，实际意义就是 $f[i][b[i]]$ 等于前面的所有元素之和，设原来的全局之和（也就是答案）应该是 $ans$， $f[i][b[i]]=ans$，原来的 $f[i][b[i]]$ 没了，也就是新的全局和变成了 $ans=ans+ans-f[i][b[i]]$。

最后因为 $-10^9\le b_i\le 10^9$，所以有可能答案为负数，所以最后 mod 的时候注意加上 mod 消掉负数。

Code

#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
typedef int itn;
const int N = 5e5 + 7, M = 1e6 + 7, mod = 1e9 + 7;
const int INF = 1e9 + 7;

int n, m, t, k, q;
ll x, y;
map<ll, ll>mp;
ll b[N];

void solve()
{
     
    ll deviation = 0, ans = 0;
    scanf("%d", &n);
    mp.clear();

    mp[0] = 1;
    ans = 1;
    for(int i = 1; i <= n; ++ i) {
     
        scanf("%lld", &b[i]);
    }
    for(int i = 1; i <= n; ++ i) {
     
        deviation -= b[i];
        ll change = ans - mp[b[i] + deviation];
        mp[b[i] + deviation] = ans;
        ans = ans + change % mod;
    }
    printf("%lld\n", (ans % mod + mod) % mod);
    return ;
}

int main()
{
     
    scanf("%d", &t);
    while(t -- ) {
     
        solve();
    }
}