Educational Codeforces Round 47 (Rated for Div. 2)

最新推荐文章于 2024-05-31 00:35:44 发布

步六孤明琪

最新推荐文章于 2024-05-31 00:35:44 发布

阅读量179

点赞数

分类专栏：【类型】做题记录【比赛】codeforces

本文链接：https://blog.csdn.net/six_solitude/article/details/81073042

版权

【类型】做题记录同时被 2 个专栏收录

46 篇文章 0 订阅

订阅专栏

【比赛】codeforces

4 篇文章 0 订阅

订阅专栏

【比赛链接】

Educational Codeforces Round 47 (Rated for Div. 2)

【A】Game Shopping

【题意】有 $n$ 个物品， $m$ 个账单，尝试用最前面的账单去买物品，若能买，账单和物品都转到下一个，否则转到下一个物品而依然使用现在的账单。问能买到多少物品。
【题解】按题意模拟即可。
时间复杂度 $O(N+M)$
【代码】

#include<bits/stdc++.h>
#define INF 0x3f3f3f3f
#define LL  long long
#define MAXN    10010
using namespace std;
int n, m, a[MAXN], b[MAXN];

template <typename T> void chkmin(T &x, T y){x = min(x, y);}
template <typename T> void chkmax(T &x, T y){x = max(x, y);}
template <typename T> void read(T &x){
    x = 0; int f = 1; char ch = getchar();
    while (!isdigit(ch)) {if (ch == '-') f = -1; ch = getchar();}
    while (isdigit(ch)) {x = x * 10 + ch - '0'; ch = getchar();}
    x *= f;
}

int main(){
    read(n), read(m);
    for (int i = 1; i <= n; ++i)
        read(a[i]);
    for (int i = 1; i <= m; ++i)
        read(b[i]);
    int cur = 1, ans = 0;
    for (int i = 1; i <= n; ++i){
        if (b[cur] >= a[i]) ++ans, ++cur;
        if (cur > m) break;
    }
    printf("%d\n", ans);
    return 0;
}

【B】Minimum Ternary String

【题意】给出一个长度为 $n$ 的仅包含 $0,1,2$ 的序列，每次可以交换相邻的 $0,1$ 或者相邻的 $1,2$ ，问在若干次操作后可以得到的字典序最小的序列是什么。
【题解】考虑一个问题，原先在 $2$ 后的 $0$ ，无论如何操作，最后一定在 $2$ 之后。那么直接从后向前贪心，每碰到一个 $2$ 就将后面的 $0$ 从后向前放并且将 $2$ 放入，最后先放 $1$ 再放 $0$ 即可。
时间复杂度 $O(N)$
【代码】

#include<bits/stdc++.h>
#define INF 0x3f3f3f3f
#define LL  long long
#define MAXN    100010
using namespace std;
char s[MAXN], t[MAXN];
int size[3], last;

template <typename T> void chkmin(T &x, T y){x = min(x, y);}
template <typename T> void chkmax(T &x, T y){x = max(x, y);}
template <typename T> void read(T &x){
    x = 0; int f = 1; char ch = getchar();
    while (!isdigit(ch)) {if (ch == '-') f = -1; ch = getchar();}
    while (isdigit(ch)) {x = x * 10 + ch - '0'; ch = getchar();}
    x *= f;
}

int main(){
    scanf("%s", s + 1);
    int n = strlen(s + 1);
    last = n;
    for (int i = n; i >= 1; --i){
        if (s[i] == '0') ++size[0];
        else if (s[i] == '1') ++size[1];
        else {
            while (size[0] > 0){
                t[last] = '0', --size[0];
                --last;
            }
            t[last] = '2';
            --last;
        }
    }
    while (size[0] + size[1]){
        if (size[1] > 0) t[last] = '1', --size[1];
        else if (size[0] > 0) t[last] = '0', --size[0];
        --last;
    }
    printf("%s", t + 1);
    return 0;
}

【C】Annoying Present

