Codeforces Round 797 （Div. 3，CF1690）全题解

已于 2022-06-12 14:38:42 修改
阅读量282 收藏 1
点赞数 2
分类专栏： 贪心 数据结构：主席树… 文章标签： c++ 算法 贪心算法
于 2022-06-09 17:54:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hans774882968/article/details/125208309
版权

文章目录


感觉对于诸神来说这么一套水题题解没啥意义啊， 后进生的笔记罢了

传送门

作者：hans774882968以及hans774882968

本文CSDN链接

本文juejin链接

A

估计最大值的下界n/3+1，直接枚举最大值就能过：

        read (n);
        int v1, v2, v3;
        rep (i, n / 3 + 1, n) {
            if ( (n - i) % 2) v1 = (n - i) / 2, v2 = v1 + 1;
            else v1 = (n - i) / 2 - 1, v2 = v1 + 2;
            if (v1 < v2 && v2 < i) {
                v3 = i;
                break;
            }
        }
        printf ("%d %d %d\n", v2, v3, v1);

不过输入n = 6 7 8 9 ...可以发现最大值是可以直接写出来的式子(n - 1) / 3 + 2，所以可以进一步优化：

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int, int> pii;
#define rep(i,a,b) for(int i = (a);i <= (b);++i)
#define re_(i,a,b) for(int i = (a);i < (b);++i)
#define dwn(i,a,b) for(int i = (a);i >= (b);--i)

const int N = 2e5 + 5;

int n;

void dbg() {
    puts ("");
}
template<typename T, typename... R>void dbg (const T &f, const R &... r) {
    cout << f << " ";
    dbg (r...);
}
template<typename Type>inline void read (Type &xx) {
    Type f = 1;
    char ch;
    xx = 0;
    for (ch = getchar(); ch < '0' || ch > '9'; ch = getchar() ) if (ch == '-') f = -1;
    for (; ch >= '0' && ch <= '9'; ch = getchar() ) xx = xx * 10 + ch - '0';
    xx *= f;
}
void read() {}
template<typename T, typename ...R>void read (T &x, R &...r) {
    read (x);
    read (r...);
}

int main() {
    int T;
    read (T);
    while (T--) {
        read (n);
        int v1, v2, v3 = (n - 1) / 3 + 2;
        if ( (n - v3) % 2) v1 = (n - v3) / 2, v2 = v1 + 1;
        else v1 = (n - v3) / 2 - 1, v2 = v1 + 2;
        printf ("%d %d %d\n", v2, v3, v1);
    }
    return 0;
}

B

分b[i]等于和不等于0讨论。

  • 对于b[i]≠0的i，要求a[i]-b[i]相同，设为x。
  • 对于其他i，要求max(a[i]) <= x。

用set实现最方便。

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int, int> pii;
#define rep(i,a,b) for(int i = (a);i <= (b);++i)
#define re_(i,a,b) for(int i = (a);i < (b);++i)
#define dwn(i,a,b) for(int i = (a);i >= (b);--i)

const int N = 2e5 + 5;

int n, a[N], b[N];

void dbg() {
    puts ("");
}
template<typename T, typename... R>void dbg (const T &f, const R &... r) {
    cout << f << " ";
    dbg (r...);
}
template<typename Type>inline void read (Type &xx) {
    Type f = 1;
    char ch;
    xx = 0;
    for (ch = getchar(); ch < '0' || ch > '9'; ch = getchar() ) if (ch == '-') f = -1;
    for (; ch >= '0' && ch <= '9'; ch = getchar() ) xx = xx * 10 + ch - '0';
    xx *= f;
}
void read() {}
template<typename T, typename ...R>void read (T &x, R &...r) {
    read (x);
    read (r...);
}

bool jdg() {
    set<int> s1, s2;
    rep (i, 1, n) {
        if (b[i]) s1.insert (a[i] - b[i]);
        else s2.insert (a[i]);
    }
    if (s1.size() > 1) return false;
    if (s1.size() == 1 && *s1.begin() < 0) return false;
    if (s1.size() == 1 && s2.size() && *s1.begin() < *s2.rbegin() ) return false;
    return true;
}

int main() {
    int T;
    read (T);
    while (T--) {
        read (n);
        rep (i, 1, n) read (a[i]);
        rep (i, 1, n) read (b[i]);
        puts (jdg() ? "YES" : "NO");
    }
    return 0;
}

C

