Codeforces Round #782 (Div. 2)

最新推荐文章于 2022-04-22 19:47:29 发布

枉玊

最新推荐文章于 2022-04-22 19:47:29 发布

阅读量226

点赞数 1

文章标签：算法

本文链接：https://blog.csdn.net/a12377978/article/details/124247860

版权

Codeforces Round #782 (Div. 2)

A. Red Versus Blue

[Link](Problem - A - Codeforces)

题意

让你构造一个长度为 $n$ 的字符串有 $r$ 个 $R$ ， $b$ 个 $B$ 且 $\ \ b+r=n$ 且连续相同的字符串长度最大值最小。

思路

贪心

由于 $r > b$ ，我们最优解应该是将 $r$ 分成尽量多且平均的段，这些段由 $B$ 来分割，也就是将 $r$ 分成 $b + 1$ 份，且尽可能均衡，所以先给每份一个 $r / (b + 1)$ ，剩下的 $r\%(b+1)$ 从前往后依次分给每一份直到分完即可。

Code

#include <bits/stdc++.h>
#define x first
#define y second
#define debug(x) cout<<#x<<":"<<x<<endl;
using namespace std;
typedef long double ld;
typedef long long LL;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
typedef unsigned long long ULL;
const int N = 1e5 + 10, M = 2 * N, INF = 0x3f3f3f3f, mod = 1e9 + 7;
const double eps = 1e-8, pi = acos(-1), inf = 1e20;
int dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1};
int h[N], e[M], ne[M], w[M], idx;
void add(int a, int b, int v = 0) {
    e[idx] = b, w[idx] = v, ne[idx] = h[a], h[a] = idx ++;
}
int n, m, k;
int a[N];
int main() {
    ios::sync_with_stdio(false), cin.tie(0);
    int T;
    cin >> T;
    while (T -- ) {
        int b, r; cin >> n >> r >> b;
        int k = r / (b + 1);
        for (int i = 1; i <= b + 1; i ++) a[i] = k;
        int kk = r % (b + 1);
        for (int i = 1; i <= kk; i ++) a[i] ++;
        for (int i = 1; i <= b + 1; i ++) {
            while (a[i] --) cout << 'R';
            if (i != b + 1) cout << 'B';
        }

        cout << '\n';
    }
    return 0;
}

B. Bit Flipping

[Link](Problem - B - Codeforces)

题意

给你一个 $01$ 串，每次你可以选择一个位置 $i$ 并让除了 $i$ 以外所有的位置取反，问你 $k$ 次操作后字典序最大是多少。

思路

贪心

因为要字典序最小，我们从前往后贪心，对于每一位我们想让它变成 $1$ ，当前这一位的是否改变取决于转的奇偶，对于第 $i$ 位分类来看：

当前 $1$ 则我们想让它转偶数次，因此如果 $k\%2==1$ ，我们就让当前这一位转一次，其它位对它的影响就是偶数了
当前 $0$ 则我们想让它转奇数次，因此如果 $k\%2==0$ ，我们就让当前这一位转一次，其它位对它的影响就是奇数了

如果还剩操作数，这些操作都给最后一位，如果贪到中间操作数用完了，注意后面数的奇偶性改变一下。

Code