【题意】给出一个长度为 $n$ 的一开始全为零的序列，有 $m$ 次操作。每次操作给出两个数 $x$ 和 $d$ ，你可以选择一个位置 $pos$ ，使得序列中的每个位置 $i$ 加上 $x+d*|pos-i|$ ，现在需要使序列的平均数最大。
【题解】显然，题目要求就是要使得序列的和最大。 $x$ 对于位置的选择没有影响，直接统计入答案即可。若 $d$ 为正，则将 $pos$ 定于序列一端，否则将 $pos$ 定于序列中间，然后就是一个等差数列求和。特别的，本题需要注意精度误差。
时间复杂度 $O(M)$
【代码】

#include<bits/stdc++.h>
#define INF 0x3f3f3f3f
#define LL  long long   
using namespace std;
int n, m;
LL ans;

template <typename T> void chkmin(T &x, T y){x = min(x, y);}
template <typename T> void chkmax(T &x, T y){x = max(x, y);}
template <typename T> void read(T &x){
    x = 0; int f = 1; char ch = getchar();
    while (!isdigit(ch)) {if (ch == '-') f = -1; ch = getchar();}
    while (isdigit(ch)) {x = x * 10 + ch - '0'; ch = getchar();}
    x *= f;
}

int main(){
    read(n), read(m);
    ans = 0;
    for (int i = 1; i <= m; ++i){
        int x, d; read(x), read(d);
        ans += 1ll * x * n;
        if (d > 0) ans += 1ll * n * (n - 1) / 2 * d;
        else {
            int tmp = n / 2;
            if (n % 2) ans += 1ll * (tmp + 1) * tmp * d;
            else ans += 1ll * tmp * (tmp - 1) / 2 * d, 
                 ans += 1ll * tmp * (tmp + 1) / 2 * d;
        }
    }
    printf("%.10lf\n", 1.0 * ans / n);
    return 0;
}

【D】Relatively Prime Graph

【题意】构造一张有 $n$ 个点， $m$ 条边的无向连通图，其中节点编号为 $1$ ~ $n$ ，且无重边自环，使得图中的每条边<script type="math/tex" id="MathJax-Element-33"> </script>都满足 $uv$ 互质。或输出无解。
【题解】首先，若 $m<n-1$ ，无解，无法构成连通图，否则一定可以将所有除了 $1$ 号节点以外的点连向 $1$ 号节点使得图连通。其次，若 $\sum_{i=2}^{n}\phi(i)<m$ ，其中 $\phi(n)$ 表示 $1$ ~ $n$ 中与 $n$ 互质的数的个数，则合法的总边数小于 $m$ ，无解。剩余情况有解，分析发现， $\sum_{i=2}^{n}\phi(i)$ 的增长速度很快，在 $n$ 很小的时候就超过了 $10^5$ ，直接暴力构造即可。
时间复杂度 $O(NlogN + K^2logK)$ ，其中 $K$ 满足 $\sum_{i=2}^{K}\phi(i)\geq m$
【代码】

#include<bits/stdc++.h>
#define INF 0x3f3f3f3f
#define LL  long long
#define MAXN    100010
using namespace std;
int n, m, f[MAXN], p[MAXN], pri[MAXN], cnt;

template <typename T> void chkmin(T &x, T y){x = min(x, y);}
template <typename T> void chkmax(T &x, T y){x = max(x, y);}
template <typename T> void read(T &x){
    x = 0; int f = 1; char ch = getchar();
    while (!isdigit(ch)) {if (ch == '-') f = -1; ch = getchar();}
    while (isdigit(ch)) {x = x * 10 + ch - '0'; ch = getchar();}
    x *= f;
}

int gcd(int a, int b){
    if (a == 0 || b == 0) return a + b;
    else return gcd(b, a % b);
}

int main(){
    read(n), read(m);
    if (m < n - 1) {printf("Impossible\n"); return 0;}
    for (int i = 1; i <= n; ++i)
        f[i] = i;
    for (int i = 1; i <= n; ++i)
        for (int j = i + i; j <= n; j += i)
            f[j] -= f[i];
    LL tot = 0;
    for (int i = 2; i <= n; ++i)
        tot += f[i];
    if (tot < m) {printf("Impossible\n"); return 0;}
    printf("Possible\n");
    m -= n - 1;
    tot = 0;
    for (int i = 2; i <= n; ++i)
        printf("%d %d\n", i, 1);
    for (int i = 2; i <= n; ++i){
        for (int j = 2; j < i; ++j){
            if (tot == m) break;
            if (gcd(i, j) == 1) {printf("%d %d\n", i, j); ++tot;}
        }
        if (tot == m) break;
    }
    return 0;
}

