Codeforces Round #772 (Div. 2) A - E

Kirito_w

已于 2022-02-23 02:37:06 修改

阅读量237

点赞数

文章标签：算法数据结构 c++

于 2022-02-22 18:39:37 首次发布

本文链接：https://blog.csdn.net/weixin_45925735/article/details/123060129

版权

Codeforces Round #772

A. Min Or Sum
B. Avoid Local Maximums
C. Differential Sorting
D. Infinite Set
E. Cars

A. Min Or Sum

题意：

初始时有一个数组 $a$ ，你可以进行一种操作：选择两个不同的下标 $i$ 和 $j$ ，并且构造两个正整数 $x$ 和 $y$ ，使得 $x|y = a_i | a_j$ ，然后用 $x$ 替换掉原数组中的 $a_i$ ， $y$ 替换掉原数组中的 $a_j$ 。
可以进行这样的操作任意次，询问进行完操作之后数组中剩余元素的和最小是多少。

分析：

      首先我们观察操作具有什么性质。例如现在 $a$ 中只有三个数： $7(111)_2$ 和 $4(100)_2$ 以及 $5(101)_2$ ，然后我们会怎么样去替换能使得最后的数加和最小呢？
      首先对于 $7(111)_2$ 和 $4(100)_2$ 来说，可以发现他们都在二进制表示的第三位上有1，而我们的或运算只需要其中某一位有1结果就是1，所以我们可以根据这一点，将某些 $a$ 中的元素在二进制表示的某些位上的1删去。像这里就可以将其变成 $7(111)_2 | 0(000)_2 = 3(011)_2 | 4(100)_2$ 。
      同样的我们无论是剩下的哪一种情况， $5(101)_2$ 中的第一位和第三位都可以删去，因为前两个数或操作后的结果是 $7(111)_2$ 。也就是说，我们可以通过上述操作不断的将有重复的二进制位上的 $1$ 减去，直到对于所有 $a$ 中的元素来说，每一个二进制位上有且只有一个 $1$ ，此时所有元素的加和一定是最小的。且值为 $a$ 中所有元素的或。

题解：

#include<bits/stdc++.h>
#define endl '\n'
#define IO ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> PII;

const int N = 3e5 + 10, M = 2e5 + 10;
const int inf = 0x3f3f3f3f;
const int mod = 998244353;

int a[N];

void solve() {
    int n;
    cin >> n;
    int res = 0;
    for(int i = 1; i <= n; ++ i) cin >> a[i], res |= a[i];
    cout << res << endl;
}


int main() {  
    IO;
    int t;
    cin >> t;
    while(t --) solve();
    return 0;
}
/*
*/

B. Avoid Local Maximums

题意：

      初始时有一个数组 $a$ ，如果 $a$ 中的一个元素既严格大于它左边的元素，又严格大于它右边的元素（即 $a_i > a_{i + 1}且a_i > a_{i - 1}$ ），我们就把这个数称为幸运数， $a_1$ 和 $a_n$ 一定不是幸运数。
      现在定义一种操作，可以选择 $a$ 中任意一个下标，然后将此位置上的数替换成任意一个不超过 $1 e 9$ 的正整数，询问使得 $a$ 数组中不存在幸运数的最小操作是多少，并且输出最终操作后的数组 $a$ 。
分析：
      首先因为需要操作次数最少，所以我们可以贪心的去考虑每一次操作。
      我们分为两种情况去考虑：
      1、如果有两个幸运数之间只相隔了一个数，例如两个幸运数所在的下标为 $i$ , $i + 2$ ，那么我们只需要将下标 $i$ 位置上的数改成 $max(a_i, a_{i + 2})$ 就可以一次消除两个幸运数。这种情况下每两个幸运数才需花费一次操作。
      2、如果两个幸运数不是只相隔一个数，那么我们就需要把每个幸运数所在位置 $x$ 上的数改为 $m a x (x - 1, x + 1)$ 即可。这种情况下每个幸运数需要花费一次操作。

