Codeforces Round #656 (Div. 3)

最新推荐文章于 2021-04-26 20:38:41 发布
最新推荐文章于 2021-04-26 20:38:41 发布
阅读量119 收藏
点赞数
分类专栏： ACM--比赛补题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_49959202/article/details/113703924
版权

文章目录

Codeforces Round #656 (Div. 3)

A. Three Pairwise Maximums

题意: 给定t个测试样例,每个测试样例给定x，y，z，需要找到a，b，c三个数，使得max(a, b)=x, max(a, c)=y, max(b, c)=z，输出a，b，c(顺序无所谓)，如果找不到输出NO。t~2e4, a、b、c~1e9
题解： max(a, b) = x, max(a, c) = y, 则max(a, b, c) = max(x, y)，同理max(a, b, c) = max(x, y) = max(y, z) = max(x, z)，则①x=y=z，②x < y = z。因此，只需要把x, y, z排序，最小的为x，中间的为y，最大的为z，判断y是否为z，不相等为NO，相等的话，输出x, x, y
代码:

#include <bits/stdc++.h>
 
using namespace std;
 
int main() {
    int a[3];
    int T ;
    cin >> T;
    while (T--) {
        for (int i = 0; i < 3; ++i) scanf("%d", &a[i]);
        sort(a, a + 3);
        if (a[1] != a[2]) {
            cout << "NO\n";
            continue;
        }
        cout << "YES\n";
        cout << a[0] << " " << a[0] << " " << a[1] << endl;
    }
    return 0;
}

B. Restore the Permutation by Merger

题意： t个测试样例，每个测试样例输入长度为2n的数组，该数组是由两个不改变相对位置的全排列数组merge而成的，每次要求输出原来的全排列数列。t ~ 400，n ~ 50
题解： 观察可以知道，同样的数字只需要取前一个出现的那个即可，因此，只需要扫一遍，如果这个数字没出现过，那么打印；如果没出现过，那么跳过
代码

#include <bits/stdc++.h>
 
using namespace std;

int main() {
    int T;
    cin >> T;
    while (T--) {
        int n;
        cin >> n;
        unordered_map<int, int> mp;
        for (int i = 1, x; i <= n * 2; ++i) {
            cin >> x;
            if (mp.count(x)) continue;
            cout << x << " " ;
            mp[x] = 1;
        }
        cout << endl;
    }
    return 0;
}

C. Make It Good

题意: 定义一个good数列：每次从该数列的头或者尾拿出一个数字，拿出来的数字是单调不减的。现在给定t个测试样例，每个测试样例给定一个长度为n的数列，问需要将长度为n的数列的删除前k个数字，使之变为good数列，这个k最小取多少？ ∑ n   2 e 5 \sum_{} n~2e5 ∑​n 2e5
题解: 对于任意两个数字x, y，如果这两个数字都是从前面拿出，那么需要x <= y；对于任意两个数字x和y，如果这两个数字都是从后面被拿出，那么需要x >= y，因此只需要倒着往前扫，找到类似小山坡的形状，即先增加后下降，一旦再次上升，即为到达边界。
代码:

#include <bits/stdc++.h>
 
using namespace std;
 
int const N = 2e5 + 10;
int a[N];
 
int main() {
    int T;
    cin >> T;
    while (T--) {
        int n;
        cin >> n;
        for (int i = 1; i <= n ; ++i) {
            scanf("%d", &a[i]);
        }
        if (n == 1) {
            cout << 0 << endl;
            continue;
        }
        int i = n - 1;
        while (a[i] >= a[i + 1] && i >= 1) i--;
        while (a[i] <= a[i + 1] && i >= 1) i--;
        cout << i << endl;
    }
    return 0;
}

D. a-Good String

题意： 定义一个’a’-good字符串为:

  1. 字符串长度为1，且只有一个字符’a’
  2. 字符串长度大于1，前半部分全为’a’，后半部分为’b’-good字符串
  3. 字符串长度大于1，后半部分全为’a,’,前半部分为’b’-good字符串
    现在有t个测试样例，每个测试样例给定一个长度为n的字符串，每次操作可以把任意位置的一个字符替换为任意一个小写字母，问最少需要多少次这样的操作后，才能使得当前字符串为’a’-good字符串?保证所有的字符串总长度为2e5

