【牛客小白月赛 113】题解

比赛链接

A. 2025

Solution

模拟即可。

C++ Code

#include <bits/stdc++.h>

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    std::string s;
    std::cin >> s;

    int sum = 1;
    for (auto c: s) {
        if (c == '-') {
            sum--;
        } else {
            sum *= 2;
        }
        if (sum >= 2025) {
            std::cout << "YES\n";
            return 0;
        }
    }
    std::cout << "NO\n";
    
    return 0;
}

B. 好字符串

Solution

直接统计有多少 $i\in (1,n]$ 满足 $s_{i-1}=s_i$，记为 $\mathrm{cnt}$，只有 $\mathrm{cnt}\le 1$ 才满足条件。

C++ Code

#include <bits/stdc++.h>

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    int n;
    std::cin >> n;

    std::string s;
    std::cin >> s;

    int cnt = 0;
    for (int i = 1; i < n; i++) {
        cnt += s[i - 1] == s[i];
    }
    std::cout << (cnt <= 1 ? "YES\n": "NO\n");
    
    return 0;
}

C. 连续数组

Solution

只要看每个 $a_i$ 是否升序，且整体无重复元素，并且 $\max -\min +1$ 要与集合大小相等。

C++ Code

#include <bits/stdc++.h>

template<class T>
std::istream &operator>>(std::istream &is, std::vector<T> &v) {
    for (auto &x: v) {
        is >> x;
    }
    return is;
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    int q;
    std::cin >> q;

    std::set<int> set;
    for (int i = 0; i < q; i++) {
        int k;
        std::cin >> k;
        std::vector<int> a(k);
        std::cin >> a;
        if (not std::ranges::is_sorted(a)) {
            std::cout << "NO\n";
            return 0;
        }
        for (int x: a) {
            if (set.contains(x)) {
                std::cout << "NO\n";
                return 0;
            }
            set.insert(x);
        }
    }

    if (*set.rbegin() - *set.begin() + 1 != set.size()) {
        std::cout << "NO\n";
    } else {
        std::cout << "YES\n";
    }
    
    return 0;
}

D. mex

题目大意

给定一个长度为 $n$ 的非负整数数组 $a$，要求做一下操作若干次，使得 $a$ 里面的数都相同。

• 取 $\mathrm{mex}=\mathrm{mex}(\mathrm{a})$，然后对 $\forall i\in [1,n]$，令 ${\mathrm{a}}_{\mathrm{i}}:=\max (0,{\mathrm{a}}_{\mathrm{i}}-\mathrm{mex})$。

求至少要操作几次（可以不操作），如果无法做到，输出 $-1$。

其中 $\mathrm{mex}(\mathrm{a})$ 表示 $a$ 中未出现的最小非负整数，例如 m e x ( { 0 , 1 , 3 } ) = 2 \rm{mex(\{0, 1, 3 \})} = 2 mex({0,1,3})=2。

数据范围

• $1\le n\le 10^5,$
• $0\le a_i\le 10^{18}.$

Solution

首先对 $a$ 排序，若 $a_1\ne 0$，说明 $\mathrm{mex}(\mathrm{a})$ 只能是 $0$，也就是无法修改 $a$，因此只要看 $a$ 的数是否全相等即可。

否则我们记录当前想要出现的 $\mathrm{mex}$、整个数组被减去的量 $\mathrm{sub}$ 以及操作次数 $\mathrm{ans}$，初值均为 $0$。

若对于当前 $x$，令 $x:=x-sub$，

• 若 $\mathrm{x}=\mathrm{mex}$，令$\mathrm{mex}:=\mathrm{mex}+1$；
• 若 $\mathrm{x}<\mathrm{mex}$，直接 continue；
• 否则这个 $\mathrm{mex}$ 就真的出现了，直接令 $$\begin{gathered} x:=x-mex, \\ sub:=sub+mex, \\ ans:=ans+，1. \end{gathered}$$ 如果此时仍有 $x>1$，那说明 $\mathrm{mex}=1$，只要减 $x-1$ 次就能令 $x=1$，然后我们再令 $\mathrm{mex}=2$，继续往后遍历。

最后如果剩下的 $\mathrm{mex}>1$，说明一定有没处理完的，答案再 $+1$。

时间复杂度 $O(n)$

C++ Code

#include <bits/stdc++.h>

using i64 = long long;

template<class T>
std::istream &operator>>(std::istream &is, std::vector<T> &v) {
    for (auto &x: v) {
        is >> x;
    }
    return is;
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    int n;
    std::cin >> n;

    std::vector<i64> a(n);
    std::cin >> a;

    std::ranges::sort(a);

    if (a[0] != 0) {
        std::cout << (a[0] != a[n - 1] ? -1: 0) << "\n";
        return 0;
    }

    i64 sub = 0;
    i64 mex = 0;
    i64 ans = 0;
    for (i64 &x: a) {
        x -= sub;
        if (x == mex) {
            mex++;
            continue;
        }
        if (x < mex) {
            continue;
        }
        x -= mex;
        sub += mex;
        ans++;
        if (x > 1) {
            sub += x - 1;
            ans += x - 1;
        }
        mex = 2;
    }
    ans += mex > 1;

    std::cout << ans << "\n";
    
    return 0;
}

