Codeforces Round 983 div2 个人题解(A~E)_codeforces round 983 (div. 2) e-优快云博客

本文链接：https://blog.youkuaiyun.com/Lazy_ChessPlayer/article/details/143444622

Codeforces Round 983 div2 个人题解(A~D)

Dashboard - Codeforces Round 983 (Div. 2) - 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. Circuit

Alice 刚刚制作了一个带有 $n$ 个灯和 $2 n$ 个开关的电路。每个组件（灯或开关）都有两种状态：开或关。灯和开关的排列方式如下：

每个灯连接到恰好两个个开关。
每个开关连接到恰好一个灯。不知道每个开关连接到哪个灯。
当所有开关都关闭时，所有灯也会关闭。
如果切换开关（从开到关，或反之亦然），则连接到它的灯的状态也会切换。

Alice 把只显示 $2 n$ 个开关状态的电路带给她的妹妹 Iris，并给了她一个谜语：可以打开的灯的最小和最大数量是多少？

Iris 非常了解她妹妹的滑稽动作，她只用了一秒钟就给了 Alice 一个正确的答案。你能做到同样的事情吗？

输入
每个测试由多个测试用例组成。第一行包含一个整数 $t$ ( $\leq t \leq 500$ ) — 测试用例的数量。测试用例的描述如下。

每个测试用例的第一行包含一个整数 $n$ ( $\leq n \leq 50$ ) — 电路中的灯的数量。

每个测试用例的第二行包含 $2 n$ 个整数 $a_1,a_2,…,a_{2n}$ ( $\leq a_i \leq 1$ ) — 电路中开关的状态。 $a_i=0$ 表示第 $i$ 个开关关闭， $a_i=1$ 表示第 $i$ 个开关打开。

输出
对于每个测试用例，输出两个整数——分别表示可以打开的灯的最小数量和最大数量。

示例
输入

5
1
0 0
1
0 1
1
1 1
3
0 0 1 0 1 0
3
0 1 1 1 0 0

输出

提示
在第一个测试用例中，电路中只有一个灯，且没有开关开启，因此灯肯定是关闭的。

在第二个测试用例中，电路中只有一个灯，但与之连接的一个开关是开启的，因此灯是开启的。

在第三个测试用例中，电路中只有一个灯，且两个开关都是开启的，因此灯是关闭的，因为它被切换了两次。

在第四个测试用例中，为了没有灯开启，开关可以这样排列：

开关 $1$ 和开关 $4$ 连接到灯 $1$ 。由于两个开关都关闭，灯 $1$ 也关闭。
开关 $2$ 和开关 $6$ 连接到灯 $2$ 。由于两个开关都关闭，灯 $2$ 也关闭。
开关 $3$ 和开关 $5$ 连接到灯 $3$ 。两个开关都是开启的，因此灯 $3$ 被切换了两次，从初始关闭状态保持关闭。
而为了开启 $2$ 个灯，开关可以这样排列：

开关 $1$ 和开关 $2$ 连接到灯 $1$ 。由于两个开关都关闭，灯 $1$ 也关闭。
开关 $3$ 和开关 $4$ 连接到灯 $2$ 。由于开关 $3$ 是开启的而开关 $4$ 是关闭的，灯 $2$ 从初始关闭状态被切换了一次，因此它是开启的。
开关 $5$ 和开关 $6$ 连接到灯 $3$ 。由于开关 $5$ 是开启的而开关 $6$ 是关闭的，灯 $3$ 从初始关闭状态被切换了一次，因此它是开启的。

解题思路

读题可知一个01对应一个开着的灯，而00和11对应着关着的灯。

所以如果1为偶数，则最小开灯数为 $0$ ，1和0内部之间互相匹配，否则为 $1$ 。

最大开灯数则为 $\min(\text{cnt0},\text{cnt1})$

代码实现

void solve()
{
    int n;
    cin >> n;
    vi a(n * 2);
    int cnt0 = 0;
    int cnt1 = 0;
    for (int i = 0; i < n * 2; i++)
    {
        cin >> a[i];
        if (a[i] == 0)
            cnt0++;
        else
            cnt1++;
    }
    cout << (cnt1 & 1) << " " << min(cnt0, cnt1) << endl;
}

B. Medians

给定一个数组 $ a = [1, 2, \ldots, n] $，其中 $ n $ 为奇数，以及一个整数 $ k $。

您的任务是选择一个奇数正整数 $ m $，并将 $ a $ 拆分为 $ m $ 个子数组 $ b_1, b_2, \ldots, b_m $，使得：