题解：
首先找到所有满足第一种情况的幸运数位置，然后将其改变，如果还存在的幸运数就通过第二种情况改变。

#include<bits/stdc++.h>
#define endl '\n'
#define IO ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> PII;

const int N = 3e5 + 10, M = 2e5 + 10;
const int inf = 0x3f3f3f3f;
const int mod = 998244353;

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

void solve() {
    int n;
    cin >> n;
    int ans = 0;
    for(int i = 1; i <= n; ++ i) cin >> a[i], b[i] = a[i];
    for(int i = 2; i < n; ++ i) {
        if(a[i] > a[i - 1] && a[i] > a[i + 1]) bj[i] = 1;
    }
    for(int i = 2; i < n; ++ i) {
        if(bj[i] == 1 && bj[i + 2] == 1) {  //成对消除
            bj[i] = 0, bj[i + 2] = 0;
            if(a[i] > a[i + 2]) b[i + 1] = a[i];
            else b[i + 1] = a[i + 2];
            ans ++;
        }
    }

    for(int i = 2; i < n; ++ i) {
        if(bj[i] == 1) b[i] = max(b[i - 1], b[i + 1]), ans ++;
    }
    cout << ans << endl;
    for(int i = 1; i <= n; ++ i) cout << b[i] << " ";
    cout << endl;
    for(int i = 1; i <= n; ++ i) bj[i] = 0;
}


int main() {  
    IO;
    int t;
    cin >> t;
    while(t --) solve();
    return 0;
}
/*
*/

C. Differential Sorting

题意：
      初始时有一个数组 $a$ ，将一次操作定义为：选择三个不同的位置 $x ， y ， z （ x < y < z ）$ ，然后将 $a_x$ 替换成 $a_y - a_z$ 。设 $n$ 为数组 $a$ 的大小，最多可以操作 $n$ 次，且操作完的 $a_x|$ 需要严格小于 $1 e 18$ 。
      询问是否可以在 $n$ 次操作内将 $a$ 变为一个非递减序列，如果可以的话还需要输出操作过程。
分析：
      首先我们可以发现，因为 $x ， y ， z$ 有先后顺序，所以实即上 $a$ 数组最后的两个数我们是没有办法改变的，如果最后的两个数已经是递减的了，那么肯定不可能有解。
      然后我们可以从后往前看。对于倒数第三个数来说，只能够用倒数第二个数 $-$ 倒数第一个数。现在的问题就是倒数第四个数需要小于等于倒数第三个数，那么应该使用哪两个数的差值最好呢？贪心的去考虑的话，设目前需要替换的位置为 $i$ ，目前可以得到的最小的数，一定是后缀中最小的数 $a_y)$ $-$ 后缀中最大的数 $a_z)$ ，且 $y < z$ 。但是其实后缀中最大的数已经确定了，肯定是最后一个数，因为我们最终要构造的序列是非递减的，所以最后一个数必须是最大的，也就是说 $z = n$ 。然后后缀最小的数肯定就是目前需要替换的数的后一个数，这也是显然的。所以每一次替换 $i$ 的方案就可以是 $(i, i + 1, n)$ ，如果将 $i$ 替换为后缀最小值 $-$ 后缀最大值依然要大于 $a_{i + 1}$ ，那么显然不可能有解。如此构造后在极限情况下， $a_1$ 最小是 $- 2 e 5 * 1 e 9$ ，也就是 $- 2 e 14$ ，满足 $a_x|$ 不超过 $1 e 18$ 。
      还有另外一种构造方案更为无脑简单，在倒数第一个数和第二个数满足非递减的前提下，第三个数为 $a_{n - 1} - a_n$ ，那么其实第四个数可以构造成和第三个数同样的大小，即也为 $a_{n - 1} - a_n$ ，那么就会变成从第 $1$ 个数到第 $n - 3$ 个数都是相同的大小的非递减序列。此种构造方法需要先判断将 $a_{n - 2}$ 改为 $a_{n-1} - a_n$ 后，这后三个数是否是非递减的，如果不是，那就无解。

