Codeforces Round 936 (Div. 2) A~F

A. Median of an Array （思维）

题意：

给定一个数组$a$，每次操作可以选择数组$a$中一个数字并将其加一，询问至少需要操作多少次，才能使得数组$a$中位数增加。

分析：

我们先对数组排序，找出中位数，从中位数开始，和中位数大小相同的元素都需要加一。

代码：

#include <bits/stdc++.h>

using namespace std;
typedef long long LL;
const LL mod = 998244353;
const int N = 2e5 + 5;
int a[N];

int main() {
    int t;
    cin >> t;
    while (t--) {
        int n;
        cin >> n;
        for (int i = 1; i <= n; i++)
            cin >> a[i];
        sort(a + 1, a + 1 + n);
        int pos = (n + 1) / 2, ans = 0;
        for (int i = pos; i <= n; i++) {
            if (a[i] == a[pos])
                ans++;
        }
        cout << ans << endl;
    }
    return 0;
}

B.Maximum Sum （思维）

题意：

给出一个 $n$ 个整数组成的数组 $a$ 。现在要对它进行 $k$ 次操作。在一次操作中，选择了数组 $a$ 的任意连续子数组（可能为空），并在数组的任意位置插入了该子数组的和。
询问经过 $k$ 次操作后数组的最大和。
答案需要模$10^9+7$ 。

分析：

每次操作取当前最大的连续子数组，再把它插到原来的连续子数组里面，相当于每次乘两倍。

代码：

#include <bits/stdc++.h>

using namespace std;
typedef long long LL;
const LL mod = 1e9 + 7;

int main() {
    int t;
    cin >> t;
    while (t--) {
        int n, k;
        cin >> n >> k;
        vector<LL> a(n + 1);
        LL ans = 0;
        LL maxval = 0;
        LL minval = 0;
        for (int i = 1; i <= n; i++) {
            cin >> a[i];
            ans += a[i];
            a[i] += a[i - 1];
        }
        for (int i = 1; i <= n; i++) {
            maxval = max(maxval, a[i] - a[minval]);
            if (a[i] < a[minval])
                minval = i;
        }
        ans -= maxval;
        for (int i = 1; i <= k; i++) {
            maxval = maxval * 2LL % mod;
        }
        cout << ((ans % mod) + maxval + mod) % mod << endl;
    }
    return 0;
}

C.Tree Cutting （二分答案）

题意：

给定一棵树，需要删除$k$条边，使得剩下的$k+1$个联通块中的最小结点数最大。输出这个最大值。

分析：

二分答案$x$，能否让剩余的连通块最小值为$x$。设当前父节点为$u$，那么对于当前节点$v$及其子树，如果它的$size\ge x$，那么就删除$u,v$这条边。如果不足$x$就保留，尝试和父节点凑更多的点。

代码：

#include <bits/stdc++.h>

using namespace std;
typedef long long LL;
const LL mod = 1e9 + 7;
const int N = 2e5 + 5;
int n, k, x;
vector<int> g[N];
int res;

int dfs(int u, int f) {
    int size1 = 1;
    for (auto v: g[u]) {
        if (v == f) {
            continue;
        }
        size1 += dfs(v, u);
    }
    if (size1 >= x) {
        ++res;
        size1 = 0;
    }
    return size1;
}

int check(int mid) {
    x = mid;
    res = 0;
    int size1 = dfs(1, -1);
    return res > k;
}

int main() {
    int t;
    cin >> t;
    while (t--) {
        cin >> n >> k;
        for (int i = 1; i <= n; ++i) {
            g[i].clear();
        }
        for (int i = 1; i < n; ++i) {
            int u, v;
            cin >> u >> v;
            g[u].push_back(v);
            g[v].push_back(u);
        }
        int l = 1, r = 1e9, ans = 0;
        while (l <= r) {
            int mid = (l + r) / 2;
            if (check(mid)) {
                l = mid + 1;
                ans = mid;
            } else {
                r = mid - 1;
            }
        }
        cout << ans << endl;
    }
    return 0;
}

