Codeforces Round 971 (Div. 4)

最新推荐文章于 2024-09-06 10:38:06 发布

icesmoke

最新推荐文章于 2024-09-06 10:38:06 发布

阅读量1.1k

点赞数 29

分类专栏： codeforces 文章标签：算法

本文链接：https://blog.csdn.net/weixin_50143539/article/details/141900569

版权

codeforces 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

比赛链接：点击进入比赛

A. Minimize!

思路

给出两个数 $\le b)$ ，要找到 $c$ ，使得 $(c - a) + (b - c)$ 最小，发现化简后 $c$ 会被消掉，简化后为 $a + b$ ，因此输出 $a + b$ 即可。

复杂度

时间复杂度和空间复杂度均为 $O (1)$

代码实现

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

#define int long long

void solve()
{
    int a, b;
    cin >> a >> b;
    cout << b - a << '\n';
}

signed main()
{
    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);

    int T = 1;
    cin >> T;
    while (T--) {
        solve();
    }
}

B. osu!mania

思路

按题意模拟即可，从最底行到最顶行，对于每一行找出 $KaTeX parse error: Expected 'EOF', got '#' at position 2: '#̲'$ 在该行所在的列即可。

复杂度

时间复杂度和空间复杂度均为 $O(n^2)$

代码实现

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

#define int long long

int n;
string s[505];

void solve()
{
    cin >> n;
    for (int i = 1; i <= n; i++) {
        cin >> s[i];
    }
    for (int i = n; i >= 1; i--) {
        for (int j = 0; j < 4; j++) {
            if (s[i][j] == '#')
                cout << j + 1 << ' ';
        }
    }
    cout << '\n';
}

signed main()
{
    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);

    int T = 1;
    cin >> T;
    while (T--) {
        solve();
    }
}

C. The Legend of Freya the Frog

思路

要使得步数最少，每次跳跃点数都跳 $k$ 点，直到最后可能剩下小于 $k$ 点，则跳剩下的点数，因此， $x$ 方向上最少步数为 $\lceil \frac{x}{k} \rceil$ ， $y$ 方向上最少步数为 $\lceil \frac{y}{k} \rceil$ 。

因为是 $x, y$ 交替方向走的，所以走 $2*max(\lceil \frac{x}{k} \rceil,\lceil \frac{y}{k} \rceil)$ 步必然能走到终点。

如果 $\lceil \frac{x}{k} \rceil > \lceil \frac{y}{k} \rceil$ ，则 $y$ 方向可以少走一步，最少步数为 $2*max(\lceil \frac{x}{k} \rceil,\lceil \frac{y}{k} \rceil) -1$ ，否则为 $2*max(\lceil \frac{x}{k} \rceil,\lceil \frac{y}{k} \rceil)$ 。

复杂度

时间复杂度和空间复杂度均为 $O (1)$

代码实现

// Problem: The Legend of Freya the Frog
// Contest: Codeforces
// URL: https://m1.codeforces.com/contest/2009/problem/C?locale=en
// Memory Limit: 256 MB
// Time Limit: 2000 ms
//
// Powered by CP Editor (https://cpeditor.org)

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

#define int long long

void solve()
{
    int x, y, k;
    cin >> x >> y >> k;
    int dx = (x + k - 1) / k;
    int dy = (y + k - 1) / k;
    if (dy >= dx) {
        cout << 2 * dy << '\n';
    } else {
        cout << 2 * dx - 1 << '\n';
    }
}

signed main()
{
    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);

    int T = 1;
    cin >> T;
    while (T--) {
        solve();
    }
}

D. Satyam and Counting

思路

要快速判断点是否存在，只需要开个二维数组标记对应位置即可。

三角形有以下可能情况：
1， $(a, 0), (a, 1), (b, 0/1)$ ， $a > b$
2， $(a, 0), (a, 1), (b, 0/1)$ ， $a < b$
3， $(a, 0), (a - 1, 1), (a + 1, 1)$
4， $(a, 1), (a - 1, 0), (a + 1, 0)$

可以枚举 $x$ 坐标：

1，在当前 $x$ 坐标下，同时存在 $y = 0, 1$ 的点，那么这两个点可以和 $x$ 坐标不同的一个点构成直角三角形，可以关于 $x$ 坐标做点数的前后缀，这样就可以快速查询前后 $x$ 坐标不同的点的数量。

2，如果 $(x, y)$ 存在， $\oplus 1),(x+1,y \oplus 1)$ 也存在，那么这三个点可以构成三角形。