题解： 仔细分析可知，‘a’-good字符串是递归定义的，肯定为一半为a，另一半的前一半为b。另一半的后一半的前一半为c，。。。，即出现16-8-4-2-1这样的情况，因此每次只需要把当前字符串分为两半，分别统计两半内当前字符哪个出现的多，少的那个则为b字符串处理，不断dfs即可，由于这个规模不大，因此不会超时
代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
int const MAXN = 2e5 + 10;
int n, m, T;
string s;

int dfs(int st, int ed, char c) {
    if (st == ed) return (s[st] != c);
    int cnt1 = 0, cnt2 = 0;
    for (int i = st; i <= (st + ed) / 2; ++i) if (s[i] != c) cnt1++;
    for (int i = (st +ed) / 2 + 1; i <= ed; ++i) if (s[i] != c) cnt2 ++;
    return min(dfs(st, (st + ed) / 2, c + 1) + cnt2, dfs((st + ed) / 2 + 1, ed, c + 1) + cnt1);
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cin >> T;
    while(T--) {
        cin >> n >> s;
        cout << dfs(0, n - 1, 'a') << endl;
    }
    return 0;
}

E. Directing Edges

题意： 给定t个测试样例，每个测试样例给定n和m，n为图的点数，m为图的边数，给定m条边，每条边为op, a, b。如果op为1,表示有一条有向边a -> b;如果op为0，表示a和b之间有一条无向边。现在要求把无向边变成有向边(把a–b变成a->b或b->a)，使得最后这m条边没有环。【累加】n、m~2e5
题解： 题意可以转换为现在有一张有向图，要求向这张有向图内加入有向边，使得这张有向图没有环，求加边的方法。因此，可以先做一次拓扑排序，求出拓扑序，如果没有拓扑序，说明已经存在环；否则，只需要加入拓扑序小的指向拓扑序大的边即可。(因为想要形成环，必须有回路，则必须a->b，同时b->a,一旦出现拓扑序，说明存在a->b,不存在b->a,因此只要不加入b->a,则不可能出现环)
代码如下：

#include<bits/stdc++.h>

using namespace std;

int const N = 2e5 + 10;
int t, n, m;
set<int> point;
int e[N * 2], ne[N * 2], idx, h[N];
int d[N], sorted[N];
vector<pair<int, int> > undirect, direct;
vector<int> ans;
struct Edge{
    int op, u, v;
};
vector<Edge> E;

void top_sort() {
    queue<int> q;
    for (int i = 1; i <= n; ++i) {
        if (!d[i]) {
            // cout << i << endl;
            q.push(i);
        }
    }
    while (q.size()) {
        auto t = q.front();
        q.pop();
        ans.push_back(t);

        for (int i = h[t]; ~i; i = ne[i]) {
            int j = e[i];
            d[j]--;
            if (!d[j]) {
                q.push(j);
            }
        }
    }
    for (int i = 0; i < ans.size(); ++i) {
        sorted[ans[i]] = i + 1;
    }
    return ;
}

void add(int a, int b) {
    e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}
 
int main() {
    // freopen("in.txt", "r", stdin);
    // freopen("out.txt", "w", stdout);
    cin >> t;
    while (t--) {
        memset(h, -1, sizeof h);
        memset(d, 0, sizeof d);
        idx = 0;
        E.clear();
        memset(sorted, 0, sizeof sorted);
        ans.clear();
        cin >> n >> m;
        for (int i = 0, op, a, b; i < m; ++i) {
            scanf("%d%d%d", &op, &a, &b);
            E.push_back({op, a, b});
            if (op == 1) {
                add(a, b);
                d[b]++;
            }
        }
        top_sort();
        // cout << ans.size() << endl;
        if (ans.size() != n) {
            cout << "NO\n";
            continue;
        }
        cout << "YES\n";
        for (int i = 0; i < E.size(); ++i) {
            if (E[i].op == 1) {
                cout << E[i].u << " " << E[i].v << endl;
            }
            else {
                if (sorted[E[i].u] < sorted[E[i].v]) cout << E[i].u << " " << E[i].v << endl;
                else cout << E[i].v << " " << E[i].u << endl;
            }
        }
    }
    return 0;
}