题解：
构造方法1：

#include<bits/stdc++.h>
#define endl '\n'
#define IO ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> PII;

const int N = 3e5 + 10, M = 2e5 + 10;
const int inf = 0x3f3f3f3f;
const int mod = 998244353;

ll a[N];
struct node {
    int x, y, z;
};

void solve() {
    int n;
    cin >> n;
    for(int i = 1; i <= n; ++ i) cin >> a[i];
    reverse(a + 1, a + 1 + n);
    if(a[2] > a[1]) {
        cout << -1 << endl;
        return ;
    }
    vector<node> ans;
    for(int i = 3; i <= n; ++ i) {
        if(a[i] > a[i - 1]) {
            ans.push_back({n - i + 1, n - (i - 1) + 1, n});
            a[i] = a[i - 1] - a[1];
            if(a[i] > a[i - 1]) {
                cout << -1 << endl;
                return ;
            }
        }
    }

    cout << ans.size() << endl;
    for(int i = 0; i < ans.size(); ++ i) {
        cout << ans[i].x << " " << ans[i].y << " " << ans[i].z << endl;
    }
}

int main() {  
    IO;
    int t;
    cin >> t;
    while(t --) solve();
    return 0;
}
/*
*/

构造方法2：

#include<bits/stdc++.h>
#define endl '\n'
#define IO ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> PII;

const int N = 3e5 + 10, M = 2e5 + 10;
const int inf = 0x3f3f3f3f;
const int mod = 998244353;

ll a[N];
struct node {
    int x, y, z;
};

void solve() {
    int n, f = 0;
    cin >> n;
    for(int i = 1; i <= n; ++ i) cin >> a[i];
    for(int i = 1; i < n; ++ i) {
        if(a[i] > a[i + 1]) f = 1;
    }
    if(!f) {  //如果已经是非递减
        cout << 0 << endl;
        return ;
    }
    if(a[n - 1] > a[n]) {  //如果倒数前两个已经是递减，无解
        cout << -1 << endl;
        return ;
    }
    if(a[n - 1] - a[n] > a[n - 1]) {  //如果第三个数改完之后还是大于第二个数，无解
        cout << -1 << endl;
        return ;
    }
    vector<node> ans;
    for(int i = n - 2; i >= 1; -- i) {
        ans.push_back({i, n - 1, n}); //把1~n-3都改成第三个数
    }

    cout << ans.size() << endl;
    for(int i = 0; i < ans.size(); ++ i) {
        cout << ans[i].x << " " << ans[i].y << " " << ans[i].z << endl;
    }
}

int main() {  
    IO;
    int t;
    cin >> t;
    while(t --) solve();
    return 0;
}
/*
*/

D. Infinite Set

题意：
首先会给出一个数组 $a$ 和一个正整数 $\leq p \leq 2e5)$ 。定义一个无穷的整数集合 $S$ ， $S$ 中的所有元素 $x$ 都至少满足以下三个条件中的一个：

$1 、$ $a_i (1 \leq i \leq n)$
$2 、$ $x = 2 y + 1$ 且 $\epsilon S$
$3 、$ $x = 4 y$ 且 $\epsilon S$

      现在需要你计算出 $S$ 集合中小于 $2^p$ 的数有多少个，答案对 $1 e 9 + 7$ 取模。