复杂度

时间复杂度和空间复杂度均为 $O (n)$

代码实现

// Problem: Satyam and Counting
// Contest: Codeforces
// URL: https://m1.codeforces.com/contest/2009/problem/D?locale=en
// Memory Limit: 256 MB
// Time Limit: 2000 ms
//
// Powered by CP Editor (https://cpeditor.org)

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

#define int long long

const int N = 2e5 + 5;

int n;
int st[N][2], lx[N], rx[N];

void solve()
{
    cin >> n;
    for (int i = 0; i <= n + 1; i++) {
        lx[i] = rx[i] = st[i][0] = st[i][1] = 0;
    }
    for (int i = 1; i <= n; i++) {
        int x, y;
        cin >> x >> y;
        st[x][y] = 1;
        // 标记对应位置
    }
    // 做前缀和
    for (int i = 0; i <= n; i++) {
        lx[i] = st[i][0] + st[i][1];
        if (i)
            lx[i] += lx[i - 1];
    }
    // 做后缀和
    for (int i = n; i >= 1; i--) {
        rx[i] = st[i][0] + st[i][1];
        if (i < n)
            rx[i] += rx[i + 1];
    }
    int ans = 0;
    for (int i = 0; i <= n; i++) {
        // (x,0),(x,1) 同时存在
        if (st[i][0] && st[i][1]) {
            // 加上前后的点
            if (i)
                ans += lx[i - 1];
            if (i < n)
                ans += rx[i + 1];
        }
        if (i > 0 && i < n) {
            ans += st[i][0] && st[i - 1][1] && st[i + 1][1];
            ans += st[i][1] && st[i - 1][0] && st[i + 1][0];
        }
    }
    cout << ans << '\n';
}

signed main()
{
    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);

    int T = 1;
    cin >> T;
    while (T--) {
        solve();
    }
}

E. Klee’s SUPER DUPER LARGE Array!!!‘

思路

$y = a_1 + a_2 + ... + a_i - a_{i+1} - ... - a_n$ ，可以发现，如果 $i$ 越小，那么 $y$ 越小，反之越大，因此 $y$ 关于 $i$ 单调递增。

因为 $a = [k, k + 1, ..., k + n - 1]$ ，所以 $\frac{(n-1)*i}{2} - ((n-i)*k + \frac{(i+n-1)*(n-i)}{2})$ 。

当 $i = n$ 时， $a_1 + ... a_n = n*k +\frac{ (n-1)*n}{2}$ ，因为 $n, k > 0$ ，所以当 $i = n$ 时， $y > 0$ 。

因为 $i$ 越小， $y$ 越小，所以 $y$ 可能会减小到 $0$ 以下，此时 $y$ 关于 $i$ 的曲线就会存在零点。

离零点越近， $y$ 对应的绝对值 $∣ x ∣$ 就越小，因此可以二分出靠近零点的整数位置，在这个整数位置周围必然会使得 $∣ x ∣$ 取得最小值。

或者可以直接三分，因为单调递减的曲线，取绝对值后负数的部分会对称到 $x$ 轴上方，从而使得曲线存在波谷，也就是最小值点，可以三分求出该点。

复杂度

时间复杂度，二分是 $log_2(n)$ ，三分是 $2\log_3(n)$ 。
空间复杂度均为 $O (1)$

代码实现

三分写法

// Problem: Klee's SUPER DUPER LARGE Array!!!
// Contest: Codeforces
// URL: https://m1.codeforces.com/contest/2009/problem/E
// Memory Limit: 256 MB
// Time Limit: 2000 ms
//
// Powered by CP Editor (https://cpeditor.org)

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

#define int long long

int n, k;

int cal(int id)
{
    int res = 0;
    res += id * k + (id - 1) * id / 2;
    res -= (n - id) * k + (id + n - 1) * (n - id) / 2;
    return abs(res);
}

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

    int l = 0, r = n;
    while (l < r) {
        int lmid = l + (r - l) / 3;
        int rmid = r - (r - l) / 3;
        if (cal(lmid) <= cal(rmid))
            r = rmid - 1;
        else
            l = lmid + 1;
    }
    cout << min(cal(l), cal(r)) << '\n';
}

signed main()
{
    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);

    int T = 1;
    cin >> T;
    while (T--) {
        solve();
    }
}

二分写法

// Problem: Klee's SUPER DUPER LARGE Array!!!
// Contest: Codeforces
// URL: https://m1.codeforces.com/contest/2009/problem/E
// Memory Limit: 256 MB
// Time Limit: 2000 ms
//
// Powered by CP Editor (https://cpeditor.org)

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

