Codeforces Round #956 (Div. 2) and ByteRace 2024

已于 2024-07-08 18:21:22 修改
阅读量470 收藏 4
点赞数 10
文章标签： 算法 数据结构
于 2024-07-08 18:18:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/charmfulpro/article/details/140275827
版权

被这场比赛整自闭 了；

首先看A题

如果一个整数数组 a1,a2,⋯,an𝑎1,𝑎2,⋯,𝑎𝑛 满足以下条件，那么这个数组就是受整数 k𝑘 约束的美丽数组：

  • 所有 j𝑗 上的 aj𝑎𝑗 之和，其中 j𝑗 是 k𝑘 的倍数， 1≤j≤n1≤𝑗≤𝑛 是 k𝑘 的倍数。本身是 k𝑘 的倍数。
  • 更正式地说，如果 ∑k|jaj∑𝑘|𝑗𝑎𝑗 能被所有 1≤j≤n1≤𝑗≤𝑛 的 k𝑘 整除，那么数组 a𝑎 在 k𝑘 的约束下是美丽的。这里， k|j𝑘|𝑗 表示 k𝑘 除以 j𝑗 ，即 j𝑗 是 k𝑘 的倍数。

给定 n𝑛 ，求一个正非零整数数组，其中每个元素都小于或等于 105105 ，且所有 1≤k≤n1≤𝑘≤𝑛 都是美丽的。

可以证明答案总是存在的。

这个题其实思路很明显

就是输出1到n就行

然后是B题

给你两个由数字 a𝑎 和 b𝑏 组成的网格，网格中有 n𝑛 行和 m𝑚 列。网格中的所有数值都是 00 、 11 或 22 。

您可以多次对 a𝑎 执行以下操作：

  • 选取网格中任意一个长宽为 ≥2≥2 的子矩形。您可以选择整个网格作为子矩形。
  • 子矩形有四个角。取所选子矩形中任意一对斜对角，并将它们的值加上 11 ，模为 33 。
  • 对于未选中的一对角，在它们的值上加上 22 modulo 33 。

需要注意的是，此操作只改变被选中的子矩形的角的值。

是否可以通过任意次数(可能为零)的上述操作将网格 a𝑎 转换为网格 b𝑏 ？

这种题一般都是找规律，不涉及什么算法知识

由于对角上分别加1与2，这就可以看为2X2的矩阵，然后会发现他的行与列mod3的值其实是不变的，我们可以去对应他所要变得的矩阵

 int n, m; cin >> n >> m;
    int flag = 1;
    memset(p, 0, sizeof(p)); // 初始化 p 数组
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++) {
            cin >> a[i][j];
            p[i] += (a[i][j]-'0');
        }
    for (int i = 1; i <= n; i++)
    {
        int sum = 0;
        for (int j = 1; j <= m; j++) {
            cin >> b[i][j];
            sum += (b[i][j] - '0');
        }
        if (sum % 3 != p[i] % 3)flag = 0;
    }
    int fale = 1;
    for (int i = 1; i <= m; i++)
    {
        int sum1 = 0; int sum2 = 0;
        for (int j = 1; j <= n; j++)
        {
            sum1 += a[j][i];
            sum2 += b[j][i];
        }
        if (sum1 % 3 != sum2 % 3)fale = 0;
    }
    if (flag&&fale)cout << "YES\n";
    else cout << "NO\n";

还有一种写法，就是挨个来遍历，暴力做法，然后判断最后的行和列是否对应

void readGrid(vector<vector<int>>& grid, int n, int m) {
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            char c;
            cin >> c;
            grid[i][j] = c - '0';
        }
    }
}
bool canTransform(vector<vector<int>>& a, vector<vector<int>>& b, int n, int m) {
    for (int i = 0; i < n - 1; ++i) {
        for (int j = 0; j < m - 1; ++j) {
            while (a[i][j] != b[i][j]) {
                int diff = (b[i][j] - a[i][j] + 3) % 3;
                a[i][j] = (a[i][j] + diff) % 3;
                a[i][j + 1] = (a[i][j + 1] + 2 * diff) % 3;
                a[i + 1][j] = (a[i + 1][j] + 2 * diff) % 3;
                a[i + 1][j + 1] = (a[i + 1][j + 1] + diff) % 3;
            }
        }
    }
 
    // Check the last row and column
    for (int i = 0; i < n; ++i) {
        if (a[i][m - 1] != b[i][m - 1]) {
            return false;
        }
    }
 
    for (int j = 0; j < m; ++j) {
        if (a[n - 1][j] != b[n - 1][j]) {
            return false;
        }
    }
 
    return true;
}
 