分析：
      因为 $p$ 非常大，所以很显然找到 $S$ 中小于 $2^p$ 的具体是哪些数显然是不可行的，所以我们需要换种思路。
      首先观察条件 $2 ， 3$ 可以发现通过条件 $2$ 生成的一定是一个奇数，而通过条件 $3$ 生成的一定是一个偶数，也就是说通过条件 $2$ 生成的数和通过条件 $3$ 生成的数不可能相同。那么其实我们就可以从奇偶性方面来下手统计集合中数的个数。
      然后观察到 $p$ 是 $2 e 5$ 的大小，那么可能我们可以从这个 $p$ 来入手。
      我们可以将数轴分为： $2 ^ 0, 2 ^ 1 - 1]，[2 ^ 1, 2 ^ 2 - 1]，[2 ^ 2, 2 ^ 3 - 1]……[2 ^ {p - 1}, 2 ^ p - 1]$ 这样的一些段。
      那么对于某一个区间 $2^{i - 1}, 2^i - 1]$ 来说，如果我们想要知道在这个区间之内，有多少在集合中的点，应该怎么统计呢？
在这里插入图片描述

      首先对于区间 $2^{i - 1}, 2^i - 1]$ 内的所有在集合中的奇数 $x$ 来说，它可以从什么地方生成呢？我们可以发现，假设 $2^{i-2}, 2^{i -1}-1]$ 中有 $num1_s$ 个集合 $S$ 中的数，那么对于这个区间内集合 $S$ 中的每一个数，都可以通过条件 $2$ 生成一个在区间 $2^{i - 1}, 2^i - 1]$ 中的奇数。
      而对于区间 $2^{i - 1}, 2^i - 1]$ 内的所有偶数 $y$ 来说，很显然只能通过条件3生成。假设 $2^{i - 3}, 2^{i - 2} - 1]$ 中有 $num2_s$ 个集合 $S$ 中的数，那么对于此区间内的每一个数来说，都可以通过条件 $3$ 生成一个在区间 $2^{i - 1}, 2^i - 1]$ 中的偶数。
      当然我们发现我们没有考虑条件 $1$ 的情况，我们怎么样去统计在区间 $2^{i - 1}, 2^i - 1]$ 内的 $a_j(1 \leq j \leq n)$ 是否被我们通过上述的方法统计进答案中了呢？
      很显然只有当 $a_j$ 无法被任何数通过条件 $2$ 或条件 $3$ 生成时，这个 $a_j$ 才需要被统计，否则就会重复计算，我们把这类无法被生成的点称作"有用的点"。这也说明了初始的 $a$ 数组中并不是所有的点都是"有用的点"，所以我们可以先将数组 $a$ 中"有用的点"都找出来，方便之后统计。
题解：
      首先我们可以先用一个 $s e t$ 将数组 $a$ 中的所有"有用的点"都找出来，这个复杂度是 $O(logn*log(a_i))$ 的。接着把找出来的"有用的点"从小到大排序。
      然后就可以开始统计答案了。我们定义一个 $f$ 数组， $f_i$ 表示从 $1,2^i-1]$ 中有多少个在集合 $S$ 中的点。求解 $f_i$ 的时候，我们可以分奇偶性去转移。
      如果 $i > = 2$ 的话，说明此区间内有奇数能从 $2^{i-2}, 2^{i -1}-1]$ 转移过来，直接让 $f_i$ + $2^{i-2}, 2^{i -1}-1]$ 中且在集合 $S$ 中数的个数。
      如果 $i > = 3$ 的话，说明此区间内有偶数能从 $2^{i-3}, 2^{i -2}-1]$ 转移过来，直接让 $f_i$ + $2^{i-3}, 2^{i -2}-1]$ 中且在集合 $S$ 中数的个数。这部分可以通过前缀和做差求解。
      特殊的情况就是 $i < 31$ 的时候，这种情况下区间 $2^{i - 1}, 2 ^ i - 1]$ 内有可能会存在"有用的点"，所以我们需要找到大小在 $2^{i - 1}, 2 ^ i - 1]$ 中的"有用的点"的个数，然后添加到 $f_i$ 中。这个部分可以通过二分求解。
      记得细节取模即可。

