Codeforces Global Round 13 A-D题题解

写在前边

链接：Codeforces Global Round 13

$A,B,C,D$

A. K-th Largest Value

链接：A题链接

题目大意:

有一个字串只由$0、1$组成，有两个操作，$1$是让其中$a_x$变为$1-a_x$，$2$是询问数组中第$k$大的数。

思路：

很简单了，字串中元素只在$0、1$中变化，要问第$k$大的数字，那么非$1$即$0$，就用一个$map$维护$0，1$的数量就好了

代码:

#include <iostream>

#include <cstring>

#include <algorithm>

#include <cstdio>

#include <vector>

#include <map>

#include <cstring>

//#pragma GCC optimize(2)

//#pragma GCC optimize(3,"Ofast","inline")

using namespace std;

#define Inf 0x3f3f3f3f

#define PII pair<int, int>

#define P2LL pair<long long, long long>

#define endl '\n'

typedef long long LL;

typedef unsigned long long ULL;

typedef vector<long long> VLL;

typedef vector<int> VI;

const int Mod = 10000007;

const int N = 1E5 + 10;

int a[N];

void solve() {

    int n, q;

    scanf("%d%d", &n, &q);

    map<int, int> cnt;

    for (int i = 1; i <= n; i++) {

        scanf("%d", &a[i]);

        cnt[a[i]]++;

    }

    while (q--) {

        int t, x;

        scanf("%d%d", &t, &x);

        if (t == 1) {

            if (a[x] == 1) {

                a[x] = 0;

                cnt[0]++, cnt[1]--;

            } else {

                a[x] = 1;

                cnt[1]++, cnt[0]--;

            }

        } else if (t == 2) {

            if (cnt[1] >= x) puts("1");

            else puts("0");

        }

    }

}

int main()

{

    //ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);

    solve();

    return 0;

}

B. Minimal Cost

链接：B题链接

题目大意:

每行一个箱子，第$i$行箱子的坐标为$a_i$，你的任务就是推箱子，然后把利用最小的花费把开一条路使得你可以从左上角走到右下角。

思路：

注意

每行就一个！
你可以随便方向的走！

那么这样就很简单了，只需要在一列箱子中开一个口就好了，然后不断更新答案即可。

代码:

#include <iostream>

#include <cstring>

#include <algorithm>

#include <cstdio>

#include <vector>

#include <map>

#include <cstring>

//#pragma GCC optimize(2)

//#pragma GCC optimize(3,"Ofast","inline")

using namespace std;

#define Inf 0x3f3f3f3f

#define PII pair<int, int>

#define P2LL pair<long long, long long>

#define endl '\n'

typedef long long LL;

typedef unsigned long long ULL;

typedef vector<long long> VLL;

typedef vector<int> VI;

const int Mod = 10000007;

const int N = 110;

int a[N];

void solve() {

    int n, u, v;

    scanf("%d%d%d", &n, &u, &v);

    for (int i = 1; i <= n; i++) scanf("%d", &a[i]);

    int res = 2e9 + 10;

    for (int i = 2; i <= n; i++) {

        if (abs(a[i] - a[i - 1]) > 1) res = 0;

        if (a[i] == a[i - 1]) res = min(res, v + min(v, u));

        if (abs(a[i] - a[i - 1]) == 1) res = min(res, min(v, u));

    }

    printf("%d\n", res);

}

int main()

{

    //ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);

    int t;

    scanf("%d", &t);

    while (t--) {

        solve();

    }

    return 0;

}

C. Pekora and Trampoline

链接：C题链接

题目大意:

跳床，有$n$个跳床，床的高度为$s_i$，每在上边跳一次那么$s_i$减小$1$，每次跨越着跳，当前在$i$那么一步会跳到$i + s_i$去，每次可以从任意一个跳床开始跳，直到跳出所有跳床算一次操作，那么经过多少次操作，所有的$s_i$都变为$1$，注意已经变为$1$的床不会再减小。

思路：

贪心的想，假如我们要是所有的床都变为$1$，那么我们每次一定得从最左边跳到最右边，所以不如直接贪心加模拟的方法解题。

1.维护一个$p$数组，$p_i$表示已经在第$i$张床上跳了$p_i$次。

2.更新答案$res += max(0, s[i] - p[i] - 1)$，即如果$s[i] - 1 > p[i]$说明还需要在第i张床上跳$s[i] - p[i] - 1$次，如果$s[i] - 1 \leq p[i]$，那么说明第$i$张床上$s[i]$已经变为$1$。同时如果在第i张床上跳，因为$s[i]$每次减一，直到减法为$1$($s[i] = 1$就没必要跳了)，那么会影响后边第$i + s[i], ...,i + 2$床。