#define int long long

int n, k;

int cal(int id)
{
    int res = 0;
    res += id * k + (id - 1) * id / 2;
    res -= (n - id) * k + (id + n - 1) * (n - id) / 2;
    return res;
}

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

    int l = 0, r = n;
    while (l < r) {
        int mid = (l + r + 1) >> 1;
        if (cal(mid) <= 0)
            l = mid;
        else
            r = mid - 1;
    }
    cout << min(abs(cal(l)), abs(cal(l + 1))) << '\n';
}

signed main()
{
    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);

    int T = 1;
    cin >> T;
    while (T--) {
        solve();
    }
}

F. Firefly’s Queries

思路

把数组 $a$ 向后复制一份构成新数组 $b$ ，可以发现从数组 $b$ 下标 $\le i \le n)$ 处开始向后取 $n$ 个数构成的数组，刚好为第 $i$ 个循环左移数组。

对复制后的数组 $b$ 做前缀和后，这样可以便于查询第 $i$ 个循环左移数组某段区间的和。

查询区间 $[l, r]$ 的前缀和，可以分为两种情况。

1， $[l, r]$ 完全在某个循环左移数组内，且 $r$ 不处于该数组右边界，如果 $[l, r]$ 在第 $i$ 个循环左移数组内，那么 $[l, r]$ 在数组 $b$ 中的对应区间为 $[i + l - (i - 1) * n - 1, i + r - (i - 1) * n - 1]$ ，直接查询对应的前缀和即为答案。

2，令满足 $\ge l$ 的 $k$ 最大值为 $lp$ ，满足 $\le r$ 的 $k$ 的最小值为 $r p$ 。（ $\lfloor \frac{l}{n} \rfloor,rp = \lceil \frac{r}{n} \rceil$ ）

当 $r$ 在 $l$ 所在数组的右边界时， $lp, r p$ 都恰好在右边界的位置，满足 $lp = r p$ ，若 $r$ 向右移动， $lp$ 不会移动， $r p$ 可能会向右移动，满足 $\le rp$ ，也是不满足 $lp > r p$ 的，因此只有情况 $1$ 满足 $lp > r p$ 。

不考虑 $l, r$ 所在的数组，中间则会有 $(r p - lp)$ 个完整的数组，如果数组 $a$ 中的总和为 $s u m$ ，那么这些数组对答案的贡献为 $s u m * (r p - lp)$ 。

因为 $l$ 在第 $lp$ 个循环数组，且 $r$ 在第 $lp$ 个循环数组的右边界或者之后，即所以 $[l, r]$ 包含了 $[l, lp * n]$ ，这一段对答案的贡献即为数组 $b$ 中 $[lp + l - (lp - 1) * n - 1, lp + n - 1]$ 的区间和，如果 $r$ 不在某个数组的右边界，那么 $[(r p * n + 1, r]$ 也会对答案产生贡献，对应的贡献为 $[r p + 1, r p + r - r p * n]$ 。

复杂度

时间复杂度为 $O (n + q)$ 。
$O (n)$ 为处理前缀和的复杂度， $q$ 次查询每次查询的复杂度是 $O (1)$ 的。

空间复杂度为 $O (n)$

代码实现

// Problem: Firefly's Queries
// Contest: Codeforces
// URL: https://m1.codeforces.com/contest/2009/problem/F
// Memory Limit: 256 MB
// Time Limit: 2000 ms
//
// Powered by CP Editor (https://cpeditor.org)

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

#define int long long

const int N = 2e5 + 5;

int n, q;
int a[3 * N];

void solve()
{
    cin >> n >> q;
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
        a[n + i] = a[i];
    }
    for (int i = 1; i <= 2 * n; i++) {
        a[i] += a[i - 1];
    }
    while (q--) {
        int l, r;
        cin >> l >> r;
        int lp = (l + n - 1) / n, rp = r / n;
        if (lp > rp) {
            int lj = rp + l - rp * n;
            int rj = rp + r - rp * n;
            cout << a[rj] - a[lj - 1] << '\n';
        } else {
            int ans = (rp - lp) * a[n];
            int lj = lp - 1 + l - (lp - 1) * n;
            int rj = lp - 1 + n;
            ans += a[rj] - a[lj - 1];
            if (r > rp * n) {
                lj = rp + 1;
                rj = rp + r - rp * n;
                ans += a[rj] - a[lj - 1];
            }
            cout << ans << '\n';
        }
    }
}