E. 可划分数组

题目大意

对于一个长度为 $n$ 的数组 $a$，将其分成 $k$ 份，第 $i$ 份的下标区间是 $[l_i,r_i]$，要求：

• $l_1=1,$
• $r_k=n,$
• $\forall i\in [1,k],l_i<r_i,$
• $\forall i\in (1,k],l_i=r_{i-1}+1,$
• $\forall p\in [l_i,r_i],至少存在一个q\in [l_i,r_i]\setminus p，使得\gcd (a_p,a_q)\ne 1.$

求 $k$ 的可能最大值，如果无法进行分割，输出 $-1$。

数据范围

• $1\le n\le 2000,$
• $1\le a_i\le 10^9.$

Solution

赛时我用了非常麻烦的分解质因数，然后对位置做标记什么的才过的，下面介绍简单方法。

首先，若 $n=1$ 或者 $\exists a_i=1$，那么一定无法分割。

否则我们考虑 $\mathrm{dp}$，设 $\mathrm{dp}[\mathrm{i}]$ 表示考虑对 $[1,i]$ 做分割，能得到的最大 $k$。

显然有转移方程

$$dp[i]=\underset{j\in [1,i)}{\max }dp[j-1]+1$$

其中 $j$ 需要满足区间 $[j,i]$ 是合法的。那么问题变成了如何在 $O(1)$ 或 $O(\log n)$ 的时间判定一段区间 $[l,r]$ 是否合法。

我们令 $\mathrm{pre}[\mathrm{i}]$ 表示$[1,i)$ 内最靠右的 $j$，使得 $\gcd (a_i,a_j)\ne 1$，如果没有设为 $0$。
接着令 $\mathrm{nxt}[\mathrm{i}]$ 表示$(i,n]$ 内最靠左的 $j$，使得 $\gcd (a_i,a_j)\ne 1$，如果没有设为 $n+1$。

这两个数组可以提前 $O(n^2\log \max (a))$ 预处理。

对一段区间 $[l,r]$ 来说，如果它是合法的，当且仅当

• $\forall i\in [l,r]$，均有 $pre[i]\ge l\mid \mid nxt[i]\le r$。

那么对于某个 $i$，当 $pre[i]\ge l$ 时，无需看 $nxt[i]$，否则就要看所有遍历过的 $nxt[i]$ 的最大值是否 $\le r$。

简单来说，就是对于固定的 $l$，$r$ 从 $l$ 开始往右遍历，若 $pre[r]<l$，说明当前 $[l,r]$ 肯定是废了（因为 $r$ 就是右端点，不能再往右找 $j$ 了），只要令 $R=\max (R,nxt[i])$，否则若 $R\le r$，就可以更新 $dp[r]$ 的状态。

时间复杂度 $O({\mathrm{n}}^2\log \max (\mathrm{a}))$

• 这个 $\log$ 是求 $\gcd$ 时产生的，其实快得很，甚至我感觉就比 $O(1)$ 慢一丢丢。

C++ Code

#include <bits/stdc++.h>

template<class T>
std::istream &operator>>(std::istream &is, std::vector<T> &v) {
    for (auto &x: v) {
        is >> x;
    }
    return is;
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    int n;
    std::cin >> n;

    std::vector<int> a(n);
    std::cin >> a;

    if (n == 1 or std::ranges::count(a, 1) > 0) {
        std::cout << -1 << "\n";
        return 0;
    }

    std::vector pre(n, -1);
    for (int i = 0; i < n; i++) {
        for (int j = i - 1; j >= 0; j--) {
            if (std::gcd(a[i], a[j]) != 1) {
                pre[i] = j;
                break;
            }
        }
    }
    std::vector nxt(n, n);
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if (std::gcd(a[i], a[j]) != 1) {
                nxt[i] = j;
                break;
            }
        }
    }

    std::vector<int> dp(n + 1, -1);
    dp[0] = 0;
    for (int l = 0; l < n; l++) {
        for (int r = l, R = 0; r < n and dp[l] != -1; r++) {
            if (pre[r] < l) {
                R = std::max(R, nxt[r]);
            } else if (R <= r) {
                dp[r + 1] = std::max(dp[r + 1], dp[l] + 1);
            }
        }
    }
    std::cout << dp.back() << "\n";

    return 0;
}

F. 最小差值

题目大意

