CF1415D XOR-gun 题解 二分答案/贪心

题目链接

https://codeforces.com/problemset/problem/1415/D

题目大意

给定一个长为 \(n\) 的不降序列，每次操作可以任选相邻的两个数，并将这两个数替换为两个数按位异或的结果，现在需要破坏序列的不降，求最少操作次数，无解输出 \(-1\)。

方法一：二分答案

首先，要破坏数列的非严格单调递增特性，肯定会选择两个连续的元素 \(a_i\) 和 \(a_{i+1}\)，然后：

• 选择将 \(a_i\) 结尾的连续若干个元素（\(\ldots, a_{i-2}, a_{i-1}, a_i\)）进行异或；
• 选择将 \(a_{i+1}\) 开头的连续若干个元素（\(a_{i+1}, a_{i+2}, \ldots\)）进行异或

并令 前者（以 \(a_i\) 结尾的连续若干个数的异或和）大于 后者（以 \(a_{i+1}\) 开头的连续若干个数的异或和）。

为什么操作连续的若干个数？

举个形象一点的例子，这个就跟伐木一样，比如说我要砍倒一棵树，我肯定会选择同一个高度砍，不会说先在距离地面 \(0.2\) 米的位置砍两刀，然后再到距离地面 \(0.5\) 米的位置砍几刀，…… 肯定是在同一个位置。

因为我们的目的是破坏数列“非严格单调递增“的性质，所以我们只需要存在一对元素满足条件即可，很明显：

1. 它们是相邻的
2. 左边的那个数是一段连续的元素的异或和（对应以某个 \(a_i\) 结尾的连续若干个数）
3. 右边的那个数也是一段连续的元素的异或和（对应以 \(a_{i+1}\) 开头的连续若干个数）

考虑可以操作 \(m\) 次时是否满足条件（破坏数列的“非严格单调递增“性质），因为要将一段连续的区间内的元素消到只剩 \(2\) 个数（然后左边那个数大于右边那个数），操作一次会消去一个数，所以 \(m\) 次操作对应一个长度为 \(m+2\) 的区间。

当 \(m\) 确定时，枚举每个下标 \(i\)，对于下标 \(i\)，我们要确定的事情是：

是否存在一个以 \(a_i\) 结尾的连续子序列（假设这个连续子序列的异或和为 \(x\)）以及一个以 \(a_{i+1}\) 开头的连续子序列（假设这个连续子序列的异或和为 \(y\)），满足 \(x \gt y\) 且两个连续子序列包含的元素个数不超过 \(m+2\)。

如果有的话就说明 \(\Rightarrow\) 消除不超过 \(m\) 次能够是数列不满足”非严格单调递增”的性质。

注意：是 ”不超过 \(m\) 次” 而不是 ”恰好 \(m\) 次”。

这是为什么呢？我们多定义两个状态 \(b_j\) 和 \(c_j\)，这两个状态在 \(j \le i\) 和 \(j \gt i\) 时表示的含义不同，其中：

当 \(j \le i\) 时：

\(b_j\) 表示的是 \(a_j \oplus a_{j+1} \oplus \ldots a_i\)（即以 \(a_j\) 开头以 \(a_i\) 结尾的连续子序列中所有元素的异或和），推导公式：

\[b_j = \begin{cases} a_i & j = i \\ a_j \oplus b_{j+1} & j \lt i \end{cases} \]

\(c_j\) 表示的是 \(b_j, b_{j+1}, \ldots, b_i\) 的最大值，推导公式：

\[c_j = \begin{cases} b_i & j = i \\ \max\{ b_j, c_{j+1} \} & j \lt i \end{cases} \]

此时的状态是从后往前推（\(i \rightarrow i-1 \rightarrow i-2 \rightarrow \ldots\)），可以发现 \(c_j\) 从后往前是非降的，因为 \(c_j\) 表示的并不是从 \(a_i\) 异或到 \(a_j\) 的结果（这是 \(b_j\) 表示的），而是从 \(a_i\) 异或到 \(a_j\) 的过程中能够得到的结果的最大值。

也就是说，\(c_j\) 表示的含义是 \(a_i\) 往前合并 不超过 \(i - j\) 次的情况下能够获得的最大值。

当 \(j \gt i\) 时：

\(b_j\) 表示的是 \(a_{i+1} \oplus a_{i+2} \oplus \ldots a_j\)（即以 \(a_i\) 开头以 \(a_j\) 结尾的连续子序列中所有元素的异或和），推导公式：

\[b_j = \begin{cases} a_{i+1} & j = i+1 \\ a_j \oplus b_{j-1} & j \gt i+1 \end{cases} \]

\(c_j\) 表示的是 \(b_{i+1}, b_{i+2}, \ldots, b_j\) 的最大值，推导公式：

\[c_j = \begin{cases} b_{i+1} & j = i+1 \\ \min\{ b_j, c_{j-1} \} & j \gt i+1 \end{cases} \]

（注意，区别于 \(j \le i\) 的情况，这里 \(c_j\) 求的是最小值）