#include <bits/stdc++.h>
#define x first
#define y second
#define debug(x) cout<<#x<<":"<<x<<endl;
using namespace std;
typedef long double ld;
typedef long long LL;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
typedef unsigned long long ULL;
const int N = 2e5 + 10, M = 2 * N, INF = 0x3f3f3f3f, mod = 1e9 + 7;
const double eps = 1e-8, pi = acos(-1), inf = 1e20;
int dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1};
int h[N], e[M], ne[M], w[M], idx;
void add(int a, int b, int v = 0) {
    e[idx] = b, w[idx] = v, ne[idx] = h[a], h[a] = idx ++;
}
int n, m, k;
int a[N], b[N];
int main() {
    ios::sync_with_stdio(false), cin.tie(0);
    int T;
    cin >> T;
    while (T -- ) {
        cin >> n >> k;
        int kk = k;
        string str; cin >> str;
        for (int i = 0; i < n; i ++) a[i] = 0, b[i] = (str[i] - '0');
        int i = 0;
        for (; i < n; i ++) {
            if (!k) break;
            if (i == n - 1) {
                a[i] = k;
                k = kk - k;
                k %= 2;
                if (k) b[i] ^= 1;
                break;
            }
            if (str[i] == '1' && kk % 2 == 0) b[i] = 1;
            else if (str[i] == '1' && kk % 2) {
                a[i] ++;
                k --;
                b[i] = 1;
                if (!k) break;
            }
            else if (str[i] == '0' && kk % 2) b[i] = 1;
            else {
                a[i] ++;
                k --;
                b[i] = 1;
                if (!k) break;
            }
        } 
        i ++;
        for (; i < n; i ++) 
            if (kk % 2) b[i] ^= 1;
        for (int i = 0; i < n; i ++) cout << b[i];
        cout << '\n';
        for (int i = 0; i < n; i ++)
            cout << a[i] << ' ';
        cout << '\n';
        }
    return 0;
}

C. Line Empire

[Link](Problem - C - Codeforces)

题意

数轴有 $n$ 个单调上升的点，一开始你在 $0$ 号点，假设当前你在第 $i$ 个点你有两个操作：

占领右边第一个没被占领的点 $x_j$ ，花费 $b\times |x_j-x_i|$
移动到右边某个占领的点 $x_j$ ，花费 $a\times|x_j-x_i|$

问你占领 $n$ 个点的最小花费是多少。

思路

贪心，前缀和

我们记录一下当前在哪个位置 $p r e$ ，设第 $i$ 个位置为 $x_i$ ， $s_i=\sum_{j=1}^{j=i}x_j$ ，每次我们占领一个位置后判断一下，从当前位置移动到占领的位置是否会更优，即是否满足 $a\times|x_i-x_{pre}|+(s_n - s_i-(n-i)\times x_{pre})<(s_n-s_i-(n-i)\times x_i)$ ，整理一下即是否满足 $a\times |x_i-x_{pre}|+(n-1)\times(x_i-x_{pre})<0$ ，如果满足我们就移动。

Code

#include <bits/stdc++.h>
#define x first
#define y second
#define debug(x) cout<<#x<<":"<<x<<endl;
using namespace std;
typedef long double ld;
typedef long long LL;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
typedef unsigned long long ULL;
const int N = 2e5 + 10, M = 2 * N, INF = 0x3f3f3f3f, mod = 1e9 + 7;
const double eps = 1e-8, pi = acos(-1), inf = 1e20;
int dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1};
int h[N], e[M], ne[M], w[M], idx;
void add(int a, int b, int v = 0) {
    e[idx] = b, w[idx] = v, ne[idx] = h[a], h[a] = idx ++;
}
int n, m, k;
LL s[N], p[N];
int main() {
    ios::sync_with_stdio(false), cin.tie(0);
    int T;
    cin >> T;
    while (T -- ) {
        LL a, b;
        cin >> n >> a >> b;
        for (int i = 1; i <= n; i ++) cin >> p[i];
        for (int i = 1; i <= n; i ++) s[i] += s[i - 1] + p[i];
        LL res = 0;
        int id = 0;
        for (int i = 1; i <= n; i ++) {
            res += b * (p[i] - p[id]);
            if (a * (p[i] - p[id]) + b * ((n - i) * (p[id] - p[i])) < 0) res += a * (p[i] - p[id]), id = i;
        }
        
        cout << res << '\n';
    }
    return 0;
}

D. Reverse Sort Sum

[Link](Problem - D - Codeforces)

题意

给你一个只含 $0, 1$ 的数组 $A$ ，设 $f (k, A)$ 为将 $A$ 的前 $k$ 个数从小到大排序，之后得到新数组 $B_k$ ，设 $C=B_1+B_2+...+B_n$ ，每个 $B$ 的每一位分别相加，现给你 $C$ 让你求出与之对应的 $A$ 。

