Codeforces Global Round 27 div1+2 个人题解(A~E)

Codeforces Global Round 27 div1+2 个人题解(A~E)

Dashboard - Codeforces Global Round 27 - Codeforces

火车头

#define _CRT_SECURE_NO_WARNINGS 1

#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <chrono>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <utility>
#include <vector>

using namespace std;

#define ft first
#define sd second

#define yes cout << "yes\n"
#define no cout << "no\n"

#define Yes cout << "Yes\n"
#define No cout << "No\n"

#define YES cout << "YES\n"
#define NO cout << "NO\n"

#define pb push_back
#define eb emplace_back

#define all(x) x.begin(), x.end()
#define all1(x) x.begin() + 1, x.end()
#define unq_all(x) x.erase(unique(all(x)), x.end())
#define unq_all1(x) x.erase(unique(all1(x)), x.end())
#define sort_all(x) sort(all(x))
#define sort1_all(x) sort(all1(x))

#define inf 0x3f3f3f3f
#define infll 0x3f3f3f3f3f3f3f3fLL

#define RED cout << "\033[91m"     // 红色
#define GREEN cout << "\033[92m"   // 绿色
#define YELLOW cout << "\033[93m"  // 蓝色
#define BLUE cout << "\033[94m"    // 品红
#define MAGENTA cout << "\033[95m" // 青色
#define CYAN cout << "\033[96m"    // 青色
#define RESET cout << "\033[0m"    // 重置

template <typename T>
void Debug(T x, int color = 1)
{
    switch (color)
    {
    case 1:
        RED;
        break;
    case 2:
        YELLOW;
        break;
    case 3:
        BLUE;
        break;
    case 4:
        MAGENTA;
        break;
    case 5:
        CYAN;
        break;
    default:
        break;
    }
    cout << x;
    RESET;
}

typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
// typedef __int128_t i128;

typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ld, ld> pdd;
typedef pair<ll, int> pli;
typedef pair<string, string> pss;
typedef pair<string, int> psi;
typedef pair<string, ll> psl;

typedef tuple<int, int, int> ti3;
typedef tuple<ll, ll, ll> tl3;
typedef tuple<ld, ld, ld> tld3;

typedef vector<bool> vb;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<string> vs;
typedef vector<pii> vpii;
typedef vector<pll> vpll;
typedef vector<pli> vpli;
typedef vector<pss> vpss;
typedef vector<ti3> vti3;
typedef vector<tl3> vtl3;
typedef vector<tld3> vtld3;

typedef vector<vi> vvi;
typedef vector<vl> vvl;

typedef queue<int> qi;
typedef queue<ll> ql;
typedef queue<pii> qpii;
typedef queue<pll> qpll;
typedef queue<psi> qpsi;
typedef queue<psl> qpsl;

typedef priority_queue<int> pqi;
typedef priority_queue<ll> pql;

typedef map<int, int> mii;
typedef map<int, bool> mib;
typedef map<ll, ll> mll;
typedef map<ll, bool> mlb;
typedef map<char, int> mci;
typedef map<char, ll> mcl;
typedef map<char, bool> mcb;
typedef map<string, int> msi;
typedef map<string, ll> msl;
typedef map<int, bool> mib;

typedef unordered_map<int, int> umii;
typedef unordered_map<ll, ll> uml;
typedef unordered_map<char, int> umci;
typedef unordered_map<char, ll> umcl;
typedef unordered_map<string, int> umsi;
typedef unordered_map<string, ll> umsl;

std::mt19937_64 rng(std::chrono::steady_clock::now().time_since_epoch().count());

template <typename T>
inline T read()
{
    T x = 0;
    int y = 1;
    char ch = getchar();
    while (ch > '9' || ch < '0')
    {
        if (ch == '-')
            y = -1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9')
    {
        x = (x << 3) + (x << 1) + (ch ^ 48);
        ch = getchar();
    }
    return x * y;
}

template <typename T>
inline void write(T x)
{
    if (x < 0)
    {
        putchar('-');
        x = -x;
    }
    if (x >= 10)
    {
        write(x / 10);
    }
    putchar(x % 10 + '0');
}

/*#####################################BEGIN#####################################*/
void solve()
{
}

int main()
{
    ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0);
    // freopen("test.in", "r", stdin);
    // freopen("test.out", "w", stdout);
    int _ = 1;
    std::cin >> _;
    while (_--)
    {
        solve();
    }
    return 0;
}

/*######################################END######################################*/
// 链接：

---

A. Sliding

红色被驱逐。他们不是冒名顶替者。