F. Removing Leaves

题意： t个测试样例，每个测试样例给定一棵有n个节点的无根树，每次选择一个有k个叶子的节点，删除这k个叶子，问最多能够做多少次这样的操作？第一行输入t，而后每个样例先输入n和k，再输入n-1条边。t ~ 2e4, ∑ n < = 2 e 5 \sum_{}n<=2e5 ∑​n<=2e5
题解： 可以从叶子的角度思考问题。当一个节点周围的叶子数目达到k的倍数的时候，答案才会加一。因此，我们可以维护一个队列，里面存放的时候当前的叶子。按照类似拓扑排序的方式进行更新，使用vis数组标记当前叶子是否存活。对于这种一圈一圈删除的问题，很多时候都是使用拓扑排序来处理。
代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
int const MAXN = 2e5 + 10, MAXM = MAXN * 2;
int n, m, T, k;
int vis[MAXN], e[MAXM], ne[MAXM], h[MAXN], idx, d[MAXN], cnt[MAXN];

void add(int a, int b) {
    e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cin >> T;
    while(T--) {
        cin >> n >> k;
        for (int i = 1; i <= n; ++i) vis[i] = 0, h[i] = -1, d[i] = cnt[i] = 0;
        idx = 0;
        for (int i = 1, a, b; i < n; ++i ) {
            cin >> a >> b;
            add(a, b), add(b, a);
            d[a] ++, d[b] ++;
        }
        queue<int> q;
        for (int i = 1; i <= n; ++i) if (d[i] == 1) q.push(i);
        int res = 0;
        while(q.size()) {
            auto t = q.front();
            q.pop();
            vis[t] = 1;
            for (int i = h[t]; ~i; i = ne[i]) {
                int j = e[i];
                if (vis[j]) continue;
                d[j]--, cnt[j] ++;
                if (cnt[j] % k == 0) {
                    res++;
                    if (d[j] == 1) q.push(j);
                }
            }
        }
        cout << res << endl;
    }
    return 0;
}

G. Columns Swaps

大意：

给出一个2xn的矩阵，问能否通过交换某几列的第一行和第二行，使得第一行和第二行都是1到n的全排列

思路：

首先统计1到n出现的次数，必须都是两次否则输出-1

然后利用拓展域并查集，i代表这一列不换，i+n代表这一列需要变换

这样如果某个数出现在同一行，假设出现的位置分别为i和j，那么合并i和j+n，以及i+n和j

否则合并i和j i+n和j+n

这样最后会出现很多小联通块，这时候就选择i和i+n中数量较小的那一个即可

#include <bits/stdc++.h>

using namespace std;

