Codeforces Round #738 (Div. 2) 题解

最新推荐文章于 2022-04-21 21:12:51 发布
最新推荐文章于 2022-04-21 21:12:51 发布
阅读量161 收藏
点赞数 1
分类专栏： 题解 比赛 算法 文章标签： 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/foxreign/article/details/119742701
版权
题解 同时被 3 个专栏收录
8 篇文章 0 订阅
订阅专栏
比赛
8 篇文章 0 订阅
订阅专栏
算法
8 篇文章 0 订阅
订阅专栏

旅行传送门

A. Mocha and Math

题意：给你一个序列，你可以任意次地进行如下操作：

选择一个任意的区间 [ l , r ] [l,r] [l,r] ，对于区间内的所有值，用 a l + i a_{l+i} al+i​ & a r − i a_{r−i} ar−i​ 替换 a l + i a_{l+i} al+i​

求序列最小化后的最大值。

题目分析：我们不妨考虑&的性质，两个数相与，只有在它们的二进制表示中该位均为1时，该位才会为1，即 a a a & b b b ≤ \leq ≤ a , b a,b a,b ，因此我们的目标就是要让答案的二进制每一位尽可能为0，那么将整个序列都相与即为所求。

AC代码：

#include <bits/stdc++.h>
#define rep(i, x, y) for (register int i = (x); i <= (y); i++)
#define down(i, x, y) for (register int i = (x); i >= (y); i--)

int t, n, ans, x;