signed main()
{
    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);

    int T = 1;
    cin >> T;
    while (T--) {
        solve();
    }
}

G1. Yunli’s Subarray Queries (easy version)

思路

如果 $a_i - i = a_j - j$ ，则 $a_j - a_i = j - i$ ，下标的距离即为这两个值的差值，则可以同时不修改 $a_i,a_j$ ，使得 $a_i,a_j$ 存在在同一个连续子数组里面，因此可以做一个新数组 $b$ ， $b_i = a_i - i$ 。

如果 $b_i = b_j$ 则， $a_i,a_j$ 可以存在于同一个连续子数组里面，那么如果数组 $b$ 在 $[l, r]$ 中同一个元素的最多出现次数为 $x$ ，那么把 $[l, r]$ 修改为连续子数组的最少次数即为 $r - l + 1 - x$ 。

因为每次查询都是查询长度为 $k$ 的区间，修改为连续子数组的最少次数，所以可以处理出数组 $a$ 中所有长度为 $k$ 的区间修改为连续子数组的最少次数。

具体的做法是从左到右对数组 $b$ 进行遍历，然后记录下 $b_i$ 的出现次数，维护每个长度为 $k$ 的窗口中元素的最大出现次数。

可以用 $m u lt i es t$ 记录所有元素出现次数的数值集合，然后用 $ma p$ 记录某个元素在当前窗口的出现次数。

当遍历到第 $i$ 个窗口时，新添加了 $b_i$ 进入窗口， $ma p$ 中 $b_i$ 的出现次数加一，同时 $m u lt i se t$ 中删去 $b_i$ 原先的出现次数，加入更新的操作次数。

用 $m u lt i se t$ 的 $. r b e g in ()$ 方法得到最大的出现次数 $x$ ， $k - x$ 即为把 $[i, i + k - 1]$ 修改成连续子数组的最小操作次数。

接着，移动到第 $i + 1$ 个窗口，要删去 $b_{i-k+1}$ ， $ma p$ 中对应的出现次数减一， $m u lt i se t$ 也是对应的删旧增新。

这样就处理出了每个长度为 $k$ 的区间修改为连续子数组的最小操作次数，开个数组记录在对应左端点或者右端点的位置，每次查询直接查即可。

复杂度

时间复杂度 $\log n)$ ，空间复杂度 $O (n)$

代码实现

// Problem: G1. Yunli's Subarray Queries (easy version)
// Contest: Codeforces - Codeforces Round 971 (Div. 4)
// URL: https://codeforces.com/contest/2009/problem/G1
// Memory Limit: 512 MB
// Time Limit: 3000 ms
//
// Powered by CP Editor (https://cpeditor.org)

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

#define int long long

const int N = 2e5 + 5;

int n, k, q;
int a[N], f[N];

void solve()
{
    cin >> n >> k >> q;
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
        f[i] = 1;
        a[i] -= i;
    }
    multiset<int> all;
    unordered_map<int, int> cnt;
    for (int i = 1; i <= n; i++) {
        int v = cnt[a[i]]++;
        if (all.find(v) != all.end())
            all.erase(all.find(v));
        all.insert(v + 1);
        if (i >= k) {
            f[i] = *all.rbegin();
            int w = cnt[a[i - k + 1]]--;
            all.insert(w - 1);
            if (all.find(w) != all.end())
                all.erase(all.find(w));
        }
    }
    while (q--) {
        int l, r;
        cin >> l >> r;
        cout << k - f[r] << '\n';
    }
}

signed main()
{
    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);

    int T = 1;
    cin >> T;
    while (T--) {
        solve();
    }
}

icesmoke

关注

29
点赞
踩
24

收藏

觉得还不错? 一键收藏
0
评论
Codeforces Round 971 (Div. 4)

的区间修改为连续子数组的最小操作次数，开个数组记录在对应左端点或者右端点的位置，每次查询直接查即可。就越小，因此可以二分出靠近零点的整数位置，在这个整数位置周围必然会使得。或者可以直接三分，因为单调递减的曲线，取绝对值后负数的部分会对称到。轴上方，从而使得曲线存在波谷，也就是最小值点，可以三分求出该点。的区间，修改为连续子数组的最少次数，所以可以处理出数组。，下标的距离即为这两个值的差值，则可以同时不修改。原先的出现次数，加入更新的操作次数。的区间修改为连续子数组的最少次数。
复制链接

扫一扫

专栏目录