数组 $ a $ 的每个元素都只属于一个子数组。
对于所有 $ 1 \leq i \leq m $， $ |b_i| $ 为奇数，即每个子数组的长度为奇数。
$ \text{median}([\text{median}(b_1), \text{median}(b_2), \ldots, \text{median}(b_m)]) = k $，即所有子数组中位数的数组中位数必须等于 $ k $。$ \text{median}© $ 表示数组 $ c $ 的中位数。

输入

每个测试由多个测试用例组成。第一行包含一个整数 $ t $ （$ 1 \leq t \leq 5000 $）——测试用例数。测试用例说明如下。

每个测试用例的第一行包含两个整数 $ n $ 和 $ k $ （$ 1 \leq k \leq n < 2 \cdot 10^5 $，且 $ n $ 为奇数）——数组 $ a $ 的长度和所有子数组中位数数组的期望中位数。

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

输出
对于每个测试用例：

如果没有合适的分区，则单行输出 $- 1$ 。
否则，在第一行输出一个奇数整数 $ m $ （$ 1 \leq m \leq n $），在第二行输出 $ m $ 个不同的整数 $ p_1, p_2, p_3, \ldots, p_m $ （$ 1 = p_1 < p_2 < p_3 < \ldots < p_m \leq n $）——表示每个子数组的左边界。具体来说，对于有效答案 $ [p_1, p_2, \ldots, p_m] $：

$ b_1 = [a_{p_1}, a_{p_1 + 1}, \ldots, a_{p_2 - 1}] $
$ b_2 = [a_{p_2}, a_{p_2 + 1}, \ldots, a_{p_3 - 1}] $
$\ldots$
$ b_m = [a_{p_m}, a_{p_m + 1}, \ldots, a_n] $

如果有多个解决方案，您可以输出其中任何一个。

示例
输入

输出

1
1
3
1 2 3
-1
5
1 4 7 10 13

提示
在第一个测试用例中，给定的分区有 $ m = 1 $ 且 $ b_1 = [1] $。显然 $ \text{median}([\text{median}([1])]) = \text{median}([1]) = 1 $。

在第二个测试用例中，给定的分区有 $ m = 3 $ 且：

$ b_1 = [1] $
$ b_2 = [2] $
$ b_3 = [3] $

因此， $ \text{median}([\text{median}([1]), \text{median}([2]), \text{median}([3])]) = \text{median}([1, 2, 3]) = 2 $。

在第三个测试用例中，对于 $ k = 3 $ 并没有有效的分区。

在第四个测试用例中，给定的分区有 $ m = 5 $ 且：

$ b_1 = [1, 2, 3] $
$ b_2 = [4, 5, 6] $
$ b_3 = [7, 8, 9] $
$ b_4 = [10, 11, 12] $
$ b_5 = [13, 14, 15] $

因此， $ \text{median}([\text{median}([1, 2, 3]), \text{median}([4, 5, 6]), \text{median}([7, 8, 9]), \text{median}([10, 11, 12]), \text{median}([13, 14, 15])]) = \text{median}([2, 5, 8, 11, 14]) = 8 $。

解题思路

由于分区长度任意，我们考虑把 $k$ 单独拎出来放在最中间的分区，然后再左右两侧划分相同数量的分区。

$k$ 为奇数，我们可以 $[1, 1] [2, k - 1] [k, k] [k + 1, k + 1] [k + 2, n]$ 划分。

$k$ 为偶数，我们可以 $[1, k - 1] [k] [k + 1, n]$ 划分

还要特判一下 $k = 1 ， k = n$ 和 $k$ 刚好为中位数的情况

代码实现

void solve()
{
    ll n, k;
    cin >> n >> k;
    if (k == (n + 1) / 2)
    {
        cout << "1\n1\n";
        return;
    }
    if (k == 1 || k == n)
    {
        cout << "-1\n";
        return;
    }
    if (k & 1)
    {
        cout << "5\n";
        cout << 1 << " " << 2 << " " << k << " " << k + 1 << " " << k + 2 << "\n";
    }
    else
    {
        cout << "3\n";
        cout << 1 << " " << k << " " << k + 1 << "\n";
    }
}

C. Trinity

您将获得一个包含 $ n $ 个元素 $ a_1,a_2,…,a_n $ 的数组 $ a $。

您可以执行以下操作任意次数（可能是 0）：

选择两个整数 $ i $ 和 $ j $，其中 $ 1 \leq i,j \leq n $，并分配 $ a_i := a_j $。找出使数组 $ a $ 满足条件所需的最少操作数：

对于每个成对不同的索引三元组 $(x, y, z)$ （$ 1 \leq x,y,z \leq n $， $ x \neq y $， $ y \neq z $， $ x \neq z $），存在一个非退化三角形，其边长为 $ a_x $、$ a_y $ 和 $ a_z $，即 $ a_x + a_y > a_z $、$ a_y + a_z > a_x $ 和 $ a_z + a_x > a_y $。