int main() {
    int t;
    cin >> t;
    while (t--) {
        int n, m;
        cin >> n >> m;
        vector<vector<int>> a(n, vector<int>(m));
        vector<vector<int>> b(n, vector<int>(m));
 
        // Read grids a and b
        readGrid(a, n, m);
        readGrid(b, n, m);
 
        // Check if we can transform a to b
        if (canTransform(a, b, n, m)) {
            cout << "YES" << endl;
        }
        else {
            cout << "NO" << endl;
        }
    }
    return 0;
}

 然后我们看c题，这道题真给我整自闭了

爱丽丝、鲍勃和查理想分享一个切成 n𝑛 块的长方形蛋糕。每个人认为每块蛋糕的价值都不同。爱丽丝认为 i𝑖 /th块的价值是 ai𝑎𝑖 ，鲍勃认为是 bi𝑏𝑖 ，而查理认为是 ci𝑐𝑖 。

所有 ai𝑎𝑖 、所有 bi𝑏𝑖 和所有 ci𝑐𝑖 的总和是一样的，都等于 tot𝑡𝑜𝑡 。

考虑到每个人的每块蛋糕的值，你需要给每个人一块连续的蛋糕。换句话说，对于 Alice、Bob 和 Charlie 来说，这些子数组左端和右端的索引(给每个人的蛋糕片)可以分别表示为 (la,ra)(𝑙𝑎,𝑟𝑎) 、 (lb,rb)(𝑙𝑏,𝑟𝑏) 和 (lc,rc)(𝑙𝑐,𝑟𝑐) 。分割需要满足以下约束条件：

  • 没有一个棋子被分配给多人，即 [la,…,ra][𝑙𝑎,…,𝑟𝑎] 、 [lb,…,rb][𝑙𝑏,…,𝑟𝑏] 和 [lc,…,rc][𝑙𝑐,…,𝑟𝑐] 中没有两个子数组相交。
  • ∑rai=laai,∑rbi=lbbi,∑rci=lcci≥⌈tot3⌉∑𝑖=𝑙𝑎𝑟𝑎𝑎𝑖,∑𝑖=𝑙𝑏𝑟𝑏𝑏𝑖,∑𝑖=𝑙𝑐𝑟𝑐𝑐𝑖≥⌈𝑡𝑜𝑡3⌉ .
  • 我的做法是挨个遍历
  • 123
  • 132
  • 231
  • 213
  • 321
  • 312
  • 但是没做出来，超时了，300多行代码，自闭了。等有空我继续做
  • 换一种方式 
    #include <iostream>
#include <map>
#include <queue>
#include <algorithm>
#include <vector>
#include <cmath>
#include <cstring>

using namespace std;
using ll = long long;

const int N = 1e6;
int a[4][N];
ll cnt[4];
int flag[4];
int l1, l2, l3, r1, r2, r3;