D.Birthday Gift （位运算）

题意：

将数组划分为$k$个连续段，并满足以下要求：

• 求出每个连续段的异或和
• 这些异或和做或运算，最终答案小于等于$x$

求出最大的$k$。

分析：

首先将$x$进行加一，将不等式变为各个异或段的或运算的结果小于$x$。对于特定第$i$位：

• 如果存在奇数个$1$，那么它们异或的结果为$1$，在这里边分成多段，加若干或运算，结果也是$1$。

• 如果存在偶数个$1$，为使得最终的各个异或段的或运算的结果为$0$，我们可以对偶数个$1$进行分段。

因为要尽可能让段的个数尽可能多，所以我们按照每两个$1$进行分段。从高位往低位枚举，如果所有元素在第$i$位的运算结果为$1$

• 如果$x$在第$i$的结果为$0$，那么停止分段，因为此时的分段运算结果，已经大于$x$了。

• 如果$x$在第$i$的结果为$1$，那么可以在下一个低位，继续分段，因为此时分段运算结果等于$x$，只要后续低位，存在小于$x$对应$bit$位的元素，就可以使用该分段了。

如果所有元素在第$i$位的运算结果为$0$并且$x$在第$i$位的结果为$1$，那么此时数组$a$的分段的运算结果是小于$x$的，可以计算当前分段个数，更新答案。

代码：

#include <bits/stdc++.h>

using namespace std;

int main() {
    int t;
    cin >> t;
    while (t--) {
        int n, x;
        cin >> n >> x;
        x++;
        vector<int> a(n);
        for (int i = 0; i < n; i++)
            cin >> a[i];
        int ans = -1;
        int flag1 = 0;
        for (int i = 30; i >= 0; i--) {
            vector<int> tmp;
            bool flag = 0;
            for (int j = 0; j < a.size(); j++) {
                if (!flag)
                    tmp.push_back(a[j]);
                else
                    tmp.back() ^= a[j];
                if (a[j] & (1 << i))
                    flag = !flag;
            }
            if (!(x & (1 << i))) {
                if (flag) {
                    cout << ans << endl;
                    flag1 = 1;
                    break;
                }
                a = tmp;
            } else {
                if (!flag)
                    ans = max(ans, (int) tmp.size());
            }
        }
        if (flag1 == 0)
            cout << ans << endl;
    }
    return 0;
}

E. Girl Permutation （数学）

题意：

现有一个长度为$n$的排列$p$，给定$p$的前缀最大值的下标集合$a$和后缀最大值的下标集合$b$(按升序排序)，求可能的排列数量，并将答案对$10^9+7$取模。

分析：

根据定义可以发现最大值$n$的位置一定会出现在前缀和后缀数组中，并且分别是前缀的最大值与后缀的最小值。首先检查一下合法性，如果两者不等则直接返回$0$。其余部分可以从剩余的$n-1$个数字中挑选前缀需要的数目的数字，剩余的交给后缀。每次从后往前看，如果当前位置出现在了前缀数组中，我们就只能拿当前手上最大的值放在这里，否则可以拿手上除了最大值的任意值放在这里。前后缀独立处理完的结果相乘就得到了答案。

代码：

#include <bits/stdc++.h>

using namespace std;
const int N = 2e5 + 10, mod = 1e9 + 7;

template<const int T>
struct ModInt {
    const static int mod = T;
    int x;

    ModInt(int x = 0) : x(x % mod) {}

    ModInt(long long x) : x(int(x % mod)) {}

    int val() { return x; }

    ModInt operator+(const ModInt &a) const {
        int x0 = x + a.x;
        return ModInt(x0 < mod ? x0 : x0 - mod);
    }

    ModInt operator-(const ModInt &a) const {
        int x0 = x - a.x;
        return ModInt(x0 < 0 ? x0 + mod : x0);
    }