给定整数数组 $a,b$，长度分别为 $n,m$，现在请找一个整数 $k\in [-2\cdot 10^9,2\cdot 10^9]$，使得 $$\left|\left(\sum _{i=1}^n|a_i-k|\right)-\left(\sum _{j=1}^m|b_j-k|\right)\right|$$ 最小，输出满足条件的最小 $k$。

数据范围

• $1\le n,m\le 10^6,$
• $-10^9\le a_i,b_i\le 10^9.$

Solution

这种找一个数使得某种求和最小，我们最简单的想法就是直接令 $k=a_i$ 或 $k=b_j$。

但是显然我们可以找个很简单的例子 $\mathrm{hack}$，比如 a = { − 2 , 1 } ,   b = { 1 , 2 } a = \{-2, 1\}, \ b = \{1, 2\} a={−2,1}, b={1,2}，在 $k=0$ 时取到最小值。

不过这个思路可以保留做拓展，因为 $k\in (-2,1)$，只要再我们探究一下 $k\ne a_i$ 且 $k\ne b_j$ 的规律，说不定就能搞定。

若现在 $k\in a\cup b$，但 $k+1\notin a\cup b$，我们令 $$f(k)=\left(\sum _{i=1}^n|a_i-k|\right)-\left(\sum _{j=1}^m|b_j-k|\right),$$ 接着计算 $f(k+1)-f(k)$。

• 对于 $a_i\le k$ 的 $i$，数量是没变的，设为 $c_{a_1}$，会对表达式产生 $c_{a_1}$ 的增量；
• 对于 $a_i>k$ 的 $i$，数量同样不变，设为 $c_{a_2}$，会对表达式产生 $-c_{a_2}$ 的增量；
• 对于 $b_j\le k$ 的 $j$，数量是没变的，设为 $c_{b_1}$，会对表达式产生 $-c_{b_1}$ 的增量；
• 对于 $b_j<k$ 的 $j$，数量同样不变，设为 $c_{b_2}$，会对表达式产生 $c_{b_2}$ 的增量。

这样一来总的增量就是 $A=c_{a_1}+c_{b_2}-c_{a_2}-c_{b_1}$。

设 $k+L\in a\cup b$，于是对于 $\forall x\in (k,k+L)$，都有 $$f(x)=f(k)+A(x-k)$$ 如果存在一个 $x$ 使得 $f(x)=0$，那 $|f(x)|=0$，一定最优。因此要找到这样的 $x$，就先令 $f(x)=0$，然后化简得到 $$x_k=k-\frac{f(k)}{A}.$$ 由于这个 $x_k$ 不是整数，所以我们只要找靠近它的两个值 $\lfloor x_k\rfloor$ 和 $\lceil x_k\rceil$ 即可。

因此最终我们需要找的点就有：

• $\forall x\in a\cup b,$
• $\forall \lfloor x_k\rfloor ,\lceil x_k\rceil .$（用上述方式计算得到的）

时间复杂度 $O((\mathrm{n}+\mathrm{m})\log (\mathrm{n}+\mathrm{m}))$

C++ Code (my implementation)

#include <bits/stdc++.h>

using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned;
using i80 = __int128_t;
using u80 = unsigned __int128_t;
using f64 = double;
using f80 = long double;
using i16 = short;
using u16 = unsigned short;

constexpr f64 pi = std::numbers::pi;

template<class T>
std::istream &operator>>(std::istream &is, std::vector<T> &v) {
    for (auto &x: v) {
        is >> x;
    }
    return is;
}

constexpr int inf = 2E9;

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    int n, m;
    std::cin >> n >> m;

    std::vector<int> a(n);
    std::cin >> a;

    std::vector<int> b(m);
    std::cin >> b;

    std::ranges::sort(a);
    std::ranges::sort(b);

    std::vector<int> v{-inf, inf};
    v.insert(v.end(), a.begin(), a.end());
    v.insert(v.end(), b.begin(), b.end());

    std::ranges::sort(v);

    std::vector<i64> sa(n + 1);
    for (int i = 0; i < n; i++) {
        sa[i + 1] = sa[i] + a[i];
    }
    std::vector<i64> sb(m + 1);
    for (int i = 0; i < m; i++) {
        sb[i + 1] = sb[i] + b[i];
    }
    auto calc = [&](int k) {
        i64 sum = 0;
        int i = std::ranges::upper_bound(a, k) - a.begin();
        sum += static_cast<i64>(i) * k - sa[i];
        sum += (sa[n] - sa[i]) - static_cast<i64>(n - i) * k;
        int j = std::ranges::upper_bound(b, k) - b.begin();
        sum -= static_cast<i64>(j) * k - sb[j];
        sum -= (sb[m] - sb[j]) - static_cast<i64>(m - j) * k;
        return sum;
    };

    std::vector<int> nv;
    for (int i = 0; i + 1 < v.size(); i++) {
        int l = v[i];
        int r = v[i + 1];
        if (l + 1 >= r) {
            continue;
        }
        i64 lv = calc(l);
        i64 rv = calc(r);
        auto sgn = [&](i64 x) {
            return x != 0 ? x / std::abs(x): 0;
        };
        if (sgn(lv) * sgn(rv) > 0) {
            continue;
        }
        int ai = std::ranges::upper_bound(a, l) - a.begin();
        int bj = std::ranges::upper_bound(b, l) - b.begin();
        int A = ai - (n - ai) - (bj - (m - bj));
        if (A == 0) {
            continue;
        }
        f64 kA = l - static_cast<f64>(lv) / A;
        for (auto k: {std::floor(kA), std::ceil(kA)}) {
            if (l < k and k < r) {
                nv.push_back(int(k));
            }
        }
    }

    v.insert(v.end(), nv.begin(), nv.end());
    std::ranges::sort(v);
    v.erase(std::unique(v.begin(), v.end()), v.end());
    
    i64 res = std::numeric_limits<i64>::max() / 4;
    int ans = 0;
    for (int k: v) {
        i64 sum = std::abs(calc(k));
        if (res > sum) {
            res = sum;
            ans = k;
        }
    }
    std::cout << ans << "\n";
    
    return 0;
}