有 $n$ 行，每行 $m$ 人。让 $r$ 行和 $c$ 列中的位置表示为 $(r,c)$。从 $1$ 开始按行主序对每个人进行编号，即编号为 $(r-1)\cdot m+c$ 的人最初位于 $(r,c)$。

位于 $(r,c)$ 的人决定离开。为了填补空缺，让离开的人编号为 $i$。每个编号为 $j>i$ 的人将移动到编号为 $j-1$ 的人最初所在的位置。下图说明了 $n=2$、$m=3$、$r=1$ 和 $c=2$ 的情况。

计算每个人移动的曼哈顿距离之和。如果一个人最初在 $(r_0,c_0)$，然后移动到 $(r_1,c_1)$，则曼哈顿距离为 $|r_0-r_1|+|c_0-c_1|$。

输入
第一行包含一个整数 $t$ ($1\le t\le 10^4$) — 测试用例的数量。

每个测试用例的唯一一行包含 $4$ 个整数 $n$、$m$、$r$ 和 $c$ ($1\le r\le n\le 10^6$、$1\le c\le m\le 10^6$)，其中 $n$ 是行数，$m$ 是列数，$(r,c)$ 是离开的人最初所在的位置。

输出
对于每个测试用例，输出一个整数，表示曼哈顿距离的总和。

示例
输入

4
2 3 1 2
2 2 2 1
1 1 1 1
1000000 1000000 1 1

输出

6
1
0
1999998000000

提示
对于第一个测试用例，编号为 $2$ 的人离开，编号为 $3$、$4$、$5$ 和 $6$ 的人的移动距离分别为 $1$、$3$、$1$ 和 $1$。所以答案是 $1+3+1+1=6$。

对于第二个测试用例，编号为 $3$ 的人离开，编号为 $4$ 的人移动。答案是 $1$。

解题思路

如图所示，找出个单元格的移动方式，并数一下它们的数量，黄色单元格数量为$(n-r)\times m$ ，绿色单元格数量为$n-r$，蓝色单元格数量为$m-c$

代码实现

void solve()
{
    ll n, m, r, c;
    cin >> n >> m >> r >> c;
    cout << (n - r) * (m - 1) + (n - r) * (m) + (m - c) << "\n";
}

---

B. Everyone Loves Tres

有 $3$ 个英雄和 $3$ 个恶棍，所以总共 $6$ 个人。

给定一个正整数 $n$。找到最小整数，其十进制表示长度为 $n$，并且仅由 $3$ 和 $6$ 组成，并且可被 $33$ 和 $66$ 整除。如果不存在这样的整数，则打印 $-1$。

输入
第一行包含一个整数 $t$ ($1\le t\le 500$) — 测试用例的数量。

每个测试用例的唯一一行包含一个整数 $n$ ($1\le n\le 500$) — 十进制表示的长度。

输出
对于每个测试用例，如果存在所需的最小整数，则输出该整数，否则输出 $-1$。

示例
输入

6
1
2
3
4
5
7

输出

-1
66
-1
3366
36366
3336366

提示
对于 $n=1$，不存在这样的整数，因为 $3$ 和 $6$ 都不能被 $33$ 整除。

对于 $n=2$，$66$ 仅由 $6$ 组成，并且可被 $33$ 和 $66$ 整除。

对于 $n=3$，不存在这样的整数。只有 $363$ 可被 $33$ 整除，但不能被 $66$ 整除。

对于 $n=4$，$3366$ 和 $6666$ 都可以被 $33$ 和 $66$ 整除，并且 $3366$ 最小。

解题思路

$33$和$66$的最小公倍数为$66$，所以我们可以打个表，枚举一下$66$的倍数，找一下规律。

打表结果：

观察发现，除了1和3以外，$n$为偶数形式为$3333\dots 66$，奇数为$3333\dots 6366$

代码实现

void solve()
{
    ll n;
    cin >> n;
    if (n == 1 || n == 3)
        cout << "-1\n";
    else
    {
        string s(n - 2, '3');
        s += "66";
        if (n & 1)
            s[n - 4] = '6';
        cout << s << endl;
    }
}

---

C. Alya and Permutation

Alya 遇到了一个难题。不幸的是，她忙于竞选学生会。请帮她解决这个问题。

给定一个整数 $n$，构造一个整数 $1,2,\dots ,n$ 的排列 $p$，经过以下过程后，使 $k$ 的值最大化（最初为 $0$）。

对第 $i$ 个操作（$i=1,2,\dots ,n$）执行 $n$ 个操作，

如果 $i$ 为奇数，则 $k=k\&p_i$，其中 $\&$ 表示按位与操作。
如果 $i$ 为偶数，则 $k=k|p_i$，其中 $|$ 表示按位或运算。