inline int read()
{
    int x = 0, f = 1;
    char ch = getchar();
    while (ch < '0' || ch > '9')
    {
        if (ch == '-')
            f = -1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9')
    {
        x = x * 10 + ch - '0';
        ch = getchar();
    }
    return x * f;
}

int main(int argc, char const *argv[])
{
    t = read();
    while (t--)
    {
        n = read();
        ans = read();
        rep(i, 2, n) x = read(), ans &= x;
        printf("%d\n", ans);
    }
    return 0;
}

B. Mocha and Red and Blue

题意：给你一个由"B、R、?"三种字符组成的字符串，将其中的?用B或R代替，相邻的字符会使不完美度+1，输出最小化不完美度时的字符串

题目分析：贪心地选择每个已经上色的字符，并使它相邻两侧的?涂上与它不同的颜色，然后再次选择新上色的字符，重复执行上述操作，我们可以利用队列来实现算法。最后再遍历一遍字符串，给仍未上色的字符周期性地用B、R代替。

AC代码：

#include <bits/stdc++.h>
#define rep(i, x, y) for (register int i = (x); i <= (y); i++)
#define down(i, x, y) for (register int i = (x); i >= (y); i--)

inline int read()
{
    int x = 0, f = 1;
    char ch = getchar();
    while (ch < '0' || ch > '9')
    {
        if (ch == '-')
            f = -1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9')
    {
        x = x * 10 + ch - '0';
        ch = getchar();
    }
    return x * f;
}

//B is 1 , R is -1.
int main(int argc, char const *argv[])
{
    int t = read();
    while (t--)
    {
        std::queue<int> q;
        int n = read();
        char s[105];
        int vis[105];
        memset(vis, 0, sizeof(vis));
        scanf("%s", s + 1);
        rep(i, 1, n)
        {
            if (s[i] != '?')
            {
                vis[i] = (s[i] == 'B' ? 1 : -1);
                q.push(i);
            }
        }
        while (!q.empty())
        {
            int pos = q.front();
            q.pop();
            if (vis[pos] == 1)
            {
                if (!vis[pos + 1] && pos + 1 <= n)
                {
                    vis[pos + 1] = -1;
                    q.push(pos + 1);
                }
                if (!vis[pos - 1] && pos - 1 > 0)
                {
                    vis[pos - 1] = -1;
                    q.push(pos - 1);
                }
            }
            else if (vis[pos] == -1)
            {
                if (!vis[pos + 1] && pos + 1 <= n)
                {
                    vis[pos + 1] = 1;
                    q.push(pos + 1);
                }
                if (!vis[pos - 1] && pos - 1 > 0)
                {
                    vis[pos - 1] = 1;
                    q.push(pos - 1);
                }
            }
        }
        int a = 1, b = -1;
        rep(i, 1, n) if (!vis[i]) vis[i] = a, std::swap(a, b);
        rep(i, 1, n)
        {
            if (vis[i] == 1)
                putchar('B');
            else if (vis[i] == -1)
                putchar('R');
        }
        puts("");
    }
    return 0;
}

C. Mocha and Hiking

题意：给你一张图，共有 2 n − 1 2n-1 2n−1 条边，其中 n − 1 n-1 n−1 条边是从 i i i 至 i − 1 i-1 i−1 ，另外 n n n 条边是从 i i i 至 n + 1 n+1 n+1 或从 n + 1 n+1 n+1 至 i i i，问是否存在一种方案使得可以遍历整张图。

题目分析：dfs会超时（血的教训），实际上无非就三种情况特判：

  • 点 n n n 能否到达点 n + 1 n+1 n+1
  • 点 n + 1 n+1 n+1 能到达点 1 1 1
  • 是否存在某个点 i i i 可以到达点 n + 1 n+1 n+1 并且从点 n + 1 n+1 n+1 可以回到点 i + 1 i+1 i+1

若三种情况都不满足，则不存在该方案

AC代码：

#include <bits/stdc++.h>
#define rep(i, x, y) for (register int i = (x); i <= (y); i++)
#define down(i, x, y) for (register int i = (x); i >= (y); i--)
const int maxn = 1e4 + 5;

int a[maxn];

inline int read()
{
    int x = 0, f = 1;
    char ch = getchar();
    while (ch < '0' || ch > '9')
    {
        if (ch == '-')
            f = -1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9')
    {
        x = x * 10 + ch - '0';
        ch = getchar();
    }
    return x * f;
}

int main(int argc, char const *argv[])
{
    int t = read();
    while (t--)
    {
        int n = read();
        rep(i, 1, n) a[i] = read();
        if (!a[n])
        {
            rep(i, 1, n + 1) printf("%d ", i);
            puts("");
            continue;
        }
        else if (a[1])
        {
            printf("%d ", n + 1);
            rep(i, 1, n) printf("%d ", i);
            puts("");
            continue;
        }
        else
        {
            int pos = -1;
            rep(i, 1, n) if (!a[i] && a[i + 1])
            {
                pos = i;
                break;
            }
            if (pos != -1)
            {
                rep(i, 1, pos)
                    printf("%d ", i);
                printf("%d ", n + 1);
                rep(i, pos + 1, n)
                    printf("%d ", i);
                puts("");
                continue;
            }
        }
        puts("-1");
    }
    return 0;
}

D1. Mocha and Diana (Easy Version)

题意：给你两张图，顶点数相同，初始边不同，在保证两张图是树形结构的情况下同时加边，问最多可以加多少条边，分别是哪些边。

题目分析：将已经连边的点放入同一个集合里，当我们要判断某两个点能否连边时，即看它们分别在两张图中是否都不属于同一个集合，因此可以用并查集维护，easy version n n n 的数据范围 ≤ 1000 \leq 1000 ≤1000 ，直接暴力枚举任意两点就好。

AC代码：

#include <bits/stdc++.h>
#define rep(i, x, y) for (register int i = (x); i <= (y); i++)
#define down(i, x, y) for (register int i = (x); i >= (y); i--)
#define pii pair<int, int>
using namespace std;
const int maxn = 1005;

int t, n, m1, m2, ans, cnt1, cnt2;
int fa1[maxn], fa2[maxn];
vector<pii> vec;

inline int read()
{
    int x = 0, f = 1;
    char ch = getchar();
    while (ch < '0' || ch > '9')
    {
        if (ch == '-')
            f = -1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9')
    {
        x = x * 10 + ch - '0';
        ch = getchar();
    }
    return x * f;
}

void init()
{
    ans = cnt1 = cnt2 = 0;
    rep(i, 0, n) fa1[i] = fa2[i] = i;
}

inline int find1(int x) { return x == fa1[x] ? x : fa1[x] = find1(fa1[x]); }

inline int find2(int x) { return x == fa2[x] ? x : fa2[x] = find2(fa2[x]); }

void merge1(int x, int y)
{
    int fx = find1(x), fy = find1(y);
    if (fx == fy)
        return;
    fa1[fx] = fy;
    ++cnt1;
}

void merge2(int x, int y)
{
    int fx = find2(x), fy = find2(y);
    if (fx == fy)
        return;
    fa2[fx] = fy;
    ++cnt2;
}

int main(int argc, char const *argv[])
{
    n = read(), m1 = read(), m2 = read();
    init();
    int x, y;
    rep(i, 1, m1)
    {
        x = read(), y = read();
        merge1(x, y);
    }
    rep(i, 1, m2)
    {
        x = read(), y = read();
        merge2(x, y);
    }
    rep(i, 1, n)
    {
        if (cnt1 == n - 1 || cnt2 == n - 1)
            break;
        rep(j, 1, n)
        {
            int fx1 = find1(i), fy1 = find1(j);
            int fx2 = find2(i), fy2 = find2(j);
            if ((fx1 != fy1) && (fx2 != fy2))
            {
                ++ans;
                merge1(i, j), merge2(i, j);
                vec.push_back(make_pair(i, j));
            }
        }
    }
    printf("%d\n", ans);
    int nn = vec.size() - 1;
    rep(i, 0, nn) printf("%d %d\n", vec[i].first, vec[i].second);
    return 0;
}

D2. Mocha and Diana (Hard Version)

题目分析：hard version n n n 的数据范围显然不允许我们使用 n 2 n^2 n2 的算法，官方题解用的是启发式合并，其实评论区神犇给出了一种更优的解决方式：

首先任选一点 i i i ，尝试将 i i i 与其它所有点连边，设以点 i i i 为中心的大集合为 U U U ，此时会出现三种情况：

  • 两张图中，均有 j ∉ U j \notin U j∈/​U ，在点 i i i 与 点 j j j 间加一条边，并将点 j j j 丢进 U U U 中

  • 在第一、二张图中，分别有 j ∉ U 1 j \notin U1 j∈/​U1 与 j ∈ U 2 j \in U2 j∈U2 ，我们将 j j j 记录下来并存入堆栈 v 1 v1 v1 中

  • 与上述情况相反，我们将 j j j 记录下来并存入堆栈 v 2 v2 v2 中

接下来我们要做的就是匹配这些没有进入“大集合”中的点:

  • 如果 v 1 v1 v1 顶部的点在大集合 U 1 U1 U1 中，则将其删除

  • 如果 v 2 v2 v2 顶部的点在大集合 U 2 U2 U2 中，则将其删除

  • 否则，在 v 1 v1 v1 顶部的点和 v 2 v2 v2 顶部的点之间添加一条边。

感性地理解下，就是先找到一个点，把它能连上的边全连了，然后再根据两张图的情况在剩下的点间连边

可以证明该算法的正确性，且其复杂度近乎为 O ( n + m ) O(n+m) O(n+m)

AC代码：

#include <bits/stdc++.h>
#define rep(i, x, y) for (register int i = (x); i <= (y); i++)
#define down(i, x, y) for (register int i = (x); i >= (y); i--)
#define pii std::pair<int, int>
#define mp std::make_pair
const int maxn = 1e5 + 10;

int n, m1, m2, x, y, fa1[maxn], fa2[maxn];
std::vector<int> v1, v2;
std::vector<pii> ans;

inline int read()
{
    int x = 0, f = 1;
    char ch = getchar();
    while (ch < '0' || ch > '9')
    {
        if (ch == '-')
            f = -1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9')
    {
        x = x * 10 + ch - '0';
        ch = getchar();
    }
    return x * f;
}

inline int find1(int x) { return x == fa1[x] ? x : fa1[x] = find1(fa1[x]); }

inline int find2(int x) { return x == fa2[x] ? x : fa2[x] = find2(fa2[x]); }

void merge1(int x, int y)
{
    int fx = find1(x), fy = find1(y);
    if (fx == fy)
        return;
    fa1[fx] = fy;
}

void merge2(int x, int y)
{
    int fx = find2(x), fy = find2(y);
    if (fx == fy)
        return;
    fa2[fx] = fy;
}

int main(int argc, char const *argv[])
{
    n = read(), m1 = read(), m2 = read();
    rep(i, 1, n) fa1[i] = fa2[i] = i;
    rep(i, 1, m1)
    {
        x = read(), y = read();
        merge1(x, y);
    }
    rep(i, 1, m2)
    {
        x = read(), y = read();
        merge2(x, y);
    }
    rep(i, 2, n)
    {
        int fx1 = find1(1), fy1 = find1(i);
        int fx2 = find2(1), fy2 = find2(i);
        if (fx1 ^ fy1 && fx2 ^ fy2)
        {
            merge1(1, i), merge2(1, i);
            ans.push_back(mp(1, i));
        }
        if (fx1 ^ fy1)
            v1.push_back(i);
        if (fx2 ^ fy2)
            v2.push_back(i);
    }
    while (v1.size() && v2.size())
    {
        x = v1.back(), y = v2.back();
        int f1 = find1(1), f2 = find2(1);
        int fx = find1(x), fy = find2(y);
        if (fx == f1)
        {
            v1.pop_back();
            continue;
        }
        if (fy == f2)
        {
            v2.pop_back();
            continue;
        }
        merge1(x, y), merge2(x, y);
        ans.push_back(mp(x, y));
    }
    printf("%d\n", ans.size());
    while (ans.size())
    {
        printf("%d %d\n", ans.back().first, ans.back().second);
        ans.pop_back();
    }
    return 0;
}
FoXreign
关注
专栏目录
题解 Codeforces Round #814 (Div. 1/2)
im_zyINF的博客
08-17 386
Codeforces
Codeforces Round #787 (Div. 3)个人题解
weixin_51767904的博客
05-06 1088
Codeforces Round #787 (Div. 3)个人题解 Codeforces Round #787 (Div. 3) A. Food for Animals B. Make It Increasing C. Detective Task D. Vertical Paths E. Replace With the Previous, Minimize F. Vlad and Unfinished Business G. Sorting Pancakes
Codeforces Round #738 (Div. 2)
weixin_50909982的博客
08-19 183
前四个题就A题难想一点，别的读懂题就可以写出来。 结果这题卡我一个多小时 A. Mocha and Math 题意：给你一个序列，你可以对称的把区间里的aia_iai​替换成ai+la_{i+l}ai+l​ & ar−ia_{r-i}ar−i​,如上图。问你操作若干次之后序列中的最小值。 思路：首先了解&的性质,AAA & B<=min(A,B)B<=min(A,B)B<=min(A,B)，所以随着&操作的增加，值肯定是不断减少的，对于序列的某一个元素来说
Codeforces Round #738 (Div. 2)（A，B，C，D1，D2）
遗落之辉的博客
08-16 227
Codeforces Round #738 Div. 2A. Mocha and MathB. Mocha and Red and BlueC. Mocha and Hiking A. Mocha and Math 题目大意： 给出一个数组，你可以在任意大小的区间（大小不能为1）进行一个操作，区间元素与颠倒后的区间元素按位与， [ l , r ]; a[l]=a[l]&a[r] a[l+1]=a[l+1]&a[r-1]… 问经过任意次操作后数组中的最小值可能是多少 思路： 因为按位与的特性
Codeforces Round #726 (Div. 2)题解A-E1
Arctic_Clam的博客
06-19 514
A. Arithmetic Array 分析： 当sum大于n时，那么添加（sum-n）个0，当sum小于n时，只需要添加一个数即可。 #include <iostream> using namespace std; int main() { int t; cin >> t; while(t--) { int n; cin >> n; int sum = 0; for(int i = 0; i &l
Codeforces Round #664 (Div. 2)题解
Adrian099的博客
08-13 308
A Boboniu Likes to Color Balls 题意思路 : 给定四种颜色通过以下操作判断能否组成回文串 操作： 前三个减一 后一个加一 思路 : 判断奇数的个数 若和为奇数 则最多有一个奇数 若为偶数 0个 代码： #include<bits/stdc++.h> using namespace std; int c[4]; bool f(){ int sum1 = 0; int sum2 = 0; for(int i = 0; i < 4; i++){ sum
Codeforces Round #662 (Div. 2)题解
steven_pzx的博客
08-31 183
A题 解题思路： 从n为奇数开始写。 示例代码： #include<bits/stdc++.h> using namespace std; int main() { int t; cin >> t; while(t--) { long long n; cin >> n; cout << (n + 2) / 2 << endl; } } B题 解题思路： 构造。
Codeforces Round #738 (Div. 2)——C. Mocha and Hiking
LHBLL的博客
08-16 313
问题： Codeforces Round #738 (Div. 2)——C. Mocha and Hiking 传送 问题描述： 1. 已知 (i)~(i+1) 可行(1<=i<=n-1) 2. 给出 (i)~(n+1)的关系 (1<=i<=n) a[i]=0：(i)~(n+1)可行。 a[i]=1：(n+1)~(i) 可行 。 3. 遍历所有点一次。 输出路径。（不存在则输出-1） 思路分析： 考虑三种情况。 1.(n+1)~(1)~(2)...
Codeforces Round #738 (Div. 2)部分题解
山中一扶苏的博客
08-16 180
A 点击此处查看对应的题目. 本题涉及算法：位运算   本题的位运算操作可以无限次，且要将答案尽可能小，利用与运算的性质只要将所有值全部取&即可。（与运算的性质：两个数相与结果必然是0或是其中最小的值） 时间复杂度 O(n)O(n)O(n) #include<bits/stdc++.h> using namespace std; typedef long long ll; const int N = 110,INF = 1e9; int a[N]; int n; void solve(
Codeforces Round #738 (Div. 2) A~D1题解
pursuit的博客
08-16 412
文章目录A. Mocha and MathB. Mocha and Red and BlueC. Mocha and HikingD1. Mocha and Diana (Easy Version) A. Mocha and Math 题意 给你一个nnn元素的数组。你可以进行任意次操作选定区间[l,r][l,r][l,r]，使得a[l]=a[l]&a[r],....a[r]=[r]&a[l]a[l] = a[l]\& a[r],....a[r] = [r] \&a[l]
Codeforces Round #738 (Div. 2)题解全集
weixin_45948940的博客
08-17 189
emm作为验题人，首先感谢崔哥的邀请 test情况来看E是比D2要简单一点点的（（ 确信 前四题太过于简单。 emmm赛后已经过穿了，D2网友的神仙随机化写法太秀了。 Mocha and Math A题 其实&操作是会保留共同的1，那么只需要记录n个数的2进制位上哪一位是n个数共有的，就可以算出答案了。 int n; int cnt[33]; int main() { ios :: sync_with_stdio(false); cin.tie(0); int t;
Codeforces Round #738 (Div. 2)题解
m0_51275778的博客
08-17 114
A 题意：一个数组长度为nnn，对数组进行操作，选取区间aia_iai​到aja_jaj​对区间的数进行与操作ai+la_{i + l}ai+l​ = ai+la_{i + l}ai+l​ & ar−ia_{r - i}ar−i​这种操作可以作用任何数组中的数，最小化最大的数，答应这个值； 思路：&运算以后，aaa&bbb <= aaa(aaa > bbb)所以想要让最大值最小就让数组中最大的数&整个数组，就可以得到最小值. #include <bits/s
Codeforces Round #783 (Div. 2) A B C
weixin_52255583的博客
04-20 242
这个codeforce前三题都还行，D题直接gg 感觉和前三题差距太大了，还是太菜了 A题：思维 题目大意：给你一个n行m列的网格，你从位置（1，1）走到 位置 (n,m)的所有路径中，走的步数最少是多少 每一次可以选择四个方向走（上 下 左 右） 但是连续的两次不能走同一个方向 也就是说 假如你上一步走的方向是 向左，那目前这一步走的方向就不能 向左走，其他的方向都都可以 思路：因为（1，1）在左上方，(n,m) 在右下方 所以我们要尽可能 向下 向右走 或者 向右 向下走 如果 n > m的话我们
Codeforces Round #783 (Div. 2)(A~C)
m0_62289613的博客
04-20 354
Codeforces Round #783 (Div. 2)
Codeforces Round #783 (Div. 2)(D~F)
zppbugmaker的博客
04-21 599
文章目录D. Optimal PartitionE. Half Queen CoverF. Edge Elimination D. Optimal Partition 题意： 给你长度为nnn的数组aaa，将其划分为任意数量的连续子串，一个子串l∼rl \sim rl∼r的价值为 sign(∑i=lrai)∗(r−l+1)sign(\sum_{i = l}^{r}a_i)*(r-l+1)sign(∑i=lr​ai​)∗(r−l+1) 问可以划分出来的子串价值之和最大是多少 思路： 考虑dpdpdp,定义dp
Codeforces Round #783 (Div. 2) A-F
nth2000的博客
04-21 565
E. Half Queen Cover(待补充 构造动机不太理解) #include <iostream> #include <vector> #include <string> #include <set> #include <algorithm> #include <map> #include <queue> #include <chrono> #include <math.h> #includ
codeforces round #772 (div. 2)
最新发布
03-16
好的，Codeforces Round #772 (Div. 2) 是一场由Codeforces主办的在线编程竞赛。 该比赛的比赛链接为：https://codeforces.com/contest/772。 该比赛分为两个级别：Div.1和Div.2。 Div. 1级别通常比Div. 2级别更...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值