Solution (faster)

上面的做法是我自己的，要两次排序去重，且中间还要不停 upper_bound，耗时太长，我们不妨延续 $f(x)=f(k)+A(x-k)$ 的思路，想一个更快的实现。

考虑 $k=-2\cdot 10^9$，显然 $k\notin a\cup b$，且它的增量 $A=0+m-n-0=m-n$。而当不断 $k:=k+1$ 直到第一个 $k\in a\cup b$ 时，

• 若 $k=a_i$，那么增量 $A^{\prime }=1+m-(n-1)-0=(m-n)+2$；
• 若 $k=b_j$，那么增量 $A^{\prime }=0+(m-1)-n-1=(m-n)-2$。

经过一通手玩，我们发现，增量 $A$ 每碰到一个 $a_i$ 就 $+2$，每碰到一个 $b_j$ 就 $-2$。那我们可以把 $a_i,b_j$ 都存到同一个数组里（请注意不需要去重），同时记录对应的小增量 $+2$ 或 $-2$。

然后对于式子中的 $f(x)$，它的含义就是：

• $+(c_{a_1}\cdot x-\le x的a_i的和)$；
• $-(>x的a_i的和-c_{a_2}\cdot x)$；
• $-(c_{b_1}\cdot x-\le x的b_j的和)$；
• $+(>x的b_j的和-c_{b_2}\cdot x)$。

由于我们把 $x$ 前面的系数拎出来作为增量 $A$，所以我们只考虑后面那些 $a_i$ 和 $b_j$ 的和，处理方式和 $A$ 一样。

这样 $f(x)$ 就是若干个一次函数的并，每一段都是$kx+b$（注意这里 $k$ 是斜率了，也就是上面的增量 $A$；$b$ 也不是数组 $b$，而是只考虑了后面那些 $a_i$ 和 $b_j$ 的和），而我们要求的就是 $\min (|kx+b|)$，所以考虑最近的三个点 { − b k − 1 ,   − b k ,   − b k + 1 } \{ -\frac{b}{k} - 1, \ -\frac{b}{k}, \ -\frac{b}{k} + 1 \} {−kb​−1, −kb​, −kb​+1} 即可。

C++ Code (faster implementation)

#include <bits/stdc++.h>

using i64 = long long;

constexpr int inf = 2E9;

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    int n, m;
    std::cin >> n >> m;

    int k = m - n;
    std::vector<std::pair<int, int>> v;
    v.reserve(n + m + 1);

    i64 b = 0;
    for (int i = 0; i < n; i++) {
        int x;
        std::cin >> x;
        v.emplace_back(x, 2);
        b += x;
    }
    for (int i = 0; i < m; i++) {
        int x;
        std::cin >> x;
        v.emplace_back(x, -2);
        b -= x;
    }
    v.emplace_back(inf, 0);

    std::ranges::sort(v);

    int ans = -inf;
    i64 res = std::abs(static_cast<i64>(k) * ans + b);

    int l = -inf;
    for (const auto &[r, add]: v) {
        if (k != 0) {
            i64 c1 = -b / k;
            for (int i = -1; i <= 1; i++) {
                i64 c2 = c1 + i;
                c2 = std::max<i64>(c2, l);
                c2 = std::min<i64>(c2, r);
                i64 sum = std::abs(k * c2 + b);
                if (res > sum) {
                    res = sum;
                    ans = c2;
                }
            }
        }
        k += add;
        b -= static_cast<i64>(add) * r;
        l = r;
    }
    std::cout << ans << "\n";
    
    return 0;
}