Codeforces Round #835 (Div. 4) A-G

比赛链接

A

题意

给出三个不同的数，求中位数。

题解

知识点：模拟。

显然。

时间复杂度 $O(1)$

空间复杂度 $O(1)$

代码

#include <bits/stdc++.h>
#define ll long long
 
using namespace std;
 
bool solve() {
    vector<int> v(3 + 1);
    for (int i = 1;i <= 3;i++) cin >> v[i];
    sort(v.begin() + 1, v.end());
    cout << v[2] << '\n';
    return true;
}
 
int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--) {
        if (!solve()) cout << -1 << '\n';
    }
    return 0;
}

B

题意

给出一个小写字母字符串，求最少需要字母表前缀多少个字母才能覆盖所有出现的字母。

题解

知识点：模拟。

找到字符串里最大的字母即可。

时间复杂度 $O(n)$

空间复杂度 $O(n)$

代码

#include <bits/stdc++.h>
#define ll long long
 
using namespace std;
 
bool solve() {
    int n;
    cin >> n;
    string s;
    cin >> s;
    int mx = 0;
    for (char ch : s) {
        mx = max(mx, ch - 'a' + 1);
    }
    cout << mx << '\n';
    return true;
}
 
int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--) {
        if (!solve()) cout << -1 << '\n';
    }
    return 0;
}

C

题意

给出一组数，求出每个数减去这组数中一个数后能得到的最小值。

题解

知识点：模拟。

显然，每个数减去最大的数即可得到最小值。

但注意最大的数可能只有一个，但自己不能减自己，因此我们还需要求出次大值，让所有等于最大值的数减去次大值即可。

时间复杂度 $O(n)$

空间复杂度 $O(n)$

代码

#include <bits/stdc++.h>
#define ll long long
 
using namespace std;
 
int a[200007];
bool solve() {
    int n;
    cin >> n;
    for (int i = 1;i <= n;i++) cin >> a[i];
    int mx1 = 0, mx2 = 0;
    for (int i = 1;i <= n;i++) {
        if (a[i] > mx1) mx2 = mx1, mx1 = a[i];
        else if (a[i] > mx2) mx2 = a[i];
    }
    for (int i = 1;i <= n;i++) {
        if (a[i] < mx1) cout << a[i] - mx1 << ' ';
        else cout << a[i] - mx2 << ' ';
    }
    cout << '\n';
    return true;
}
 
int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--) {
        if (!solve()) cout << -1 << '\n';
    }
    return 0;
}

D

题意

给出一组数，问其中是否有且只有一个山谷。

山谷的定义是，数组中的一个连续子串 $a_{l\cdots r}$ ，满足以下条件：

• $0≤l≤r≤n−1$
• $a_l=a_{l+1}=a_{l+2}=\cdots =a_r$
• $l=0$ 或 $a_{l−1} > al$
• $r=n−1$ 或 $a_r<a_{r+1}$

题解

知识点：模拟。

显然第一个山谷一定会出现在第一次严格递增前，如果没有则出现在右端点。

因此，这组数一旦有一次严格递增，之后就不能严格递减（可以相等），因为再次严格递减后必然会再出现一个山谷。

时间复杂度 $O(n)$

空间复杂度 $O(n)$

代码

#include <bits/stdc++.h>
#define ll long long
 
using namespace std;
 
int a[200007];
bool solve() {
    int n;
    cin >> n;
    for (int i = 1;i <= n;i++) cin >> a[i];
    bool dz = 0;
    for (int i = 2;i <= n;i++) {
        if (a[i] < a[i - 1] && dz) return false;
        dz |= a[i] > a[i - 1];
    }
    cout << "YES" << '\n';
    return true;
}
 
int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--) {
        if (!solve()) cout << "NO" << '\n';
    }
    return 0;
}

E

题意

给定一个 01 串，可以选择一位翻转一次，求最大逆序数。

题解

知识点：枚举，前缀和，贪心。

我们只需要知道每位修改后变化量，取最大值即可。

变化量可以通过维护前缀后缀 1 的个数和 $l1,r1$ 获得。在第 $i$ 位， 1->0 ，则变化量为 $l1_{i-1} - (n-i -r1_{i+1})$ ；0->1 ，则变化量为 $(n-i -r1_{i+1}) - l1_{i-1}$ 。

时间复杂度 $O(n)$

空间复杂度 $O(n)$

代码

#include <bits/stdc++.h>
#define ll long long
 
using namespace std;
 
bool a[200007];
int l1[200007], r1[200007];
bool solve() {
    int n;
    cin >> n;
    for (int i = 1;i <= n;i++) cin >> a[i];
    l1[0] = r1[n + 1] = 0;
    for (int i = 1;i <= n;i++) l1[i] = l1[i - 1] + a[i];
    for (int i = n;i >= 1;i--) r1[i] = r1[i + 1] + a[i];
    int delta = 0;
    ll sum = 0;
    for (int i = 1;i <= n;i++) {
        if (a[i]) delta = max(delta, l1[i - 1] - (n - i - r1[i + 1])), sum += (n - i - r1[i + 1]);
        else delta = max(delta, (n - i - r1[i + 1]) - l1[i - 1]);
    }
    cout << sum + delta << '\n';
    return true;
}
 
int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--) {
        if (!solve()) cout << -1 << '\n';
    }
    return 0;
}

F

题意

给定 $n$ 个任务，任务 $i$ 完成后能得到金币 $a_i$ 个。