【E】Intercity Travelling

【题意】从起点到终点之间共有 $n$ 段路程， $n-1$ 个休息站，每个休息站都有 $\frac{1}{2}$ 的概率会停下来休息。每段路的难度为 $a_p$ ，其中 $p$ 是指上一个停下来休息的位置到这条路的距离 $+1$ 。求从起点走到终点的期望难度，答案乘 $2^{n-1}$ 模 $998244353$ 。
【题解】根据期望的线性可加性质，和的期望等于期望的和，问题转化为求每段路的期望难度之和。对于每一段，贡献是 $a_1$ 的的概率是上一个点为休息站的概率( $\frac{1}{2}$ )，贡献为 $a_2$ 的概率是上一个点不是休息站且再上一个点是休息站的概率( $\frac{1}{2^2}$ )……总结起来，每段路的期望难度 $e(x)=\sum_{i=1}^{x}(\frac{1}{2^i}*a_i)+2^x*a_x$ ，答案就是 $\sum_{i=1}^{n}e(i)$ ，最后还要按照题目要求乘上 $2^{n-1}$ 。
时间复杂度 $O(N)$
【代码】

#include<bits/stdc++.h>
#define INF 0x3f3f3f3f
#define LL  long long
#define mod 998244353
#define MAXN    1000010
using namespace std;
LL f[MAXN], a[MAXN], b[MAXN], inv;
int n;

template <typename T> void chkmin(T &x, T y){x = min(x, y);}
template <typename T> void chkmax(T &x, T y){x = max(x, y);}
template <typename T> void read(T &x){
    x = 0; int f = 1; char ch = getchar();
    while (!isdigit(ch)) {if (ch == '-') f = -1; ch = getchar();}
    while (isdigit(ch)) {x = x * 10 + ch - '0'; ch = getchar();}
    x *= f;
}

LL qpow(LL a, int b){
    LL ret = 1;
    while (b){
        if (b & 1) ret = ret * a % mod;
        a = a * a % mod;
        b >>= 1;
    }
    return ret;
}

int main(){
    read(n);
    for (int i = 1; i <= n; ++i)
        read(a[i]);
    f[1] = a[1];
    inv = qpow(2, mod - 2);
    LL tnp = inv;
    b[1] = a[1] * inv % mod;
    b[2] = (b[1] + a[2] * inv % mod) % mod;
    for (int i = 3; i <= n; ++i){
        inv = inv * tnp % mod;
        b[i] = (b[i - 1] - inv * a[i - 1] % mod + a[i] * inv % mod) % mod;
    }
    for (int i = 2; i <= n; ++i)
        f[i] = (f[i - 1] + b[i]) % mod;
    LL ans = f[n] * qpow(2, n - 1) % mod;
    ans = (ans + mod) % mod;
    printf("%I64d\n", ans);
    return 0;
}

【F】Dominant Indices

【题意】给出一棵以 $1$ 号节点为根的树。求出对于 $1$ ~ $n$ 每个节点，在其子树中宽度最大的一层到该节点的距离，若有多层宽度相同取深度最小的。
【题解】对每个节点维护其子树中各个深度的点的个数，在原树上从叶子向上做线段树合并。每到一个节点就在线段树上二分出最大值，求出答案并记录一下。
时间复杂度 $O(NlogN)$
【代码】

#include<bits/stdc++.h>
#define INF 0x3f3f3f3f
#define LL  long long
#define MAXN    1000004
using namespace std;
int n, ans[MAXN];
vector <int> a[MAXN];

template <typename T> void chkmin(T &x, T y){x = min(x, y);}
template <typename T> void chkmax(T &x, T y){x = max(x, y);}
template <typename T> void read(T &x){
    x = 0; int f = 1; char ch = getchar();
    while (!isdigit(ch)) {if (ch == '-') f = -1; ch = getchar();}
    while (isdigit(ch)) {x = x * 10 + ch - '0'; ch = getchar();}
    x *= f;
}