#include<bits/stdc++.h>
#define endl '\n'
#define IO ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> PII;

const int N = 3e5 + 10, M = 2e5 + 10;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;

int a[N];
int f[N];
set<int> S;
int n, p;

bool gen(int x) {
    if(S.count(x)) return false;
    if(x <= 0) return true;
    if(x & 1) {
        return gen(x / 2);
    }
    else {
        if(x % 4 != 0) return true;
        return gen(x / 4);
    }
    return true;
}

void solve() {
    cin >> n >> p;
    for(int i = 1; i <= n; ++ i) cin >> a[i], S.insert(a[i]);
    vector<int> use;  //找到不可能由其他数生成的数
    for(int i = 1; i <= n; ++ i) {
        S.erase(a[i]);
        if(gen(a[i])) use.push_back(a[i]);
        S.insert(a[i]);
    }

    sort(use.begin(), use.end());

    f[0] = 0;  //f[i] 为 小于 2 ^ i的合法数的个数
    for(int i = 1; i <= p; ++ i) {
         f[i] = f[i - 1]; //继承[2 ^ (i - 2), 2 ^ (i - 1) - 1]的在最终集合中的数的个数
         if(i >= 2) f[i] = (f[i] + (f[i - 1] - f[i - 2])) % mod; //[2 ^ (i - 1), 2 ^ i - 1]中奇数的可行的转移是从[2 ^ (i - 2), 2 ^ (i - 1) - 1]
         if(i >= 3) f[i] = (f[i] + (f[i - 2] - f[i - 3])) % mod; //[2 ^ (i - 1), 2 ^ i - 1]中偶数可行的转移是从[2 ^ (i - 3), 2 ^ (i - 2) - 1]
        if(i <= 30) {
            f[i] = (f[i] + (lower_bound(use.begin(), use.end(), (1 << i)) - lower_bound(use.begin(), use.end(), (1 << (i - 1))))) % mod;
            //找到不可能由其他数生成的数中在[2 ^ (i - 1), 2 ^ i - 1]中的数的个数。
        }
        f[i] %= mod;
    }
    cout << (f[p] % mod + mod) % mod << endl;
}

int main() {  
    IO;
    solve();
    return 0;
}
/*
*/

E. Cars

题意：
      在一条数轴上有 $n$ 辆车，每辆车可以有一个初始的方向( $L, R$ )和一个初始的位置，且车的方向之后不会再改变。车会以任意的速度行驶(速度大于0)。
      如果两辆车一定不会相遇，我们称其为不相关。
      如果两辆车一定会相遇，我们称其为相关。（相遇之后车辆照常行驶）
      现在给出 $m$ 条关系，代表车辆之间是相关还是不相关。
      请判断是否存在这样的情况，如果有则输出每辆车的初始位置和方向。
分析：
      首先考虑当两辆车一定不会相遇时，初始的速度方向应该是什么样的。
在这里插入图片描述
      显然其情况应该为上图，因为如果同方向有可能会相遇(当前者车速很小且后者车速很大时)

      然后当两辆车一定会相遇时，情况应该为下图：
在这里插入图片描述
      因为如果方向相同时有可能不相遇(当前者车速很大且后者车速很小时)
      也就是说无论相关还是不相关，只要两辆车存在关系，那么这两辆车的方向就一定不同。
      我们可以把这些关系看作是边，而只有当所有边的两边的点方向都不同时，才会有解。这显然是一个二分图染色问题。
      染色完成之后如果存在解，我们还需要构造一种方案，使得所有的存在的关系（相关及不相关）成立，我们可以先建立一个新的图NewG。
      对于相关的两个点来说：如果我们把染色后方向向左的点称作 $u$ ，方向向右的点称作 $v$ 的话，如果想要使得这两个点相遇， $v$ 肯定需要在 $u$ 的左边，我们可以在NewG中建立一条从 $v \to u$ 的边。
      而对于不相关的两个点来说：如果我们把染色后方向向左的点称作 $u$ ，方向向右的点称作 $v$ 的话，如果想要使得这两个点一定不相遇， $u$ 肯定需要在 $v$ 的左边，我们可以在NewG中建立一条从 $u \to v$ 的边。
      所以我们其实可以得到一个所有的点与点之间的前后关系（偏序集关系），想要解决这个问题我们只需要对NewG拓扑排序即可。如果存在不存在拓扑序，那么说明有冲突，即无解；否则就按拓扑顺序将所有的车从坐标轴上的 $0$ 开始往右放置即可。