输入
第一行包含一个整数 $t$ ($1\le t\le 500$) — 测试用例的数量。

每个测试用例的唯一一行包含一个整数 $n$ ($5\le n\le 2\cdot 10^5$) — 排列的长度。

保证所有测试用例的 $n$ 之和不超过 $2\cdot 10^5$。

输出
对于每个测试用例，在第一行输出 $k$ 的最大值，在第二行输出排列 $p_1,p_2,\dots ,p_n$。

如果有多个这样的排列，则输出任意一个。

示例
输入

6
5
6
7
8
9
10

输出

5
2 1 3 4 5 
7
1 2 4 6 5 3 
7
2 4 5 1 3 6 7 
15
2 4 5 1 3 6 7 8 
9
2 4 5 6 7 1 3 8 9 
15
1 2 3 4 5 6 8 10 9 7 

提示
对于第一个测试用例，$k$ 的值确定如下：

$k=0$ 初始。

在第 $1$ 次操作中，$1$ 是奇数，所以 Alya 设置 $k$ 为 $k\&p_1=0\&2=0$。
在第 $2$ 次操作中，$2$ 是偶数，所以 Alya 设置 $k$ 为 $k|p_2=0|1=1$。
在第 $3$ 次操作中，$3$ 是奇数，所以 Alya 设置 $k$ 为 $k\&p_3=1\&3=1$。
在第 $4$ 次操作中，$4$ 是偶数，所以 Alya 设置 $k$ 为 $k|p_4=1|4=5$。
在第 $5$ 次操作中，$5$ 是奇数，所以 Alya 设置 $k$ 为 $k\&p_5=5\&5=5$。
最终 $k$ 的值为 $5$。可以证明，对于所有长度为 $5$ 的排列，最终 $k$ 的值至多为 $5$。另一个有效输出是 $[2,3,1,4,5]$。

对于第二个测试用例，最终 $k$ 的值为 $7$。可以证明，对于所有长度为 $6$ 的排列，最终 $k$ 的值至多为 $7$。其他有效输出包括 $[2,4,1,6,3,5]$ 和 $[5,2,6,1,3,4]$。

解题思路

我们打个表发现，对于$n$为奇数，最大$k$值为$n$，对于$n$为偶数的情况，最大$k$值为$2^{len+1}-1$，其中$len$为$n$的最高二进制位。

打表结果：

根据结果倒推最大$k$值如何获得

• $n$为奇数

  我们可以构造$3,1,n-1,n$这样的序列放在最末尾。

  假设$n=99$，其末尾为$3,1,98,99$

  写成二进制形式如下：
  $0000011_2\&0000001_2|1100010_2\&1100011_2$

  计算结果为$1100011_2$，由于前一个操作是$|$，所有无论前面是什么值，答案一定不会小于$n$。

• $n$为偶数

  我们可以构造$3,1,2^{len}-2,2^{len}-1,n$这样的序列放在最末尾，其中$len$为$n$的最高二进制位。

  假设$n=100$，其末尾为$3,1,62,63,100$​

  写成二进制形式如下：
  $0000011_2\&0000001_2|0111110_2\&0111111_2|1100100_2$

  计算结果为$1111111_2$,由于前一个操作是$|$，所有无论前面是什么值，答案一定不会小于$2^{len+1}-1$。

  注：$n=6$的情况要特判一下

代码实现

void solve()
{
    int n;
    cin >> n;
    vb vis(n + 1);
    if (n & 1)
    {
        cout << n << "\n";
        vis[3] = vis[1] = vis[n - 1] = vis[n] = true;
        for (int i = 1; i <= n; i++)
        {
            if (vis[i])
                continue;
            cout << i << " ";
        }
        cout << 3 << " " << 1 << " " << n - 1 << " " << n << "\n";
    }
    else
    {
        if (n == 6)
        {
            cout << 7 << "\n";
            cout << "4 5 1 2 3 6\n";
            return;
        }
        int len = __lg(n);
        cout << (1 << len + 1) - 1 << "\n";
        int full = (1 << len) - 1;
        vis[3] = vis[1] = vis[full - 1] = vis[full] = vis[n] = true;
        for (int i = 1; i <= n; i++)
        {
            if (vis[i])
                continue;
            cout << i << " ";
        }
        cout << 3 << " " << 1 << " " << full - 1 << " " << full << " " << n << "\n";
    }
}

---

D. Yet Another Real Number Problem

给定一个长度为 $m$ 的数组 $b$。您可以执行以下任意次操作（可能是零次）：