struct Segment_Tree{
    struct info{int ls, rs, maxn;}a[MAXN * 26];
    int root[MAXN], cnt, n;
    void push_up(int pos){
        a[pos].maxn = max(a[a[pos].ls].maxn, a[a[pos].rs].maxn);
    }
    int merge(int x, int y, int l, int r){
        if (x == 0 || y == 0) return x + y;
        if (l == r){
            a[x].maxn = a[x].maxn + a[y].maxn;
            return x;
        }
        int mid = (l + r) >> 1;
        a[x].ls = merge(a[x].ls, a[y].ls, l, mid);
        a[x].rs = merge(a[x].rs, a[y].rs, mid + 1, r);
        push_up(x);
        return x;
    }
    void merge(int p, int x, int y){
        root[p] = merge(root[x], root[y], 1, n);
    }
    void modify(int &pos, int l, int r, int p, int d){
        if (!pos) pos = ++cnt;
        if (l == r) {a[pos].maxn += d; return;}
        int mid = (l + r) >> 1;
        if (p <= mid) modify(a[pos].ls, l, mid, p, d);
        else modify(a[pos].rs, mid + 1, r, p, d);
        push_up(pos);
    }
    void modify(int T, int p, int d){
        modify(root[T], 1, n, p, d);
    }
    void init(int x){
        n = x;
        cnt = 0;
    }
    int query(int pos, int l, int r){
        if (l == r) return l;
        int mid = (l + r) >> 1;
        if (a[a[pos].ls].maxn == a[pos].maxn) return query(a[pos].ls, l, mid);
        else return query(a[pos].rs, mid + 1, r);
    }
    int query(int T){
        return query(root[T], 1, n);
    }
}sgt; 

void dfs(int pos, int dad, int dep){
    bool is_leaf = 1;
    for (unsigned i = 0, si = a[pos].size(); i < si; ++i){
        int son = a[pos][i];
        if (son != dad){
            dfs(son, pos, dep + 1);
            is_leaf = 0;
        }
    }
    if (is_leaf) {
        ans[pos] = 0;
        sgt.modify(pos, dep, 1);
    } else {
        for (unsigned i = 0, si = a[pos].size(); i < si; ++i){
            int son = a[pos][i];
            if (son != dad){
                sgt.merge(pos, pos, son);
            }
        }
        sgt.modify(pos, dep, 1);
        ans[pos] = sgt.query(pos) - dep;
    }
}

int main(){
    read(n);
    for (int i = 1; i < n; ++i){
        int u, v; read(u), read(v);
        a[u].push_back(v);
        a[v].push_back(u);
    }
    sgt.init(n);
    dfs(1, 0, 1);
    for (int i = 1; i <= n; ++i)
        printf("%d\n", ans[i]);
    return 0;
}

【G】Allowed Letters

【题意】给出一个长度为 $n$ 的仅包含字符 $'a'$ ~ $'f'$ 的字符串，每次可以任意交换两个位置的字符。对于一些位置，规定这个位置只能选择哪些字符，对于其他没有规定的位置，可以选择任意的字符。求交换后的字典序最小的合法字符串，或输出无解。
【题解】先考虑一种可以判断是否有解的方法。用网络流做二分图匹配，左边一排点表示 $'a'$ ~ $'f'$ ，右边一排点二进制表示可以选哪些字符。 $S$ 向左边一排点连边，流量为这种字符的数量；左边一排点向右边一排点中选择这种字符的点连边，流量为 $INF$ ；右边一排点向 $T$ 连边，流量为满足这种限制的位置的数量。若满流，即存在完美匹配，则有解，否则无解。
此时考虑字典序最小的限制，贪心地从前向后逐位确定，每一次强制一条边至少要流过 $1$ 的流量，然后判断是否还存在完美匹配即可，那么这样我们就得到了一种退流的做法。
但这是一张二分图，判断二分图的完美匹配是否存在可以使用Hall定理。Hall定理：二分图 $G$ 中的两部分顶点组成的集合分别为 $X$ ， $Y$ ，其中 $|X|\leq|Y|$ ，存在完美匹配的充要条件是： $X$ 中的任意 $k$ 个点至少与 $Y$ 中的 $k$ 个点相邻( $1\leq k\leq |X|$ )。
我们称在左边一排点中选择的可重集合为 $x$ ，右边一排点中选择的可重集合为 $y$ 。考虑若一种存在情况中将所有在这种情况的子集都选上时，满足 $|x|\geq |y|$ ，那么 $y$ 的所有不改变存在性的子集都满足（相当于 $|x|$ 不变 $|y|$ 减小），所以只要枚举每一种存在情况进行判断即可。
具体实现，记录 $f[pos][s]$ 表示从pos向后有多少位置的 $mask$ 是 $s$ 的子集，从前向后从小到大枚举放哪个字母，更改 $sum$ ，若对于下一个位置 $pos$ ，满足 $\forall s$ ， $\sum\limits_{t\in s}sum[t]\geq f[pos][s]$ 则表示可行，否则需将 $sum$ 改回来并尝试下一个字母。若一个位置放每一种字母都不可行，输出无解。
时间复杂度 $O(N*A^2*2^A)$ ，其中 $A$ 为字符集大小，本题中 $A=6$
【代码】