此时的状态是从前往后推（\(i+1 \rightarrow i+2 \rightarrow i+3 \rightarrow \ldots\)），可以发现 \(c_j\) 从前往后是非增的，因为 \(c_j\) 表示的是从 \(a_{i+1}\) 异或到 \(a_j\) 的过程中能够得到的结果的最小值。

也就是说，在 \(g \gt i\) 时，\(c_j\) 表示的含义是 \(a_{i+1}\) 往后合并 不超过 \(j - i - 1\) 次的情况下能够获得的最大值。

那么怎么能确保不超过 \(m\) 次操作能够存在两个相邻的数前者大于后者呢？

枚举合并的过程中最前面那个数的下标！

以 \(a_i\) 结尾合并 \(m\) 次能合并到 \(a_{i-m}\)，所以我们从 \(\max\{ i-m, 1\}\) 到 \(i\) 枚举下标 \(j\)，对于的下标区间范围是 \([j, j+m+1]\) —— 注意 \(j+m+1\) 可能大于 \(n\)，所可以开一个 \(k = j+m+1\)，对于的区间范围是 \([j, k]\)，当 \(k \gt n\) 时就不用继续操作了（因为 \(k \gt n\) 是左边一段变小，而右边一段固定，继续 \(j++\) 只会让左边一段异或和的最大值变小，而右边一段异或和的最小值是不会发生任何变换，所以继续 \(j++\) 没意义）它表示的含义是：

• \(a_i\) 能够合并到的最左边的数是 \(a_j\)
• \(a_{i+1}\) 能够合并到的最右边的数是 \(a_k\)

那么 \(a_i\) 往左合并的过程中的最大值就是 \(c_j\)，\(a_{i+1}\) 往右合并的过程中的最小值就是 \(c_k\)。只要 \(c_j \gt c_k\)，就说明不超过 \(m\) 次操作能够是数列变得不满足”非严格单调递增”性质。

对应的我可以开一个 check(int m) 函数进行判断。

但是这种方法只能判断在不超过 \(m\) 次合并时能够满足条件，不过可以发现，当 \(m\) 大于等于我们的最小操作次数时，check 函数总会返回 true；当 \(m\) 小于我们的最小操作次数时，check 函数总会返回 false。

所以可以对 check 函数二分答案。

示例程序：

#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int n, a[maxn], b[maxn], c[maxn];

bool check(int m) {
    for (int i = 1; i < n; i++) {
        b[i] = c[i] = a[i];
        for (int j = i-1; j >= max(1, i-m); j--) {
            b[j] = a[j] ^ b[j+1];
            c[j] = max(b[j], c[j+1]);
        }
        b[i+1] = c[i+1] = a[i+1];
        for (int j = i+2; j <= min(i+m+1, n); j++) {
            b[j] = a[j] ^ b[j-1];
            c[j] = min(b[j], c[j-1]);
        }
        for (int j = max(1, i-m); j <= i && j+m+1 <= n; j++)
            if (c[j] > c[j+m+1])
                return true;
    }
    return false;
}

int main() {
    cin >> n;
    for (int i = 1; i <= n; i++) cin >> a[i];
    int l = 0, r = n-2, res = -1;
    while (l <= r) {
        int mid = (l + r) / 2;
        if (check(mid)) res = mid, r = mid - 1;
        else l = mid + 1;
    }
    cout << res << endl;
    return 0;
}

方法二：贪心思想+枚举答案

上面二分答案的解法虽然能通过，但是分析一下，由于 check(m) 的时间复杂度是 \(O(n \cdot m)\) 的，\(m\) 接近 \(n\)，所以总的时间复杂度是 \(O(n^2 \log n)\) 的，之所以能过的原因最主要我觉得还是因为：

1. 当 \(n\) 比较大时，答案很小
2. 题目的 \(n\) 可能给的比较小
3. 或者别的原因（欢迎评论区补充）

可以发现，因为 \(1 \le a_i \le 10^9\)，所以 \(a_i\) 的二进制表示最多 \(30\) 位，而数列是非严格单调递增的，所以根据鸽笼/雀巢/抽屉原理，当 \(n \gt 60\) 时，必然存在连续的三个数 —— 假设这三个数是 \(a_i, a_{i+1}, a_{i+2}\) —— 的最高位的位数是相同的，此时将后两个数（即 \(a_{i+1}\) 和 \(a_{i+2}\)）异或能够消去最高位的 \(1\)，此时 \(a_i \gt a_{i+1} \oplus a_{i+2}\)（注意：本题中 \(a_i \ge 1\)，若 \(a_i\) 可以取 \(0\) 那还需要考虑排除 \(0\) 的影响），即：当 \(n \gt 60\) 时，答案为 \(1\)。

而当 \(n \le 60\) 时，直接用二分或者枚举答案都是可以的。

也就是说，在题目里面可以加一行

if (n > 60) {
    cout << 1 << endl;
    return 0;
}

来优化我们的程序。