void solve() {
    int n;
    cin >> n;

    // 重置全局变量
    memset(a, 0, sizeof(a));
    memset(cnt, 0, sizeof(cnt));
    memset(flag, 0, sizeof(flag));
    l1 = l2 = l3 = r1 = r2 = r3 = 0;

    // 读取输入并计算前缀和
    for (int i = 1; i <= 3; ++i) {
        for (int j = 1; j <= n; ++j) {
            cin >> a[i][j];
            a[i][j] += a[i][j - 1];
        }
    }

    ll tot = (a[1][n] + 2) / 3;
    int start = 0;

    // 123 顺序
    for (int i = start + 1; i <= n; i++) {
        cnt[1] = a[1][i] - a[1][start];
        if (cnt[1] >= tot) {
            l1 = start + 1;
            r1 = i;
            start = i;
            flag[1] = 1;
            break;
        }
    }
    for (int i = start + 1; i <= n; i++) {
        cnt[2] = a[2][i] - a[2][start];
        if (cnt[2] >= tot) {
            l2 = start + 1;
            r2 = i;
            start = i;
            flag[2] = 1;
            break;
        }
    }
    for (int i = start + 1; i <= n; i++) {
        cnt[3] = a[3][i] - a[3][start];
        if (cnt[3] >= tot) {
            l3 = start + 1;
            r3 = i;
            start = i;
            flag[3] = 1;
            break;
        }
    }

    if (flag[1] && flag[2] && flag[3]) {
        cout << l1 << ' ' << r1 << ' ' << l2 << ' ' << r2 << ' ' << l3 << ' ' << r3 << "\n";
        return;
    }
    else {
        flag[1] = 0; flag[2] = 0; flag[3] = 0; start = 0;
        cnt[1] = 0; cnt[2] = 0; cnt[3] = 0;
    }

    // 132 顺序
    for (int i = start + 1; i <= n; i++) {
        cnt[1] = a[1][i] - a[1][start];
        if (cnt[1] >= tot) {
            l1 = start + 1;
            r1 = i;
            start = i;
            flag[1] = 1;
            break;
        }
    }
    for (int i = start + 1; i <= n; i++) {
        cnt[3] = a[3][i] - a[3][start];
        if (cnt[3] >= tot) {
            l3 = start + 1;
            r3 = i;
            start = i;
            flag[3] = 1;
            break;
        }
    }
    for (int i = start + 1; i <= n; i++) {
        cnt[2] = a[2][i] - a[2][start];
        if (cnt[2] >= tot) {
            l2 = start + 1;
            r2 = i;
            start = i;
            flag[2] = 1;
            break;
        }
    }

    if (flag[1] && flag[2] && flag[3]) {
        cout << l1 << ' ' << r1 << ' ' << l2 << ' ' << r2 << ' ' << l3 << ' ' << r3 << "\n";
        return;
    }
    else {
        flag[1] = 0; flag[2] = 0; flag[3] = 0; start = 0; cnt[1] = 0; cnt[2] = 0; cnt[3] = 0;
    }

    // 213 顺序
    for (int i = start + 1; i <= n; i++) {
        cnt[2] = a[2][i] - a[2][start];
        if (cnt[2] >= tot) {
            l2 = start + 1;
            r2 = i;
            start = i;
            flag[2] = 1;
            break;
        }
    }
    for (int i = start + 1; i <= n; i++) {
        cnt[1] = a[1][i] - a[1][start];
        if (cnt[1] >= tot) {
            l1 = start + 1;
            r1 = i;
            start = i;
            flag[1] = 1;
            break;
        }
    }
    for (int i = start + 1; i <= n; i++) {
        cnt[3] = a[3][i] - a[3][start];
        if (cnt[3] >= tot) {
            l3 = start + 1;
            r3 = i;
            start = i;
            flag[3] = 1;
            break;
        }
    }

    if (flag[1] && flag[2] && flag[3]) {
        cout << l1 << ' ' << r1 << ' ' << l2 << ' ' << r2 << ' ' << l3 << ' ' << r3 << "\n";
        return;
    }
    else {
        flag[1] = 0; flag[2] = 0; flag[3] = 0; start = 0; cnt[1] = 0; cnt[2] = 0; cnt[3] = 0;
    }

    // 231 顺序
    for (int i = start + 1; i <= n; i++) {
        cnt[2] = a[2][i] - a[2][start];
        if (cnt[2] >= tot) {
            l2 = start + 1;
            r2 = i;
            start = i;
            flag[2] = 1;
            break;
        }
    }
    for (int i = start + 1; i <= n; i++) {
        cnt[3] = a[3][i] - a[3][start];
        if (cnt[3] >= tot) {
            l3 = start + 1;
            r3 = i;
            start = i;
            flag[3] = 1;
            break;
        }
    }
    for (int i = start + 1; i <= n; i++) {
        cnt[1] = a[1][i] - a[1][start];
        if (cnt[1] >= tot) {
            l1 = start + 1;
            r1 = i;
            start = i;
            flag[1] = 1;
            break;
        }
    }

    if (flag[1] && flag[2] && flag[3]) {
        cout << l1 << ' ' << r1 << ' ' << l2 << ' ' << r2 << ' ' << l3 << ' ' << r3 << "\n";
        return;
    }
    else {
        flag[1] = 0; flag[2] = 0; flag[3] = 0; start = 0; cnt[1] = 0; cnt[2] = 0; cnt[3] = 0;
    }

    //312
    for (int i = start + 1; i <= n; i++) {
        cnt[3] = a[3][i] - a[3][start];
        if (cnt[3] >= tot) {
            l3 = start + 1;
            r3 = i;
            start = i;
            flag[3] = 1;
            break;
        }
    }
    for (int i = start + 1; i <= n; i++) {
        cnt[1] = a[1][i] - a[1][start];
        if (cnt[1] >= tot) {
            l1 = start + 1;
            r1 = i;
            start = i;
            flag[1] = 1;
            break;
        }
    }
    for (int i = start + 1; i <= n; i++) {
        cnt[2] = a[2][i] - a[2][start];
        if (cnt[2] >= tot) {
            l2 = start + 1;
            r2 = i;
            start = i;
            flag[2] = 1;
            break;
        }
    }
    if (flag[1] && flag[2] && flag[3]) {
        cout << l1 << ' ' << r1 << ' ' << l2 << ' ' << r2 << ' ' << l3 << ' ' << r3 << "\n";
        return;
    }
    else {
        flag[1] = 0; flag[2] = 0; flag[3] = 0; start = 0; cnt[1] = 0; cnt[2] = 0; cnt[3] = 0;
    }
    // 321 顺序
    for (int i = start + 1; i <= n; i++) {
        cnt[3] = a[3][i] - a[3][start];
        if (cnt[3] >= tot) {
            l3 = start + 1;
            r3 = i;
            start = i;
            flag[3] = 1;
            break;
        }
    }
    for (int i = start + 1; i <= n; i++) {
        cnt[2] = a[2][i] - a[2][start];
        if (cnt[2] >= tot) {
            l2 = start + 1;
            r2 = i;
            start = i;
            flag[2] = 1;
            break;
        }
    }
    for (int i = start + 1; i <= n; i++) {
        cnt[1] = a[1][i] - a[1][start];
        if (cnt[1] >= tot) {
            l1 = start + 1;
            r1 = i;
            start = i;
            flag[1] = 1;
            break;
        }
    }

    if (flag[1] && flag[2] && flag[3]) {
        cout << l1 << ' ' << r1 << ' ' << l2 << ' ' << r2 << ' ' << l3 << ' ' << r3 << "\n";
    }
    else {
        cout << "-1\n";
    }
}