    ModInt operator*(const ModInt &a) const { return ModInt(1LL * x * a.x % mod); }

    ModInt operator/(const ModInt &a) const { return *this * a.inv(); }

    bool operator==(const ModInt &a) const { return x == a.x; };

    bool operator!=(const ModInt &a) const { return x != a.x; };

    void operator+=(const ModInt &a) {
        x += a.x;
        if (x >= mod)
            x -= mod;
    }

    void operator-=(const ModInt &a) {
        x -= a.x;
        if (x < 0)
            x += mod;
    }

    void operator*=(const ModInt &a) { x = 1LL * x * a.x % mod; }

    void operator/=(const ModInt &a) { *this = *this / a; }

    friend ModInt operator+(int y, const ModInt &a) {
        int x0 = y + a.x;
        return ModInt(x0 < mod ? x0 : x0 - mod);
    }

    friend ModInt operator-(int y, const ModInt &a) {
        int x0 = y - a.x;
        return ModInt(x0 < 0 ? x0 + mod : x0);
    }

    friend ModInt operator*(int y, const ModInt &a) { return ModInt(1LL * y * a.x % mod); }

    friend ModInt operator/(int y, const ModInt &a) { return ModInt(y) / a; }

    friend ostream &operator<<(ostream &os, const ModInt &a) { return os << a.x; }

    friend istream &operator>>(istream &is, ModInt &t) { return is >> t.x; }

    ModInt pow(int64_t n) const {
        ModInt res(1), mul(x);
        while (n) {
            if (n & 1)
                res *= mul;
            mul *= mul;
            n >>= 1;
        }
        return res;
    }

    ModInt inv() const {
        int a = x, b = mod, u = 1, v = 0;
        while (b) {
            int t = a / b;
            a -= t * b;
            swap(a, b);
            u -= t * v;
            swap(u, v);
        }
        if (u < 0)
            u += mod;
        return u;
    }
};

using mint = ModInt<mod>;
mint fact[N], invfact[N];

void init() {
    fact[0] = invfact[0] = 1;
    for (int i = 1; i < N; i++)
        fact[i] = fact[i - 1] * i;
    invfact[N - 1] = fact[N - 1].inv();
    for (int i = N - 2; i; i--)
        invfact[i] = invfact[i + 1] * (i + 1);
}

inline mint C(int a, int b) {
    if (a < 0 || b < 0 || a < b)
        return 0;
    return fact[a] * invfact[b] * invfact[a - b];
}

int main() {
    init();
    int T;
    cin >> T;
    while (T--) {
        int n, m1, m2;
        cin >> n >> m1 >> m2;
        vector<int> p(m1 + 1), s(m2 + 1);
        vector<int> map1(n + 1);
        for (int i = 1; i <= m1; i++) {
            cin >> p[i];
            map1[p[i]] = 1;
        }
        for (int i = 1; i <= m2; i++) {
            cin >> s[i];
            map1[s[i]] = 1;
        }
        if (p[m1] != s[1]) {
            cout << "0" << endl;
            continue;
        }
        mint ans = C(n - 1, s[1] - 1);
        int len = s[1] - 1;
        for (int i = len; i >= 1; i--)
            if (!map1[i])
                ans = ans * (i - 1);
        len = s[1] + 1;
        for (int i = len; i <= n; i++)
            if (!map1[i])
                ans = ans * (n - i);
        cout << ans << endl;
    }
    return 0;
}

F. Nobody is needed （数据结构）

题意：

有一个长度为 $n$ 的排列 $a$ ，$q$ 个询问，每个问题都有两个数字 $l$ 和 $r$ ，输出任意长度 $k\ge 1$ 的索引集 $(t_1,t_2,\dots ,t_k)$ 的个数：

• 从 $1$ 到 $k$ 的每个 $i$ 的 $l\le t_i\le r$ 。

• 从 $1$ 到 $k-1$ 的每个 $i$ 为 $t_i<t_{i+1}$ 。