选择两个不同的索引 $i$ 和 $j$，其中 $1\le i<j\le m$ 且 $b_i$ 为偶数，将 $b_i$ 除以 $2$ 并将 $b_j$ 乘以 $2$。
您的任务是在执行任意数量的此类操作后最大化数组的总和。由于它可能很大，请输出此总和模数 $10^9+7$。

由于这道题太简单了，给您一个长度为 $n$ 的数组 $a$，您需要对 $a$ 的每个前缀进行求解。

换句话说，表示在执行任意数量的 $f(b)$ 这样的操作后 $b$ 的最大和，您需要分别输出 $f([a_1])$、$f([a_1,a_2])$、…、$f([a_1,a_2,\dots ,a_n])$ 模数 $10^9+7$。

输入
第一行包含一个整数 $t$ （$1\le t\le 10^4$） — 测试用例的数量。

每个测试用例的第一行包含一个整数 $n$ （$1\le n\le 2\cdot 10^5$） — $a$ 的长度。

第二行包含 $n$ 个整数 $a_1,a_2,\dots ,a_n$ （$1\le a_i\le 10^9$） — 数组 $a$ 的起始值。

保证所有测试用例的 $n$ 之和不超过 $2\cdot 10^5$。

输出
对于每个测试用例，输出 $n$ 个整数，表示 $a$ 模 $10^9+7$ 的每个前缀的答案。

示例
输入

3
10
1 2 3 4 5 6 7 8 9 10
11
1 6 9 4 7 4 4 10 3 2 3
4
527792568 502211460 850237282 374773208

输出

1 3 8 13 46 59 126 149 1174 1311 
1 7 22 26 70 74 150 1303 1306 1308 1568 
527792568 83665723 399119771 773892979 

注意
对于第一个示例中的每个前缀，经过操作后可能的数组是：

$[1]$ 和总和为 $1$；
$[1,2]$ 和总和为 $3$；
$[1,1,6]$ 和总和为 $8$；
$[1,1,3,8]$ 和总和为 $13$；
$[1,1,3,1,40]$ 和总和为 $46$；
$[1,1,3,1,5,48]$ 和总和为 $59$；
$[1,1,3,1,5,3,112]$ 和总和为 $126$；
$[1,1,3,1,5,3,7,128]$ 和总和为 $149$；
$[1,1,3,1,5,3,7,1,1152]$ 和总和为 $1174$；
$[1,1,3,1,5,3,7,1,9,1280]$ 和总和为 $1311$。

解题思路

由于乘法的增长速度很快，所以最优的操作一定是将区间内的其它$2$因子尽量挪到一起。

我们可以先将$a$中所有元素的$2$因子给拆出来。

然后使用单调栈维护$[1,i-1]$的区间最大值$a_t$，如果$a_t<a_i$，我们肯定是把$a_t$的所有$2$因子挪到$a_i$身上带来的贡献更多。

代码实现

const ll mod = 1e9 + 7;

ll qmi(ll x, ll k, ll p = mod)
{
    ll res = 1;
    while (k)
    {
        if (k & 1)
            res = res * x % p;
        x = x * x % p;
        k >>= 1;
    }
    return res;
}
ll cal(ll v, ll k)
{
    ll res = v;
    while (k)
    {
        res <<= 1;
        // 防止溢出
        if (res > inf)
            return inf;
        k--;
    }
    return res;
}
void solve()
{
    int n;
    cin >> n;
    vl a(n + 1);
    vl cnt(n + 1);
    for (int i = 1; i <= n; i++)
    {
        cin >> a[i];
        while (a[i] % 2 == 0)
        {
            a[i] /= 2;
            cnt[i]++;
        }
    }

    ll sum = 0;
    vi stk;
    for (int i = 1; i <= n; i++)
    {
        // 将a[i]还原后加入sum
        sum = (sum + a[i] * qmi(2, cnt[i]) % mod) % mod;
        // 单调栈维护，区间最大区间和，如果将栈顶元素小于当前a[i],直接出栈
        while (!stk.empty() && a[stk.back()] < cal(a[i], cnt[i])) // cal为还原函数，注意要防止溢出
        {
            int t = stk.back();
            // 将栈顶的2因子全部挪到a[i]上
            sum = (sum - a[t] * qmi(2, cnt[t]) % mod + a[t] + mod) % mod;
            sum = (sum - a[i] * qmi(2, cnt[i]) % mod + a[i] * qmi(2, cnt[t] + cnt[i]) % mod + mod) % mod;
            cnt[i] += cnt[t];
            stk.pop_back();
        }
        stk.eb(i);
        cout << sum << " \n"[i == n];
    }
}

---

E. Monster

