比赛链接

A

知识点：贪心，数论。

先求出序列最大公约数 \(d\) ，如果为 \(1\) 直接输出 \(0\) 。

否则，尝试用最后一个数操作， \(gcd(d,n) = 1\) 则可以，花费为 \(1\) 。

否则，用倒数第二个数操作，\(gcd(d,n-1) = 1\) （不必担心 \(n-1 = 0\) ，因为此时上一步一定成功），花费为 \(2\) 。

否则，用倒数两个数操作，一定成功，因为 \(gcd(n-1,n)=1\) ，花费为 \(3\) 。

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

空间复杂度 \(O(n)\)

#include <bits/stdc++.h>
#define ll long long

using namespace std;

int a[27];
bool solve() {
    int n;
    cin >> n;
    for (int i = 1;i <= n;i++) cin >> a[i];
    int d = a[1];
    for (int i = 2;i <= n;i++) d = __gcd(a[i], d);
    if (d == 1) cout << 0 << '\n';
    else if (__gcd(d, n) == 1) cout << 1 << '\n';
    else if (__gcd(d, n - 1) == 1) cout << 2 << '\n';
    else cout << 3 << '\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

知识点：贪心。

显然左侧已经排好的不用管，从第一段 \(1\) 开始记录后面一共分成的段数 \(cnt\)（如 0000|111|00|1|0|1|0 有 \(6\) 段）。若 \(cnt > 1\) ，则从第一段开始使用操作，每次可以将一段变为 \(0\) （后面也会改变），直到最后一段不用更改，一共操作 \(cnt-1\) 次。另外，如果 \(cnt = 0\) ，答案也是 \(0\) 。

时间复杂度 \(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;
    s = "?" + s;
    bool st = 0;
    int cnt = 0;
    for (int i = 1;i <= n;i++) {
        if (s[i] != st + '0') {
            cnt++;
            st ^= 1;
        }
    }
    cout << max(cnt - 1, 0) << '\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

知识点：枚举，双指针，位运算，前缀和，贪心。

因为异或相当于不进位的加法，那么前缀和减去前缀异或和一定是非减的，于是一个贪心的结论：最大值一定是 \(f(L_i,R_i)\) 的值。接下来需要用这个值，求一个最小区间。

为了方便区间运算，我们预处理一个前缀和，以及一个前缀异或和。

可以证明，最多删除 \(31\) 个非 \(0\) 元素，否则区间值必然减小。因为在 int 范围内， \(31\) 个二进制位，最多能分配给 \(31\) 个数一个不同为值的 \(1\) ，这样能使这 \(31\) 个数对答案没有贡献，实际情况不会超过 \(31\) ，因此我们放心大胆的枚举端点就行了。我们只需要考虑非 \(0\) 点，遍历一遍存一下非 \(0\) 点坐标即可。左端点从左往右，内循环右端点从右往左，区间等于最大值的如果长度更小就更新答案。

另外，需要特判没有非 \(0\) 元素的情况，此时直接输出 \(L,L\) 即可。

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

空间复杂度 \(O(n)\)

#include <bits/stdc++.h>
#define ll long long

using namespace std;

int a[100007];
ll sum[100007], sumx[100007];
bool solve() {
    int n, q;
    cin >> n >> q;
    for (int i = 1;i <= n;i++) cin >> a[i];
    vector<int> pos;
    for (int i = 1;i <= n;i++) {
        sum[i] = sum[i - 1] + a[i];
        sumx[i] = sumx[i - 1] ^ a[i];
        if (a[i]) pos.push_back(i);
    }
    while (q--) {
        int L, R;
        cin >> L >> R;
        int l = lower_bound(pos.begin(), pos.end(), L) - pos.begin();
        int r = upper_bound(pos.begin(), pos.end(), R) - pos.begin() - 1;
        auto get = [&](int _l, int _r) {return sum[_r] - sum[_l - 1] - (sumx[_r] ^ sumx[_l - 1]);};
        ll val = get(L, R);
        int ansl = 0, ansr = n + 1;
        for (int i = l;i <= r;i++) {
            if (get(pos[i], pos[r]) < val) break;//可以证明无论左右端点至多删除31个非0元素对答案没有影响（0，2，4，8，...鸽巢原理）
            for (int j = r;j >= i;j--) {
                if (get(pos[i], pos[j]) < val) break;
                if (pos[j] - pos[i] + 1 < ansr - ansl + 1) {
                    ansl = pos[i];
                    ansr = pos[j];
                }
            }
        }
        if (ansr - ansl + 1 > n) cout << L << ' ' << L << '\n';
        else cout << ansl << ' ' << ansr << '\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;
}

D1

知识点：STL，枚举。

用一个 set<ll> vis 维护出现过的元素，再用一个 map<ll,ll> last 维护某个元素上一次的询问结果，下一次询问这个元素时直接从上一次结果开始。

每个元素 \(i\) 只经过其倍数一次，共 \(\dfrac{n}{i}\) 次。所有元素次数之和 \(O(\sum \dfrac{n}{i}) = O(n \log n)\) 。

时间复杂度 \(O(q \log^2 q)\)

空间复杂度 \(O(q)\)

#include <bits/stdc++.h>
#define ll long long

using namespace std;

int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int q;
    cin >> q;
    set<ll> vis;
    map<ll, ll> last;
    while (q--) {
        char op;
        ll x;
        cin >> op >> x;
        if (op == '+') {
            vis.insert(x);
        }
        else {
            if (!last.count(x)) last[x] = x;
            while (vis.count(last[x])) last[x] += x;
            cout << last[x] << '\n';
        }
    }
    return 0;
}

D2

知识点：STL，枚举。

因为存在删除已存在元素的操作，这意味着我们之前得到的答案在未来可能不适用。

因此需要对每个已询问过的数字维护一个已删除集合 map<ll,set<ll>> del ，来得到目前某个元素的最大询问结果之前，是否有在序列中被删除的倍数。

对于已删除集合的维护，需要对每个询问过程中遍历到的且存在于序列中的倍数维护一个影响列表 map<ll,vector<ll>> chg ，来得到修改序列某个元素的状态时，哪些询问过的元素的已删除集合会被修改。

如此我们就维护了带删除求 mex 的数据结构。

时间复杂度 \(O(q \log ^2 q)\)

空间复杂度 \(O(q\log q)\)

#include <bits/stdc++.h>
#define ll long long

using namespace std;

int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int q;
    cin >> q;
    set<ll> vis;//序列中存在的元素
    map<ll, ll> last;//某元素最大询问结果：记录需要维护的数据上界，超出最大询问结果的不需要考虑
    map<ll, set<ll>> del;//某元素的已删除集合：最大询问结果内，目前不存在于序列中的倍数
    map<ll, vector<ll>> chg;//某元素的影响列表：更改序列中某元素状态，已删除集合将发生变化的元素列表
    while (q--) {
        char op;
        ll x;
        cin >> op >> x;
        if (op == '+') {
            vis.insert(x);
            for (auto y : chg[x]) del[y].erase(x);//删除受x影响元素的已删除集合中的x，因为x已存在
        }
        else if (op == '-') {
            vis.erase(x);
            for (auto y : chg[x]) del[y].insert(x);//增加受x影响元素的已删除集合中的x，因为x已删除
        }
        else {
            if (!last.count(x)) last[x] = x;//新增已询问元素
            if (del[x].size()) cout << *del[x].begin() << '\n';//已删除集合存在元素，优先使用
            else {//考虑最大询问结果是否可行，否则扩大最大询问结果
                while (vis.count(last[x])) {
                    chg[last[x]].push_back(x);//已存在的x的倍数，在未来可能会被修改状态，影响x的结果
                    last[x] += x;
                }
                cout << last[x] << '\n';
            }
        }
    }
    return 0;
}