只需要求实际的开始时间，其表达式看样例就很容易写出来。

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int, int> pii;
#define rep(i,a,b) for(int i = (a);i <= (b);++i)
#define re_(i,a,b) for(int i = (a);i < (b);++i)
#define dwn(i,a,b) for(int i = (a);i >= (b);--i)

const int N = 2e5 + 5;

int n, a[N], b[N];

void dbg() {
    puts ("");
}
template<typename T, typename... R>void dbg (const T &f, const R &... r) {
    cout << f << " ";
    dbg (r...);
}
template<typename Type>inline void read (Type &xx) {
    Type f = 1;
    char ch;
    xx = 0;
    for (ch = getchar(); ch < '0' || ch > '9'; ch = getchar() ) if (ch == '-') f = -1;
    for (; ch >= '0' && ch <= '9'; ch = getchar() ) xx = xx * 10 + ch - '0';
    xx *= f;
}
void read() {}
template<typename T, typename ...R>void read (T &x, R &...r) {
    read (x);
    read (r...);
}

int main() {
    int T;
    read (T);
    while (T--) {
        read (n);
        rep (i, 1, n) read (a[i]);
        rep (i, 1, n) read (b[i]);
        rep (i, 1, n) printf ("%d%c", b[i] - max (b[i - 1], a[i]), " \n"[i == n]);
    }
    return 0;
}

D

直接枚举一个长为k的区间，看里面有多少个W即可。用前缀和统计W个数。

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int, int> pii;
#define rep(i,a,b) for(int i = (a);i <= (b);++i)
#define re_(i,a,b) for(int i = (a);i < (b);++i)
#define dwn(i,a,b) for(int i = (a);i >= (b);--i)

const int N = 2e5 + 5;

int n, a[N], k;
char s[N];

void dbg() {
    puts ("");
}
template<typename T, typename... R>void dbg (const T &f, const R &... r) {
    cout << f << " ";
    dbg (r...);
}
template<typename Type>inline void read (Type &xx) {
    Type f = 1;
    char ch;
    xx = 0;
    for (ch = getchar(); ch < '0' || ch > '9'; ch = getchar() ) if (ch == '-') f = -1;
    for (; ch >= '0' && ch <= '9'; ch = getchar() ) xx = xx * 10 + ch - '0';
    xx *= f;
}
void read() {}
template<typename T, typename ...R>void read (T &x, R &...r) {
    read (x);
    read (r...);
}

int main() {
    int T;
    read (T);
    while (T--) {
        read (n, k);
        scanf ("%s", s + 1);
        rep (i, 1, n) a[i] = a[i - 1] + (s[i] == 'W');
        int ans = n;
        rep (i, k, n) ans = min (ans, a[i] - a[i - k]);
        printf ("%d\n", ans);
    }
    return 0;
}

E

对于有定值掺杂其中的式子，总是建议先尝试把定值提取出来，再进行进一步分析。——沃·兹基硕德

(a + b) / k = a / k + b / k + (a % k + b % k) / k，这就把定值a / k和b / k提取出来了，后续只需要考虑a % k + b % k >= k是否成立。

这是一个很经典的贪心问题，好像是以过河为背景来着？贪心策略：先排序，再试图为当前的最小值a[i]匹配一个最小的满足条件的值。若匹配失败则丢弃a[i]，成功则获得一对。用multiset来进行匹配操作即可。

有另一种做法是排序+双指针，即直接拿现有的最大值去匹配当前的最小值。这种做法也能AC，但我不清楚其正确性。

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int, int> pii;
#define rep(i,a,b) for(int i = (a);i <= (b);++i)
#define re_(i,a,b) for(int i = (a);i < (b);++i)
#define dwn(i,a,b) for(int i = (a);i >= (b);--i)

const int N = 2e5 + 5;

int n, k, a[N];

void dbg() {
    puts ("");
}
template<typename T, typename... R>void dbg (const T &f, const R &... r) {
    cout << f << " ";
    dbg (r...);
}
template<typename Type>inline void read (Type &xx) {
    Type f = 1;
    char ch;
    xx = 0;
    for (ch = getchar(); ch < '0' || ch > '9'; ch = getchar() ) if (ch == '-') f = -1;
    for (; ch >= '0' && ch <= '9'; ch = getchar() ) xx = xx * 10 + ch - '0';
    xx *= f;
}
void read() {}
template<typename T, typename ...R>void read (T &x, R &...r) {
    read (x);
    read (r...);
}