题解：

#include<bits/stdc++.h>
#define endl '\n'
#define IO ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> PII;

const int N = 3e5 + 10, M = 2e5 + 10;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;

vector<int> G[N], New[N], res;
int color[N], f, d[N];
int n, m;

struct edge {
    int type;
    int x, y;
}T[M];

struct node {
    int id, col, pos;
};

void dfs(int u, int fa, int col) {
    if(f) return ;
    if(color[u] != 0) {
        if(col != color[u]) {  //染色过程中冲突
            cout << "NO" << endl;
            f = 1;
        }
        return ;
    }
    color[u] = col;
    for(int i = 0; i < G[u].size(); ++ i) {
        int to = G[u][i];
        if(to == fa) continue;
        dfs(to, u, col ^ 1);
    }
}

bool topsort() {
    queue<int> Q;
    for(int i = 1; i <= n; ++ i) {
        if(!d[i]) Q.push(i);
    }
    while(Q.size()) {
        int h = Q.front();
        Q.pop();
        res.push_back(h);
        for(int i = 0; i < New[h].size(); ++ i) {
            int to = New[h][i];
            d[to] --;
            if(d[to] == 0) Q.push(to);
        }
    }
    if(res.size() == n) return true;
    return false;
}

void solve() {
    cin >> n >> m;
    for(int i = 1; i <= m; ++ i) {
        int type, a, b;
        cin >> type >> a >> b;
        G[a].push_back(b), G[b].push_back(a);
        T[i] = {type, a, b};
    }

    for(int i = 1; i <= n; ++ i) 
        if(color[i] == 0) dfs(i, -1, 2);

    if(f) return ;

    for(int i = 1; i <= m; ++ i) {
        int x = T[i].x, y = T[i].y, ty = T[i].type;
        if(ty == 1) {
            if(color[x] == 3) New[x].push_back(y), d[y] ++;
            else New[y].push_back(x), d[x] ++;
        }
        else {
            if(color[x] == 2) New[x].push_back(y), d[y] ++;
            else New[y].push_back(x), d[x] ++;
        }
    }

    if(!topsort()) {  //不存在拓扑序，说明前后关系有冲突
        cout << "NO" << endl;
        return ;
    }

    vector<node> ans;

    int x = 0;
    for(int i = 0; i < res.size(); ++ i, ++ x) ans.push_back({res[i], color[res[i]], x});

    sort(ans.begin(), ans.end(), [&](node a, node b) {return a.id < b.id;});
    
    cout << "YES" << endl;
    for(int i = 0; i < ans.size(); ++ i) cout << ((ans[i].col == 2) ? "R" : "L")  << " " << ans[i].pos << endl;
}

int main() {  
    IO;
    solve();
    return 0;
}
/*
*/

Kirito_w

关注

0
点赞
踩
1

收藏

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

A. Min Or Sum题意：      初始时有一个数组aaa，你可以进行一种操作：选择两个不同的下标iii和jjj，并且构造两个正整数xxx和yyy，使得x∣y=ai∣ajx|y = a_i | a_jx∣y=ai∣aj，然后用xxx替换掉原数组中的aia_iai，yyy替换掉原数组中的aja_jaj。      可以进行这样的操作任意次，询问进行完操作之后数组中剩余元
复制链接

扫一扫