#include<bits/stdc++.h>
#define INF 0x3f3f3f3f
#define LL  long long
#define MAXN    100010
using namespace std;
int n, m, sum[8], f[MAXN][(1 << 6) + 2], mask[MAXN], maxn;
char s[MAXN], t[8], ans[MAXN];

template <typename T> void chkmin(T &x, T y){x = min(x, y);}
template <typename T> void chkmax(T &x, T y){x = max(x, y);}
template <typename T> void read(T &x){
    x = 0; int f = 1; char ch = getchar();
    while (!isdigit(ch)) {if (ch == '-') f = -1; ch = getchar();}
    while (isdigit(ch)) {x = x * 10 + ch - '0'; ch = getchar();}
    x *= f;
}

int main(){
    scanf("%s", s + 1);
    n = strlen(s + 1);
    maxn = (1 << 6) - 1;
    for (int i = 1; i <= n; ++i)
        mask[i] = maxn;
    for (int i = 1; i <= n; ++i)
        ++sum[s[i] - 'a'];
    read(m);
    for (int i = 1; i <= m; ++i){
        int pos; read(pos);
        scanf("%s", t + 1);
        int tmp = 0;
        for (int j = 1; j <= (int)strlen(t + 1); ++j)
            tmp |= (1 << (t[j] - 'a'));
        mask[pos] = tmp;
    }
    for (int i = 1; i <= n; ++i){
        for (int j = 1; j <= maxn; ++j)
            if ((mask[i] | j) == j) ++f[i][j];
    }
    for (int i = n; i >= 1; --i)
        for (int j = 1; j <= maxn; ++j)
            f[i][j] += f[i + 1][j];
    for (int i = 1; i <= n; ++i){
        int fla = 0;
        for (int cur = 0; cur <= 5; ++cur){
            if (!sum[cur]) continue;
            if (!(mask[i] & (1 << cur))) continue;
            --sum[cur];
            int ff = 1;
            for (int j = 1; j <= maxn; ++j){
                int tmp = 0;
                for (int t = 0; t <= 5; ++t)
                    if (j & (1 << t)) tmp += sum[t];
                if (tmp < f[i + 1][j]) {ff = 0; break;}
            }
            if (!ff) ++sum[cur];
            else {ans[i] = cur + 'a'; fla = 1; break;}
        }
        if (!fla) {printf("Impossible\n"); return 0;}
    }
    for (int i = 1; i <= n; ++i)
        printf("%c", ans[i]);
    printf("\n");
    return 0;
}

步六孤明琪

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Educational Codeforces Round 47 (Rated for Div. 2)

【比赛链接】Educational Codeforces Round 47 (Rated for Div. 2)【A】Game Shopping【题意】【题解】时间复杂度O()O()O()【代码】#include&amp;amp;amp;amp;amp;amp;amp;amp;lt;bits/stdc++.h&amp;amp;amp;amp;amp;amp;amp;amp;gt;#define INF 0x3f3f3f3f#define LL long l
复制链接

扫一扫