int main() {
    int T;
    read (T);
    while (T--) {
        read (n, k);
        rep (i, 1, n) read (a[i]);
        LL ans = 0;
        rep (i, 1, n) ans += a[i] / k, a[i] %= k;
        sort (a + 1, a + n + 1);
        multiset<int> st;
        rep (i, 1, n) st.insert (a[i]);
        rep (i, 1, n) {
            if (!st.size() ) break;
            if (!st.count (a[i]) ) continue;
            st.erase (st.find (a[i]) );
            auto it = st.lower_bound (k - a[i]);
            if (it == st.end() ) continue;
            st.erase (it);
            ++ans;
        }
        printf ("%lld\n", ans);
    }
    return 0;
}

F

前置芝士：一个置换可以写成若干个循环的乘积。如输入数据的8 6 1 7 5 2 9 3 10 4写成(1 8 3) (2 6) (4 7 9 10) (5)。一个置换的阶等于其所有循环的阶的lcm，符合直觉很好理解。

对于循环(a[1] a[2] ... a[x])，取出字符串t = s[a[1]]s[a[2]]...s[a[x]]，那么变换一次就表示把首字符移到末尾。所以我们构造一个t + t，t变换回原串的次数就等于(t + t).find(t, 1)，其中find是cpp的string的函数，第二个参数表示从哪个下标开始匹配子串。

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int, int> pii;
#define rep(i,a,b) for(int i = (a);i <= (b);++i)
#define re_(i,a,b) for(int i = (a);i < (b);++i)
#define dwn(i,a,b) for(int i = (a);i >= (b);--i)

const int N = 2e2 + 5;

int n, p[N];
bool vis[N];

void dbg() {
    puts ("");
}
template<typename T, typename... R>void dbg (const T &f, const R &... r) {
    cout << f << " ";
    dbg (r...);
}
template<typename Type>inline void read (Type &xx) {
    Type f = 1;
    char ch;
    xx = 0;
    for (ch = getchar(); ch < '0' || ch > '9'; ch = getchar() ) if (ch == '-') f = -1;
    for (; ch >= '0' && ch <= '9'; ch = getchar() ) xx = xx * 10 + ch - '0';
    xx *= f;
}
void read() {}
template<typename T, typename ...R>void read (T &x, R &...r) {
    read (x);
    read (r...);
}

LL gcd (LL a, LL b) {
    return b ? gcd (b, a % b) : a;
}

LL lcm (LL a, LL b) {
    return a / gcd (a, b) * b;
}

int main() {
    int T;
    read (T);
    while (T--) {
        memset (vis, 0, sizeof vis);
        read (n);
        string s;
        cin >> s;
        re_ (i, 0, n) read (p[i]), p[i]--;
        LL ans = 1;
        re_ (i, 0, n) {
            if (vis[i]) continue;
            vis[i] = true;
            int u = p[i];
            string t = string (1, s[i]);
            while (u != i) {
                vis[u] = true;
                t += s[u];
                u = p[u];
            }
            int cnt = (t + t).find (t, 1);
            ans = lcm (ans, cnt);
        }
        printf ("%lld\n", ans);
    }
    return 0;
}

G

以样例10 13 5 2 6为例。首先求出所有形成的区间[1, 2] [3, 3] [4, 5]。若a[2] -= 3，因为大于等于该区间的值，所以没有发生区间的分裂。若a[2] -= 8，因为小于该区间的值，所以需要进行区间分裂，即idx = 2成为新的区间左端点，之后要找出新的区间的右端点，即进行区间合并，[3, 3]被合并进去了。如果a[2]再小一些，变成a[2] <= 2，则[3, 3] [4, 5]都会被合并进去。

从上面的例子发现，需要进行区间的分裂和合并。合并时要一直遍历到候选区间的值严格小于新产生的区间的值为止。因为区间之间没有缝隙，所以我们只需要用一个值来表示，比如上面的例子就是1 3 4。此时可以梳理我们需要的操作：

  • 区间分裂，即插入一个值。
  • 区间合并，即删除若干个值。
  • 寻找最大的小于等于k的值。

这些操作只需要set。

时间复杂度：O((n + m)logn)。

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int, int> pii;
#define rep(i,a,b) for(int i = (a);i <= (b);++i)
#define re_(i,a,b) for(int i = (a);i < (b);++i)
#define dwn(i,a,b) for(int i = (a);i >= (b);--i)

const int N = 2e5 + 5;

int n, m, a[N];