const int N = 2e5 + 5;
typedef long long LL;
int t;
int a[N][2], n, cnt[N], pre[N], Size[2 * N], vis[2 * N], res[N], rescnt;
int f[2 * N];
int findf(int x) { return x == f[x] ? x : f[x] = findf(f[x]); }
void Union(int x, int y) {
    int fx = findf(x), fy = findf(y);
    if (fx != fy) {
        f[fx] = fy;
        Size[fy] += Size[fx];
    }
}
int main() {
    cin >> t;
    while (t--) {
        cin >> n;
        for (int i = 1; i <= n; i++) cnt[i] = 0, pre[i] = 0;
        for (int i = 1; i <= n; i++) cin >> a[i][0], cnt[a[i][0]]++;
        for (int i = 1; i <= n; i++) cin >> a[i][1], cnt[a[i][1]]++;
        int flag = 1;
        for (int i = 1; i <= n; i++)
            if (cnt[i] != 2) {
                flag = 0;
            }
        if (flag == 0) {
            printf("-1\n");
            continue;
        }
        for (int i = 1; i <= n; i++) {
            f[i] = i, f[i + n] = i + n;
            Size[i] = 0, Size[i + n] = 1;
            vis[i] = vis[i + n] = 0;
        }
        for (int i = 0; i < 2; i++) {
            for (int j = 1; j <= n; j++) {
                int now = a[j][i];
                if (pre[now] == 0)
                    pre[now] = j;
                else {
                    if (pre[now] == j) continue;
                    int k = pre[now];
                    if (a[k][i] == now) {  //同一行
                        int fx = findf(k), fy = findf(j);
                        int fx2 = findf(k + n), fy2 = findf(j + n);
                        if (fx == fy)
                            flag = 0;
                        else
                            Union(fx, fy2), Union(fx2, fy);
                    } else {
                        int fx = findf(k), fy = findf(j);
                        int fx2 = findf(k + n), fy2 = findf(j + n);
                        if (fx == fy2)
                            flag = 0;
                        else
                            Union(fx, fy), Union(fx2, fy2);
                    }
                }
            }
        }
        for (int i = 1; i <= n; i++)
            if (findf(i + n) == findf(i)) {
                flag = 0;
                break;
            }
        if (flag == 0) {
            printf("-1\n");
            continue;
        }
        for (int i = 1; i <= n; i++) {
            int x = findf(i), y = findf(i + n);
            // if (x == i && y == (i + n)) continue;
            if (!vis[x] && !vis[y]) {
                if (Size[x] > Size[y])
                    vis[y] = 1;
                else
                    vis[x] = 1;
            }
        }
        rescnt = 0;
        for (int i = 1; i <= n; i++) {
            if (vis[f[i + n]]) res[rescnt++] = i;
        }
        printf("%d\n", rescnt);
        for (int i = 0; i < rescnt; i++) printf("%d ", res[i]);
        printf("\n");
    }
    return 0;
}
「已注销」
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Codeforces Round #723 (Div. 2).md
10-13
Codeforces Round #723 (Div. 2).md
Codeforces Round #656 (Div. 3)ABC
ACM-ICPC 现役(铜牌) Codeforces Rating: 2172
07-22 208
5 3 2 3 100 100 100 50 49 49 10 30 20 1 1000000000 1000000000
补题：Codeforces Round #656 (Div. 3)
qq_45980336的博客
07-19 141
1.Codeforces Round #656 (Div. 3) A 题意：给定三个数，求另三个数，两两比较的大数正好是给定的三个数。 #include<iostream> #include<iomanip> #include<fstream> #include<cstdlib> #include<algorithm> #include<cmath> #include<string> #include<cstring
Codeforces Round #627 (Div. 3) B. Yet Another Palindrome Problem
01-03
一个长度为n的数组，为删除一些数后，剩下的数能否构成长度大于3的回文数组 思路： 只要能找到两个相等的数，且他们的间距大于2即可 o(n^2)的暴力就能过 比赛时写了一个o(n)的 就是把所有相等的数放到一个vector里，...
Codeforces Round #627 (Div. 3) C. Frog Jumps（思维）
01-20
传送门 题意： 开始位置在0，问能否跳到n+1位置 每步只能跳d 在1——n每个位置有方向，L,R，求d的最小值 思路： 只用找相邻两个R之间的最大值即可 代码： #include #include ...typedef long long l
codeforces round 962 (div. 3).docx
最新发布
07-29
Codeforces Round 962 (Div. 3) 是一场编程竞赛，其中包含了多个编程题目，每个题目都有其独特的挑战和解题思路。以下是对该竞赛中部分题目的简要介绍及解题思路概述： A题: Legs 题意： 一只鸡有2条腿，一头奶牛有...
Codeforces Round #656 (Div. 3)(ABCDE题解)
weixin_43736492的博客
07-18 187
题面大意： 给你x,y,zx,y,zx,y,z，并且满足x=max(a,b),y=max(a,c),z=max(b,c)x=max(a,b),y=max(a,c),z=max(b,c)x=max(a,b),y=max(a,c),z=max(b,c)，要你输出a,b,ca,b,ca,b,c。 思路： 通过观察可以发现要满足上面的式子必然存在两个或者以上的最大值。 然后就可以分三种情况讨论x=y,x=z,y=zx=y,x=z,y=zx=y,x=z,y=z，对于不同的情况令最大值为它们相同的那个数，然后次大值..
Codeforces Round #656 (Div. 3) (C、D题)
qq_14904619的博客
07-19 106
C. Make It Good 题意 : (多组输入) 给定 长度为 n 的 数组a，可以将其前x个元素删除(从头删起)，得到一个新数组b 然后每次都选择拿新数组b的 首或尾 一个元素 放入新数组c 必须满足 数组c是非递减数组 问题 : 求x的最小值(最少删除的元素个数) 思路 : b数组 只要保证从一个元素开始 向两边单调递减(在这定义为 峰 ) 又因为 a数组 的删除是从头开始的 我们只需要从尾开始跑 a数组 找到 最长的峰的左边界 pos (此处 峰的右边界必须是n) pos 之前的元素都是要删除
Codeforces Round #656 (Div. 3) F. Removing Leaves
矮纸斜行闲作草
04-26 99
题目链接 题意：给定一棵无根树，一次操作只能删去k个有相同邻接点的叶子节点。问最多可以有多少次这样的操作。 分析：这题不用想太复杂，对于一个连了>=k个叶子的节点来说，删去k个叶子，不会对其他的节点造成影响，所以满足局部最优，可以直接贪心选取。 具体的做法是 记录每个顶点的度，相邻的被删的叶子数。 用一个队列存叶子节点，挨个删去，同时记录删去当前叶节点对周围节点产生的影响，如果当前删除使得某个节点相邻的被删的叶子成为了k的倍数，则答案+1。 如果此时度变成了1，那么说明他成为了新的叶节点（即：该节点
Codeforces Round #656 (Div. 3)总结
amazingee的博客
07-18 485
题目链接 感受：这次一共做出四道题。感觉自己的思维还是不那么灵活，在A题卡了半小时（丢人）。前二十分钟看的A题感觉有思路又感觉没思路，索性直接看B，两分钟AC了，然后又看了两分钟A，还是写不出，又看了C，做了十分钟AC 了，这时候看了眼D，觉得应该出的不会快，然后决定静心看A，好好分析了几分钟AC了。这时候还一个小时，先是看了一眼E题，一个图论题，一开始的想法是并查集判环，但写到一半发现我处理不了一些细节，然后就放弃了去看D。D题给我的感觉是像一个贪心，分析了一下发现当前决策会影响下面的决策，所以贪心否定了
Codeforces Round #656 (Div. 3)题解
steven_pzx的博客
07-18 129
CF7.19日div3题解 A.Three Pairwise Maximums 解题思路： 依照题意和样例，三个整数x,y,z必须有两个相同且都比第三个数大。 如果x==y则说明a为最大值，此时需要满足a>=z，如果不满足该条件，则无解，因为z=max(b，c)，我们不能确定b,c谁比较大，所以我们就假设两个数一样的即可。而当y == z和x == z同理。 代码 在这里插入代码片 ...
Codeforces Round #656 (Div. 3) E. Directing Edges
naiue的博客
07-18 146
思路：拓扑序、有向图判环。 有向图判环大家都很熟悉，就是跑一边拓扑排序，看最终加入队列的点数是否等于总点数。 第二个是给环添加方向的做法。 这让我想起了学网络流时的dinic算法。也就是选取一点dfs，得出所有点的深度，然后路线只能从浅向深移动，这样避免成环，我的思路正是受这启发。 这里就不用多写dfs了，用拓扑序（可以理解为深度）解决即可。 code： #include<bits/stdc++.h> using namespace std; #define MAXN 200010 int to
Codeforces Round #656 (Div. 3) A、B、C、D题解
江小举的博客
07-18 674
CF在两次unrate之后终于恢复正常了。 A. Three Pairwise Maximums 题意：给你三个整数x、y、z，然后需要找出三个数a、b、c，使这三个数满足 x=max(a,b)x=max(a,b), y=max(a,c)y=max(a,c) and z=max(b,c)z=max(b,c)，或者确定这三个数不存在 思路：最大的两个数必须相同 #include<bits/stdc++.h> using namespace std; int main() { ios::syn
codeforces round #828 (div. 3)
06-06
好的，以下是关于Codeforces Round #828 (Div. 3)的一些信息： Codeforces Round #828 (Div. 3)是Codeforces网站上的一场编程竞赛，属于Div. 3级别的比赛。该比赛于2022年3月1日 15:35 (UTC)开始，比赛时长为2个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值