int main() {
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int t;
    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}

celestial pp
关注
  • 10
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Codeforces Round #956 (Div. 2) and ByteRace 2024（A~D题解）
2301_80475191的博客
07-08 1313
这次比赛也是比较吃亏的，做题顺序出错了，先做的第三个，错在第三个数据点之后，才做的第二个（因为当时有个地方没检查出来）所以这次比赛还是一如既往地打拉了那么就来发一下题解吧题意：对于1
Codeforces Round 956 (Div. 2) 部分题解A~C
ZZZioz的博客
07-08 771
给定操作，可以选择一个矩形的一条对角线上的两个端点，让他们加1/2；另一条对角线的端点值加2/1，然后对这些值取模3。考虑网格的边上的值，边上的值的变化会受到其他的影响，所以我们优先去找如何让边上的值相等即可。所有j的aj之和可以被k整除，其中j是k的倍数，k的取值为1~n。问如何分配蛋糕，使三个人获得的蛋糕价值均高于蛋糕价值和的三分之一。给定a和b两个网格，网格中只存在0、1、2三种值。三个人吃蛋糕，每个人对蛋糕不同位置有自己的估价。正扫一遍，反扫一遍，然后比较数组即可。分类讨论：三个人拿蛋糕的顺序。
Codeforces Round #956 (Div. 2) and ByteRace 2024 Editorial
A2899531592的博客
07-08 403
【代码】Codeforces Round #956 (Div. 2) and ByteRace 2024 Editorial。
Codeforces Round #956 (Div. 2) and ByteRace 2024 A-C题解
m0_63322121的博客
07-08 1024
【代码】Codeforces Round #956 (Div. 2) and ByteRace 2024 A-C题解。
22.1.23打卡 Codeforces Round #845 (Div. 2) and ByteRace 2023 A~B
Tanya_xiaomai的博客
01-23 237
只要看上一个是否和当前的数组元素奇偶性是否相同, 不相同就ans++自己手动计算一下逆序数就好了。
Codeforces Round #956 (Div. 2) and ByteRace 2024 E. I Love Balls（概率期望）
Code92007的博客
07-11 283
n-k+1一半向上取整就是(n-k+2)/2，同理n-k个一般向上取整(n-k+1)/2。特殊球不会改变普通球的顺序，所以都是alice拿一半里较多的部分。另外一个做法是，根据E(x+y)=E(x)+E(y)，可以把特殊球的总分集在一个特殊球上，普通球同理。每个特殊球独立地来看，在每个空隙的概率相同。也可以看成是摊成平均分摊在这若干个球上。所以分别统计特殊球和非特殊球的分数。
Codeforces Round 845 (Div. 2) and ByteRace 2023(C. Quiz Master)
weixin_63128867的博客
04-17 151
可以发现，一定存在一种最优方案，使得选出的数在 a 排序后的序列中是一段连续区间，且极差最小。因为如果存在一种最优方案选取的不是连续区间，那么将这些数最左端和最右端内全部选取，仍然符合题意，极差不变，但是选择的数是连续区间。多组询问，一个长为 n 的数列 a 和一个数 m，求在数列 a 中删掉几个数，使得从 11到 m 的所有数组成的集合是数列 a 中所有数的因数组成的集合的子集，求删数后数列 a 的极差。因此将 a 排序后，考虑双指针，因此我们只需要维护一段连续区间是否符合题意。
Codeforces Round #956 (Div. 2) and ByteRace 2024 F. array-value（trie经典问题 二分+01字典树）
Code92007的博客
07-29 306
对于长度>=2的区间[l,r]，定义b[l,r]为区间[l,r]内ai异或aj（l<=i<j<=r）的最小值，t(t<=2e4)组样例，每次给定长度n(n<=1e5)序列a（0<=ai<=1e9)对于(a[i]^a[j])>=mid，即不存在(a[i]^x)<mid的x，先检查trie上是否有值违背规则，即(a[r+1]^x)<mid，双指针单增，把这样的x从trie上删掉，得到新的l’，所以把r+1对应的值a[r+1]加入到trie树前，枚举右端点，对于右端点r来说，已经得到了左端点l，
Codeforces Round #845 (Div. 2) and ByteRace 2023-C. Quiz Master
weixin_52490191的博客
01-28 207
Codeforces Round #845 (Div. 2) and ByteRace 2023-C. Quiz Master
Codeforces Round #723 (Div. 2).md
10-13
Codeforces Round #723 (Div. 2).md
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 #627 (Div. 3) B. Yet Another Palindrome Problem
01-03
就是把所有相等的数放到一个vector里，如果他出现大于2次，看最远的间距是否大于2即可，找到一个就可以 代码： #include #include #include #include #include #include #include #include #include #include #...
Codeforces Round #833 (Div. 2) 思路
m0_75212691的博客
11-22 240
Codeforces Round #833 (Div. 2) 思路
算法练习题13——除自身以外数组的乘积（动态规划）
hello77的blogggg 祝你得偿所愿
09-04 498
给你一个整数数组nums，返回 数组answer，其中answer[i]等于nums中除nums[i]之外其余各元素的乘积。
【算法】C++贪心算法解题（单调递增数字、坏了的计算器、合并区间）
卜及中的博客
09-03 578
【算法】贪心算法解析：基本概念、策略证明与代码例题演示。
LeetCode LCR088.使用最小花费爬楼梯
m0_63816268的博客
09-03 1037
动态规划
树状数组记录
最新发布
volcan的博客
09-06 360
树状数组（Fenwick Tree）是一种用于维护数组前缀和的数据结构，支持高效的单点更新和区间查询操作。它的查询和更新时间复杂度为Ologn，适用于需要频繁更新和查询的场景。
【数据结构-二维前缀和】力扣1277. 统计全为 1 的正方形子矩阵
sjsjs11的博客
09-06 258
该题和力扣221.最大正方形类似，以某一格为右下角能形成最大正方形的边长，就是以该格为右下角的正方形数量。给你一个 m * n 的矩阵，矩阵中的元素不是 0 就是 1，请你统计并返回其中完全由 1 组成的 正方形 子矩阵的个数。正方形的总数 = 10 + 4 + 1 = 15.正方形的总数 = 6 + 1 = 7.边长为 1 的正方形有 10 个。边长为 2 的正方形有 4 个。边长为 3 的正方形有 1 个。边长为 1 的正方形有 6 个。边长为 2 的正方形有 1 个。输入：matrix =
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、付费专栏及课程。

余额充值