天哪，这个原神boss太难了。幸好只用 4.99$ 就可以充值 6 个硬币。我应该小心，不要花太多钱，以免我妈妈抓到我……

你正在用一把伤害为 $d$ 的武器与一个生命值为 $z$ 的怪物战斗。最初， $d=0$ 。您可以执行以下操作。

增加 $d$ — 你的武器的伤害 $1$ ，花费 $x$ 个硬币。
攻击怪物，造成 $d$ 伤害并花费 $y$ 个硬币。
您不能连续执行第一个操作超过 $k$ 次。

找出击败怪物所需的最少硬币数量，至少造成 $z$ 点伤害。

输入
第一行包含一个整数 $t$ （$1\le t\le 100$） — 测试用例的数量。
每个测试用例的唯一一行包含 $4$ 个整数 $x$、$y$、$z$ 和 $k$ （$1\le x,y,z,k\le 10^8$） — 第一个操作的成本、第二个操作的成本、怪物的生命值以及第一个操作的限制。

输出
对于每个测试用例，输出击败怪物所需的最少硬币数量。

示例
输入

4
2 3 5 5
10 20 40 5
1 60 100 10
60 1 100 10

输出

12
190
280
160

提示
在第一个测试用例中，$x=2$，$y=3$，$z=5$，$k=5$。这是一个实现最低成本 $12$ 个硬币的策略：

• 增加伤害 $1$，花费 $2$ 个硬币。
• 增加伤害 $1$，花费 $2$ 个硬币。
• 增加伤害 $1$，花费 $2$ 个硬币。
• 攻击怪物，造成 $3$ 伤害，花费 $3$ 个硬币。
• 攻击怪物，造成 $3$ 伤害，花费 $3$ 个硬币。

你造成了总共 $3+3=6$ 伤害，击败了生命值为 $5$ 的怪物。你使用的硬币总数是 $2+2+2+3+3=12$ 个硬币。

在第二个测试用例中，$x=10$，$y=20$，$z=40$，$k=5$。这是一个实现最低成本 $190$ 个硬币的策略：

• 增加伤害 $5$，花费 $5\cdot x=50$ 个硬币。
• 攻击怪物一次，造成 $5$ 伤害，花费 $20$ 个硬币。
• 增加伤害 $2$，花费 $2\cdot x=20$ 个硬币。
• 攻击怪物 $5$ 次，造成 $5\cdot 7=35$ 伤害，花费 $5\cdot y=100$ 个硬币。

你造成了总共 $5+35=40$ 伤害，击败了生命值正好为 $40$ 的怪物。你使用的硬币总数是 $50+20+20+100=190$ 个硬币。

解题思路

暴力枚举增加伤害的最终次数，二分查找最小代价，具体实现可以看代码

代码实现

// 设置枚举次数，设置到不会超时即可，时间复杂度为Nlog(n)，log(n)约为14，N可以设置成1e7
const int N = 1e7 + 5;

void solve()
{
    ll x, y, z, k;
    cin >> x >> y >> z >> k;

    ll ans = infll;

    // 遍历可能的增加伤害操作的次数i
    for (ll i = 0; i <= z / k + 1 && i < N; i++)
    {
        ll temp = infll;

        // 计算剩余需要造成的伤害
        ll remain = z - i * (i + 1) / 2 * k - 1;

        // 遍历当前增加伤害后的伤害值l
        for (ll l = i * k + 1; l <= i * k + k;)
        {
            // 初始化r
            ll r = i * k + k;

            // 计算在当前l下，剩余伤害可以被多少个l整除
            ll cnt = remain / l;

            // 如果cnt大于0，更新r为remain / cnt，确保r不超过i*k + k
            if (cnt > 0)
                r = remain / cnt;
            r = min(r, i * k + k);

            // 计算增加伤害的总成本
            ll sum = l * x;

            // 计算可以进行多少次攻击操作
            ll num = (l - 1) / k;

            // 增加攻击操作的成本
            sum += num * y;

            // 计算剩余需要造成的伤害
            ll re = z - num * (num + 1) / 2 * k;

            // 如果还有剩余的伤害，增加相应次数的攻击操作成本
            if (re > 0)
                sum += ((re - 1) / l + 1) * y;

            // 更新当前最小成本
            temp = min(temp, sum);

            // 移动左指针到r的下一个位置
            l = r + 1;
        }
        // 更新答案
        ans = min(ans, temp);
    }
    cout << ans << endl;
}

---

打表场，C题陆陆续续折腾了一个多小时，在那里打表找规律，人快麻了。

C题浪费太多时间了，D写完了但是取模有点问题没来的及调完。哎，最近做的最不顺畅的一场。