输入

每个测试由多个测试用例组成。第一行包含一个整数 $ t $ （$ 1 \leq t \leq 10^4 $）——测试用例的数量。测试用例的描述如下。

每个测试用例的第一行包含一个整数 $ n $ （$ 3 \leq n \leq 2 \cdot 10^5 $）——数组 $ a $ 中的元素数量。

每个测试用例的第二行包含 $ n $ 个整数 $ a_1,a_2,…,a_n $ （$ 1 \leq a_i \leq 10^9 $）——数组 $ a $ 的元素。

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

输出
对于每个测试用例，输出一个整数——所需的最少操作数。

示例
输入

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

输出

提示
在第一个测试用例中，可以进行以下操作：

赋值 $ a_1 := a_4 = 4 $，数组变为 $ [4,2,3,4,5,6,7] $。
赋值 $ a_2 := a_5 = 5 $，数组变为 $ [4,5,3,4,5,6,7] $。
赋值 $ a_7 := a_1 = 4 $，数组变为 $ [4,5,3,4,5,6,4] $。

可以证明，最终数组中任意三元组的元素都能形成一个非退化三角形，且不可能用少于 3 次操作得到答案。

在第二个测试用例中，我们可以赋值 $ a_1 := a_2 = 3 $，使数组 $ a = [3,3,2] $。

在第三个测试用例中，由于 3、4 和 5 是有效的三角形边长，因此不需要对数组进行任何操作。

解题思路

观察题目要求和三角形的性质发现，我们实际上是在求一个极差小于最小值的区间，即 $\min\times2>\max$ 。

所以我们可以先给数组排个序，枚举最小值，然后二分查找最大值，我们就得到了所需的区间。

但是！！！

这种做法忽略了最小值只有一个的情况，如果最小值只有一个且次小值加最小值大于最大值，也是可行的。

所以，我们应该枚举最小值和次小值，然后二分查找小于他们之和的最大值，所找到的区间即为三角形可行区间。

区间外的元素就是我们需要操作的元素。

代码实现

void solve()
{
    int n;
    cin >> n;
    vector<ll> a(n); // 注意a的范围为1e9，最小值和次值相加时可能会溢出
    for (int i = 0; i < n; i++)
    {
        cin >> a[i];
    }
    sort(all(a));
    int ans = inf;
    for (int i = 1; i < n; i++)
    {
        int p = lower_bound(all(a), a[i] + a[i - 1]) - a.begin();
        ans = min(ans, n - p + i - 1);
    }
    cout << ans << endl;
}

D. Genokraken

这是一个交互式问题。

清理完水边区域后，Gretel 发现了一个名为 Genokraken 的怪物，她将其控制起来用于科学研究。

怪物的神经系统可以构造为一棵由 $ n $ 个节点组成的树，编号从 $ 0 $ 到 $ n−1 $，以节点 $ 0 $ 为根。

Gretel 的目标是了解怪物神经系统的确切结构——更具体地说，她想知道树的值 $ p_1,p_2,…,p_{n−1} $，其中 $ p_i $ （$ 0 \leq p_i < i $）是节点 $ i $ （$ 1 \leq i \leq n−1 $）的直接父节点。

她不知道节点的具体放置方式，但她知道一些方便的事实：

如果我们删除根节点 $ 0 $ 和所有相邻边，这棵树将变成仅由路径组成的森林。最初与节点 $ 0 $ 相邻的每个节点将成为某条路径的终点。
节点的索引方式为，如果 $ 1 \leq x \leq y \leq n−1 $，则 $ p_x \leq p_y $。
节点 $ 1 $ 恰好有两个相邻节点（包括节点 $ 0 $）。

Gretel 可以对包含单元进行查询：

“? a b”（$ 1 \leq a,b < n $，$ a \neq b $）——单元将检查节点 $ a $ 和 $ b $ 之间的简单路径是否包含节点 $ 0 $。但是，为了避免过度刺激生物而导致意外后果，Gretel 最多希望查询 $ 2n−6 $ 次。

输入

每个测试由多个测试用例组成。第一行包含一个整数 $ t $ （$ 1 \leq t \leq 500 $）——测试用例的数量。测试用例的描述如下。

每个测试用例的第一行包含一个整数 $ n $ （$ 4 \leq n \leq 10^4 $）——Genokraken神经系统中的节点数。

保证所有测试用例的 $ n $ 之和不超过 $ 10^4 $。

交互

对于每个测试用例，交互从读取整数 $ n $ 开始。