3. 还有就是，如果第$i$张床上跳的过多，即$s[i]$已经变为$1$了，那么第$i$张床上多余的跳跃次数可以转移到下一张床上。

代码:

#include <iostream>

#include <cstring>

#include <algorithm>

#include <cstdio>

#include <vector>

#include <map>

#include <cstring>

//#pragma GCC optimize(2)

//#pragma GCC optimize(3,"Ofast","inline")

using namespace std;

#define Inf 0x3f3f3f3f

#define PII pair<int, int>

#define P2LL pair<long long, long long>

#define endl '\n'

typedef long long LL;

typedef unsigned long long ULL;

typedef vector<long long> VLL;

typedef vector<int> VI;

const int Mod = 10000007;

LL gcd(LL a, LL b) {

    return b ? gcd(b, a % b) : a;

}

const int N = 5010;

int s[N];

int p[N];

void solve() {

    int n;

    scanf("%d", &n);

    for (int i = 1; i <= n; i++) scanf("%d", &s[i]);

    LL res = 0;

    memset(p, 0, sizeof p);

    for (int i = 1; i <= n; i++) {

        int x = max(0, s[i] - p[i] - 1);

        res += x;

        for (int j = i + 2; j <= min(n, i + s[i]); j++) {

            p[j]++;

        }

        p[i + 1] += max(p[i] - s[i] + 1, 0);

    }

    printf("%lld\n", res);

}

int main()

{

    //ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);

    int t;

    scanf("%d", &t);

    while (t--) {

        solve();

    }

    return 0;

}

D. Zookeeper and The Infinite Zoo

链接：D题链接

题目大意:

可以在结点$u$到$u+v$连一条边，当前仅当$u \, \& \, v = v$的时候，然后给定$q$个询问，每次两个端点$u_i$, $v_i$问是否能从$u_i$到$v_i$。

思路：

首先发现两个性质：

假如现结点为$v$,那么它一定可以转移到$2 * v$,很显然。
还有就是要满足$u \, \& \, v = v$,那么起码满足$u \leq v$,否则直接$pass$掉即可

然后再推到发现，$u$中$1$的个数必须要大于等于$v$中$1$的个数，为什么呢？

我们令$k = v - u$.

我们发现，因为$u \, \& \, k = k$，那么说明，$u$与$k$的二进制数中存在$1$的位数一定在同一位啊，否则不可能按位与得到$k$，然后实现$u$转移到$u+k = v$,那么$v$相对于$u$来说肯定是$u$其中的某些$1$进位才得到了$u+k = v$，那么所以说$v$中$1$得个数肯定是小于等于$u$中$1$得个数的，举两个例子：

$u_(2) = 011$, $k_(2) = 001$,那么$v_(2) = 100$。$1$的个数减少了。

$u_(2) = 011$, $k_(2) = 011$,那么$v_(2) = 110$。$1$的个数不变。

那么单纯满足这个条件就对了吗，当然不是。

还要满足，$v$中的每一位$1$要高于$u$中每一位的$1$，总不能越转移越低吧。那么满足这两个条件，$u$到$v$就可以进行转移了,那么上边的操作都可以用$lowbit$运算就可以了

代码:

#include <iostream>

#include <cstring>

#include <algorithm>

#include <cstdio>

#include <vector>

#include <map>

#include <cstring>

//#pragma GCC optimize(2)

//#pragma GCC optimize(3,"Ofast","inline")

using namespace std;

#define Inf 0x3f3f3f3f

#define PII pair<int, int>

#define P2LL pair<long long, long long>

#define endl '\n'

#define pub push_back

#define pob pop_back

typedef long long LL;

typedef unsigned long long ULL;

typedef vector<long long> VLL;

typedef vector<int> VI;

const int Mod = 10000007;

int lowbit(int x) {

    return x & (-x);

}

void solve() {

    int u, v;

    scanf("%d%d", &u, &v);

    if (u > v) {

        puts("NO");

        return;

    }

    int uu = u, vv = v;

    int cnt1 = 0, cnt2 = 0;

    while (uu) { //u中1的个数

        uu -= lowbit(uu);

        cnt1++;

    }

    while (vv) { //v中1的个数

        vv -= lowbit(vv);

        cnt2++;

    }

    while (u && v) { //必须往高位推才行

        if (lowbit(u) > lowbit(v)) {

            puts("NO");

            return;

        }

        u -= lowbit(u), v -= lowbit(v);

    }

    if (cnt1 >= cnt2) puts("YES");

    else puts("NO");

}

int main()

{

    //ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);

    int t;

    scanf("%d", &t);

    while (t--) {

        solve();

    }

    return 0;

}