每天能选择一个任务完成并得到其金币，任务可以重复完成，但每个任务完成后这个任务会冷却 $k$ 天，之后才能再次选择。

给定需求金币数 $c$ ，以及总天数 $d$ ，问在 $d$ 天内获得 $c$ 个金币的前提下， $k$ 最大是多少。

题解

知识点：二分，贪心。

显然用二分检验求解。

令 $k \in [0,d]$ ，$k<0$ 则无解，$k\geq d$ 则每个任务只需要完成一次就能满足，则 $k$ 可以无穷大。

对于一个需要检验的 $k$ ，显然我们优先选金币数大的任务。又因为一个任务完成后 $k$ 天又可以再完成，因此我们只需要选前 $\min(k+1,n)$ 个任务重复完成即可，能完整完成 $\lfloor \frac{d}{k+1} \rfloor$ 轮，并再多完成 $\min(n,d - (k+1) \cdot \lfloor \frac{d}{k+1} \rfloor)$ 个任务。总额大于等于 $c$ ，这个答案就合法。

时间复杂度 $O(n \log n + \log d)$

空间复杂度 $O(n)$

代码

#include <bits/stdc++.h>
#define ll long long
 
using namespace std;
 
int n;
ll c;
int d;
ll a[200007];
 
bool check(int mid) {
    int cyc = d / (mid + 1);
    int rest = d % (mid + 1);
    return a[min(mid + 1, n)] * cyc + a[min(rest, n)] >= c;
}
 
bool solve() {
    cin >> n >> c >> d;
    for (int i = 1;i <= n;i++) cin >> a[i];
    sort(a + 1, a + n + 1, [&](int a, int b) {return a > b;});
    for (int i = 1;i <= n;i++) a[i] += a[i - 1];
    int l = 0, r = d;
    while (l <= r) {
        int mid = l + r >> 1;
        if (check(mid)) l = mid + 1;
        else r = mid - 1;
    }
    if (r < 0) cout << "Impossible" << '\n';
    else if (r >= d) cout << "Infinity" << '\n';
    else cout << r << '\n';
    return true;
}
 
int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--) {
        if (!solve()) cout << -1 << '\n';
    }
    return 0;
}

G

题意

给一个有 $n$ 个节点的带权树。

从节点 $a$ 出发到节点 $b$ ，开始时 $x = 0$ ，经过一条边 $i$ 时，则异或边权 $w_i$ ，即 $x = x \oplus w_i$ 。当且仅当进入 $b$ 时恰好 $x = 0$ 才能进入 $b$ ，否则不能进入 $b$ 。有一次传送机会，可以从任意点出发，传送到除了 $b$ 的任意点。

问是否存在方案从 $a$ 走到 $b$ 。

题解

知识点：dfs，枚举，位运算。

异或有个性质，$a \oplus a = 0$ 。

结合我们可以任意传送考虑，我们发现只需要两个点 $i,j$ （除了 $b$ ）满足 $a$ 到 $i$ 的异或和等于 $j$ 到 $b$ 的异或和，那我们就可以从 $i$ 传送到 $j$ 即可存在 $a$ 到 $b$ 的方案。

因此，先从 $a$ 遍历每个点的异或和。注意，$a$ 出发的路径不能跨越 $b$ ，因为此时 $b$ 是走不通的。当然有可能到 $b$ 直接就能进去了，我们可以把这个归类为走到 $b$ 前的一个点原地传送以后，再从这个点出发进入 $b$ 。

随后，我们把 $a$ 能到达的点的异或和放进 set 里，再从 $b$ 出发遍历每个点的异或和，因为异或具有交换律，倒着走和正着走结果一样。

最后，在 set 中查找 $b$ 出发每个点得到的异或和是否已经存在即可。

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

空间复杂度 $O(n)$

代码

#include <bits/stdc++.h>
#define ll long long
 
using namespace std;
 
template<class T>
struct Graph {
    struct edge {
        int v, nxt;
        T w;
    };
    int idx;
    vector<int> h;
    vector<edge> e;
 
    Graph(int n, int m) :idx(0), h(n + 1), e(m + 1) {}
    void init(int n) {
        idx = 0;
        h.assign(n + 1, 0);
    }
 
    void add(int u, int v, T w) {
        e[++idx] = edge{ v,h[u],w };
        h[u] = idx;
    }
};
 
const int N = 100007, M = 100007 << 1;
int n, a, b;
Graph<int> g(N, M);
int dis[N];
 
void dfs(int u, int fa) {
    for (int i = g.h[u];i;i = g.e[i].nxt) {
        int v = g.e[i].v, w = g.e[i].w;
        if (v == fa || v == b) continue;
        dis[v] = dis[u] ^ w;
        dfs(v, u);
    }
}
 
bool solve() {
    cin >> n >> a >> b;
    g.init(n);
    for (int i = 1;i <= n - 1;i++) {
        int u, v, w;
        cin >> u >> v >> w;
        g.add(u, v, w);
        g.add(v, u, w);
    }
    for (int i = 1;i <= n;i++) dis[i] = -1;
    dis[a] = 0;
    dfs(a, 0);
    set<int> st;
    for (int i = 1;i <= n;i++) if (dis[i] != -1)st.insert(dis[i]);
    dis[b] = 0;
    dfs(b, 0);
    for (int i = 1;i <= n;i++) {
        if (i != b && st.count(dis[i])) {
            cout << "YES" << '\n';
            return true;
        }
    }
    cout << "NO" << '\n';
    return true;
}
 
int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--) {
        if (!solve()) cout << -1 << '\n';
    }
    return 0;
}