void dbg() {
    puts ("");
}
template<typename T, typename... R>void dbg (const T &f, const R &... r) {
    cout << f << " ";
    dbg (r...);
}
template<typename Type>inline void read (Type &xx) {
    Type f = 1;
    char ch;
    xx = 0;
    for (ch = getchar(); ch < '0' || ch > '9'; ch = getchar() ) if (ch == '-') f = -1;
    for (; ch >= '0' && ch <= '9'; ch = getchar() ) xx = xx * 10 + ch - '0';
    xx *= f;
}
void read() {}
template<typename T, typename ...R>void read (T &x, R &...r) {
    read (x);
    read (r...);
}

int main() {
    int T;
    read (T);
    while (T--) {
        read (n, m);
        rep (i, 1, n) read (a[i]);
        set<int> s;
        for (int mn = INT_MAX, i = 1; i <= n; ++i) {
            if (mn > a[i]) s.insert (i);
            mn = min (mn, a[i]);
        }
        while (m--) {
            int k, d;
            read (k, d);
            a[k] -= d;
            auto it = --s.upper_bound (k);
            auto it_tmp = it;
            for (++it; it != s.end() && a[*it] >= a[k]; it = s.erase (it) );
            if (a[*it_tmp] > a[k]) s.insert (k);
            // for (int v : s) cout << v << ",";
            // puts (""); //
            printf ("%d%c", s.size(), " \n"[m == 0]);
        }
    }
    return 0;
}
hans774882968
关注
专栏目录
codeforces round 962 (div. 3).docx
07-29
Codeforces Round 962 (Div. 3) 是一场编程竞赛，其中包含了多个编程题目，每个题目都有其独特的挑战和解题思路。以下是对该竞赛中部分题目的简要介绍及解题思路概述： A题: Legs 题意： 一只鸡有2条腿，一头奶牛有...
CF 1690E - Price Maximization
花生ono的博客
07-19 98
就能使成本大一点。这也是我们需要做的，尽量把余数大的找到一个小的余数组合，使得它相加后能再多一个。个包裹，也就是每两个商品为一个包裹，而每一个包裹的成本就是包裹中两个商品的重量和除以给定的。把所有包裹相加后，可以看出任意两个商品组合，都不会影响各自拥有的。值(结果向下取整)，我们要找到的就是所有包裹最大成本值并输出。我们可以将一个包裹的成本划分为两个商品重量。的个数，影响的而是余数相加能否再多一个。(偶数)个商品划分为。
cf1690F. Shifting String（div3）
国家一级划水运动员的博客
06-12 337
传送门题意给定一个长度为 n 的字符串和数组 p，字符串的每次变换都将以数组 p 中的数字作为基准，问在经过最少几次（不可以为 000 ）变换后，该字符串能够变换为与初始字符串相同。对样例 3 手模后，可以得到如上表格（眼瞎了，可能有错，凑合看看规律 ），发现其中是以若干个环进行滚动的，如下标（1,8,3），（2,6）,（4,7,9,10）,（5）（1,8,3），（2,6）,（4,7,9,10）,（5）（1,8,3），（2,6）,（4,7,9,10）,（5） ，在最坏情况下求出每个环的长度的最小公倍数即为操
Codeforces-1690 E: Price Maximization 【排序、双指针】
Sherlock_Holmewei的博客
06-10 297
题目传送门：Codeforces-1690 E  给定一个长度为 nnn 的数组 {ai}\{a_{i}\}{ai​}（nnn 是偶数）和一个整数 kkk，可以将里面的数两两打包，例如，打包 ai,aja_i,a_jai​,aj​ 后对应包裹的价值为 ⌊ai+ajk⌋\lfloor \frac{a_i + a_j}{k} \rfloor⌊kai​+aj​​⌋。   求将整个数组里的数两两打包后，能得到的最大价值总和是多少。  为了让价值更大，我们就要减少浪费，即我们要将约数都利用起来。两个数对 kkk 的约
Codeforces Round #797 (Div. 3)个人题解
hacker__man的博客
07-29 497
E是双指针，F是置换找环。
Codeforces 797A k-Factorization
Polanwind
05-25 296
题目来源：CF 797A 简单题目分析： 给定n和k，问：是否存在k个数（均大于1，但可以相同）的乘积等于n。若没有，输出-1，若有且有多组数据，任意输出一组数据即可。 思路： 唯一分解定理：一个非质数一定可以分解为若干质数的乘积（质数的话则是它本身），而且这种分解是最彻底的，如果你分解的因子中还有合数，那么这个合数可以继续分解，直到所有因数都是质数。 那么，这个题目就可以转化为求质因数
codeforces round 962 (div. 3) .zip
07-28
Codeforces Round 962 (Div. 3) 是一场编程竞赛，旨在测试参赛者在算法和数据结构方面的能力。由于篇幅限制，我将对这场竞赛中的几个关键问题进行详细解析，但请注意，由于具体实现细节可能因题目而异，且无法在此...
Codeforces Round 964 (Div. 4).pdf
08-07
A~G
codeforces round 962 (div. 3)tion-ma笔记
07-29
codeforces round 962 (div. 3)tion-ma笔记
CF 1690 G. Count the Trains 思维 2000
m0_62346540的博客
07-18 121
CF 1690 G. Count the Trains 思维 2000
codeforces 797e Array Queries 部分dp+暴力
chen_minghui的博客
05-01 354
题意：一个长度为n的数组，ai ,1= 思路：部分dp，k较大时，路径较短，可以暴力，k较小时，路径可能很深，记忆化搜索. #include #include using namespace std; const int maxn = 100010; int a[maxn]; int f[maxn][420]; int n; int dfs(int q,int k) { if(q>n)ret
Codeforces Round #797 (Div. 3)总结
m0_64045085的博客
06-08 342
Codeforces Round #797 (Div. 3) Codeforces 1690
Codeforces Round #797 (Div. 3)无F
fnmdpnmsl的博客
06-08 610
这打的也太屎了呜呜呜Given the integer n — the number of available blocks. You must use all blocks to build a pedestal.The pedestal consists of 3 platforms for 2-nd, 1-st and 3-rd places respectively. The platform for the 1-st place must be strictly higher than for t
codeforces #797 div[3] A~D
aktiaotiao的博客
06-08 101
弱鸡的第一篇codeforces题解
CF1490G Old Floppy Drive（前缀和+二分查找+思维）
m0_51841071的博客
03-01 321
题目传送门 在洛谷上面这道题的翻译有一些歧义，本题应该是a的第一个前缀和大于等于x的下标（本蒟蒻语文学的不好）。 分析： 这道题是循环前缀和，那么解决本道题本质上不能用暴力思想一直求到大于等于x的位置（给G题一点点面子不好嘛？？？）那么我们应该求一遍a的前缀和sum[]，看看我们的询问的x中包含多少个sum[n] ① sum[n]<=0而且数据中的最大前缀和数组mxx[]小于我们的x，那么就说明我们永远也无法触碰到我们询问的这个x ②反之，如果最大前缀和mxx[]大于等于最大的数据，就说明在第一次前缀
p4:cmu 15213/15513 csapp 深入理解计算机系统（寄存器、标志位/条件码、set指令、大端法小端法、逻辑左右移和算数左右移、字长概念）
最新发布
shanshan的博客
11-11 300
可以简单记成，setg表示set greater，但是机器指令的参数顺序与我们习惯的顺序不同，机器指令是从右到左比较的。标志位都是一位，他们不是你直接设置的，而是计算机的算术指令自己设置的。在这里是零拓展的意思，将al的一字节的全0拓展为4字节，左边都补0。综上，机器指令的流程是，比较两个数，得到一字节的0或1，然后根据返回类型的字长要求，拓展为相应位数的0或1。这里setg指令根据sf条件码，假设为0，（说明y>x），那么最低位的单个字节也都设为0。将单个寄存器的单个字节根据条件码的值设为1或0。
C++——C++11新语法（中）
Wangx_wang的博客
11-06 1042
介绍了C++11中的引用折叠、可变模板参数、类的新功能、lambda
C++_用 using 语句继承基类的构造函数
学海无涯
11-09 235
**默认情况下**，派生类会继承基类的所有成员，包括数据成员和函数成员，但不会继承基类的**构造函数和析构函数**，因为构造函数和析构函数的作用是创建和销毁对象，派生类通常需要有自己的构造和析构的逻辑。C++11 引入了using语句，使得派生类可以通过 using 关键字使用基类的构造函数，更方便地复用基类的构造逻辑。
常用的c++特性--＞day02
m0_69093426的博客
11-06 646
C++11中为我们提供了一个模板类叫做std::enable_shared_from_this，这个类中有一个方法叫做shared_from_this()，通过这个方法可以返回一个共享智能指针，在函数的内部就是使用weak_ptr来监测this对象，并通过调用weak_ptr的lock()方法返回一个shared_ptr对象。通过打印的结果可以知道，虽然弱引用智能指针wp3、wp4、wp5监测的资源是同一个，但是它的引用计数并没有发生任何的变化，也进一步证明了weak_ptr只是监测资源，并不管理资源。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值