然后您可以进行以下类型的查询：

“? a b”（不带引号）（$ 1 \leq a,b < n $，$ a \neq b $）。查询后，读取一个整数 $ r $——查询的答案。您最多可以使用 $ 2n−6 $ 个此类查询。

如果节点 $ a $ 和 $ b $ 之间的简单路径不包含节点 $ 0 $，您将得到 $ r=0 $。
如果节点 $ a $ 和 $ b $ 之间的简单路径包含节点 $ 0 $，您将得到 $ r=1 $。
如果您进行了超过 $ 2n−6 $ 次查询或进行了无效查询，您将得到 $ r=−1 $。您需要在此之后终止以获得“错误答案”判决。

当您找出结构时，以“! $ p_1 \ p_2 \ \ldots \ p_{n−1} $”（不带引号）格式输出一行，其中 $ p_i $ （$ 0 \leq p_i < i $）表示节点 $ i $ 的直接父节点的索引。此查询不计入 $ 2n−6 $ 查询限制。

解决一个测试用例后，程序应立即转到下一个测试用例。解决所有测试用例后，程序应立即终止。

示例

输入

输出

? 2 3
! 0 0 1
? 2 3
? 2 4
! 0 0 1 2
! 0 0 0 1 3 5 6 7

提示
在第一个测试用例中，Genokraken 的神经系统形成了以下树：

对“? 2 3”的答案是 $ 1 $。这意味着节点 $ 2 $ 和 $ 3 $ 之间的简单路径包含节点 $ 0 $。

在第二个测试用例中，Genokraken 的神经系统形成了以下树：

对“? 2 3”的答案是 $ 1 $。这意味着节点 $ 2 $ 和 $ 3 $ 之间的简单路径包含节点 $ 0 $。

对“? 2 4”的答案是 $ 0 $。这意味着节点 $ 2 $ 和 $ 4 $ 之间的简单路径不包含节点 $ 0 $。

解题思路

说人话的题意：

给了你一棵特殊的树，其节点编号为 $0\sim n-1$ ，根节点为 $0$ 。

有3个性质

除了根节点外，其它节点最多只有一个子节点。
如果节点 $u$ 的编号小于 $v$ 的编号，即 $u < v$ ，它们的父亲 $p_u$ 和 $p_v$ 的关系为 $p_u\le p_v$ 。
$1$ 固定为根节点的一个子节点。

如果我们把根节点下的各个子树称为链，每次可以询问 $a$ 和 $b$ 是否不在同一条链上

花费最多 $2 n - 6$ 次询问，找出除根以外的节点的父节点

思路

我们称根节点的所有子节点为开始节点，可以得到三个推论：

开始节点是连续的，即开始节点的编号为 $[1, m]$ 。

假设其不连续，设不连续的那个点编号为 $x$ ，则$p_x \in [1,x-1] $，可知$ p_{x+1}=0 $，则$ p_{x+1}\lt p_{x}$，违反了性质2
每条链上的点随深度递增的。
综合上面两个性质，我们可以得出，同一深度的点，所在链开始节点小的点的编号小于开始节点大的点的编号

据此，我们可以很轻易的想出询问方式。

首先枚举 $2\sim n-1$ 与 $1$ 一起进行询问，如果得到的是 $1$ 说明该点也是开始节点。如果询问 $1, m$ 得到的是 $0$ ，说明开始节点为 $[1, m - 1]$ ，且由推论3可得 $p_m=1$ 。

接着我们使用类似 $\text{bfs}$ 的思路枚举剩下的节点 $i\in[m+1,n-1]$ ，我们设 $i$ 可能的父节点为 $j$ ， $j$ 初始为2。如果询问 $i, j$ 得到的是 $0$ ，说明 $p_i=j$ ， $i$ 和 $j$ 都要加一，因为一个节点最多只能由一个子节点，否则 $j$ 加一。

代码实现

int query(int a, int b)
{
    printf("? %d %d\n", a, b);
    fflush(stdout);
    int x;
    scanf("%d", &x);
    return x;
}

void answer(const vector<int> &v)
{
    printf("!");
    for (int i = 1; i < v.size(); i++)
    {
        printf(" %d", v[i]);
    }
    printf("\n");
    fflush(stdout);
}
void solve()
{
    int n;
    scanf("%d", &n);
    vector<int> p(n);
    int i = 1;
    int m = 2;
    while (query(1, m))
    {
        p[m] = 0;
        m++;
    }
    p[m] = 1;
    int j = 2;
    for (int i = m + 1; i < n; i++)
    {
        while (query(i, j))
        {
            j++;
        }
        p[i] = j++;
    }
    answer(p);
}