• 从 $1$ 到 $k-1$ 的每一个 $i$ 都能被 $a_{t_i}$ 整除。

分析：

枚举合法的左右端点，设为$t_1,t_k$，$t_1$是$t_k$的因子，最多只有$nlogn$ 对合法的$t_1,t_k$，只要知道所有的$t_1,t_k$对答案的贡献 $x$，也就是区间$[l,r]$对答案增量为$x$，就可以利用扫描线求得答案。

将问题转化成：已知$t_1,t_k$，如何计算对答案的贡献 $x$。其中可能存在转移 $t_1\to t_2\to t_k$，$t_1=t_2$， $t_2\ne t_k$。那么设$f[t_1]=1$，其他为$0$。固定左端点$t_1$，模拟$dp$转移，再枚举倍数$t_2,t_k$，显然答案最后在所有$t_1$的倍数内。

代码：

#include <bits/stdc++.h>

using namespace std;
typedef long long LL;

template<typename T>
struct Fenwick {
    int n;
    std::vector<T> a;

    Fenwick(int n = 0) { init(n); }

    void init(int n) {
        this->n = n;
        a.assign(n, T());
    }

    void add(int x, T v) {
        for (int i = x + 1; i <= n; i += i & -i) {
            a[i - 1] += v;
        }
    }

    T sum(int x) {
        auto ans = T();
        for (int i = x; i > 0; i -= i & -i) {
            ans += a[i - 1];
        }
        return ans;
    }

    T rangeSum(int l, int r) {
        return sum(r) - sum(l);
    }

    int kth(T k) {
        int x = 0;
        for (int i = 1 << std::__lg(n); i; i /= 2) {
            if (x + i <= n && k >= a[x + i - 1]) {
                x += i;
                k -= a[x - 1];
            }
        }
        return x;
    }
};

int main() {
    int T;
    cin >> T;
    while (T--) {
        int n, m;
        cin >> n >> m;
        vector<int> a(n + 1), p(n + 1);
        for (int i = 1; i <= n; i++)
            cin >> a[i];
        for (int i = 1; i <= n; i++)
            p[a[i]] = i;
        vector<array<int, 3>> query(m);
        for (int i = 0; i < m; i++) {
            int l, r;
            cin >> l >> r;
            query[i] = {l, r, i};
        }
        vector<array<int, 3>> tmp;
        vector<int> f(n + 1);
        for (int l = 1; l <= n; l++) {
            int x = a[l];
            f[x] = 1;
            for (int y = x; y <= n; y += x) {
                int m = p[y];
                if (l > m)
                    continue;
                for (int z = 2 * y; z <= n; z += y) {
                    int r = p[z];
                    if (r < m)
                        continue;
                    f[z] += f[y];
                }
            }
            for (int y = x; y <= n; y += x) {
                int r = p[y];
                tmp.push_back({l, r, f[y]});
                f[y] = 0;
            }
        }
        Fenwick<LL> fen(n + 1);
        sort(tmp.begin(), tmp.end(), [&](auto edge1, auto edge2) { return edge1[1] < edge2[1]; });
        sort(query.begin(), query.end(), [&](auto edge1, auto edge2) { return edge1[1] < edge2[1]; });
        int k = tmp.size();
        vector<LL> ans(m);
        int i = 0, j = 0;
        for (int r = 1; r <= n; r++) {
            while (i < k && tmp[i][1] == r) {
                auto [l, r, x] = tmp[i];
                i++;
                fen.add(l, x);
            }
            while (j < m && query[j][1] == r) {
                auto [l, r, id] = query[j];
                j++;
                ans[id] = fen.rangeSum(l, n + 1);
            }
        }
        for (auto x: ans) {
            cout << x << " ";
        }
        cout << endl;
    }
    return 0;
}

赛后交流

在比赛结束后，会在交流群中给出比赛题解，同学们可以在赛后查看题解进行补题。

群号： 704572101，赛后大家可以一起交流做题思路，分享做题技巧，欢迎大家的加入。