思路

构造

这种题就是要从小样例来推大的，我们要找一些性质，首先发现因为每个 $B_i$ 只是改变了原数组的顺序，因此我们统计一下 $C$ 的和 $s u m$ ， $A$ 中的 $1$ 的数量即 $c n t = s u m / n$ 。

观察一下每个 $C_i$ 是如何构成的：对于每个 $C_i$ 在 $B_i$ 之前加的是原来的 $A_i$ ， $B_i$ 包括之后是排序以后加的对应 $A_i$ ，如果可以将 $B_i$ 以及之后的这些加的数都消除掉，那么就可以直接判断当前这一位是否大于 $0$ 来确定这一位 $A_i$ 是什么了。

因此我们可以倒着考虑，维护当前还剩 $c n t$ 个 $1$ 没放置，对于第 $i$ 轮，因为会将 $[1, i]$ 排序，因此 $[i - c n t + 1, i]$ 这些位置都是 $1$ ，相当于这些位置都会对对应的 $C_i$ 加一，倒着考虑就将这些位置减 $1$ ，如果操作完第 $i$ 个位置大于 $0$ 那么这个位置就是 $1$ 。这样区间减对于确定第 $i - 1$ 个位置（即判断第 $i - 1$ 轮）时第 $i$ 个位置（即第 $i$ 轮）对它影响就消除了，同理前面的也均在那些轮消除了。

对于动态区间加，和查询某个位置的值，我们可以对原数组差分一下，用个树状数组来维护。

注意特判一下第一个位置，因为第一个位置前面没有位置，他没有每个 $C_i$ 在 $B_i$ 之前加的是原来的 $A_i$ ，无论怎么减完都是 $0$ ，因此最后特判一下是否还剩下 $1$ 即可。

Code

#include <bits/stdc++.h>
#define x first
#define y second
#define debug(x) cout<<#x<<":"<<x<<endl;
using namespace std;
typedef long double ld;
typedef long long LL;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
typedef unsigned long long ULL;
const int N = 2e5 + 10, M = 2 * N, INF = 0x3f3f3f3f, mod = 1e9 + 7;
const double eps = 1e-8, pi = acos(-1), inf = 1e20;
int dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1};
int n, m, k;
int a[N], c[N];
int tr[N];
int lowbit(int x) {
    return x & -x;
}
void add(int x, int v) {
    for (; x <= n; x += lowbit(x)) tr[x] += v;
}
int sum(int x) {
    int res = 0;
    for (; x; x -= lowbit(x)) res += tr[x];
    return res;
}
int main() {
    ios::sync_with_stdio(false), cin.tie(0);
    int T;
    cin >> T;
    while (T -- ) {
        cin >> n;
        LL cnt = 0;
        for (int i = 1; i <= n; i ++) {
            cin >> a[i];
            cnt += a[i];
            c[i] = 0;
            tr[i] = 0;
        }
       
        for (int i = n; i; i --) a[i] -= a[i - 1], add(i, a[i]);
        
        cnt /= n;
        for (int i = n; i; i --) {
            if (!cnt) break;
            add(i - cnt + 1, -1);
            if (sum(i) > 0) c[i] = 1, cnt --;
        }

        if (cnt) c[1] = 1; 
        for (int i = 1; i <= n; i ++)
            cout << c[i] << ' ';
        
        cout << '\n';
    }
    return 0;
}

枉玊

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Codeforces Round #782 (Div. 2)

Codeforces Round #782 (Div. 2)A. Red Versus Blue[Link](Problem - A - Codeforces)题意让你构造一个长度为nnn的字符串有rrr个RRR，bbb个BBB且b<r  b+r=nb<r \ \ b+r=nb<r  b+r=n且连续相同的字符串长度最大值最小。思路贪心由于r>br>br>b，我们最优解应该是将rrr分成尽量多且平均的段，这些段
复制链接

扫一扫