建议先从easy version开始做。
easy version题解
题目
题意
给定长度为n(1<=n<=200000)的数组
1<=a[i]<=10^9
q个查询(1<=q<=200000)，每次查询，给定整数k(1<=k<=10^9)
初始时，每个元素状态都是红色。
对于第i次操作，每次选择从数组中选择一个元素进行操作。
- 如果当前元素状态为红色，则将该元素的值+i，并变更当前元素状态为蓝色。
- 如果当前元素状态为蓝色，则将该元素的值-i，并变更当前元素状态为红色。
问，经过k次操作后。得到的新数组，它的元素最小值min，最大能取多大。即求数组的最大 最小值。
思路
当k<=n时，我们贪心地把每个操作，应用到最小的k个元素，即可满足。
当k>n时，复用贪心思路。这里先假设n-k是偶数。
我们把前n大的元素，累加，应用到这n个元素。
怎么确保到最后n次操作时，每个元素的状态刚好是红色（即对应新增状态）呢？我们只要保证，在最后n次操作之前，每个元素都应用了偶数次即可。
为了确保在应用最后n次操作的时候，元素之间的变更最少（这里需要理解下，因为我们要求的是数组的最小值，因此，需要确保整体增加的时候，是相对均匀的）。
我们可以把前面k-n次操作，拆分成(+1,-2)，(+3,-4)…这样的成对操作，每个操作都只-1。
设a’为应用了最后n次操作的新数组。设num为剩余的-1操作。
令res = a’[i]-min(a’)。那么这res可以抵消掉数组的-1操作，且不会变更数组最小值。
经过res次-1操作后，数组a’则变成所有元素都相等了，那么之后，每n次-1，我们的数组最小值都会-1。（这里注意向上取整）
优化
利用上述思路，我们可以做到用O(qnlogn)解决问题。但hard version的n,q为200000，显然会TLE。考虑优化。
第一步，查询前预处理，将a数组进行排序处理。
对于k<=n的场景，我们需要更新a[i]，并从更新后的a数组获取最小值。
a[i] = a[i] - i + k, 0 <= i < k.
观察到，更新时，a[i]-i的值是与k无关的，我们可以预处理，计算关于a[i]-i的前缀最小值。那么每次查询，我们只需用O(1)的时间就可以快速得到最小值。
下面考虑k>n的场景。
考虑n和k奇偶性相同的场景（奇偶性不同的场景类似）
同样的，对于最小值的计算，我们可以抽取出a[i]-i去做预处理。
for (int i = 0; i < n; ++i) {
a[i] = a[i] - i + k;
}
对于数组a’更新后，每个元素超出当前最小值的部分，我们也可以做预处理。我们只需计算出它们的总和，减去n个当前最小值min，即为超出部分。
预处理后，每次计算，可以用O(1)的时间。
注意用long long储存。
long long res = sum(a[i]) + (k + (k-n+1))*n/2 - n*cur_min;
详见代码。
代码
#include<string>
#include<iostream>
#include<cmath>
#include<algorithm>
using namespace std;
#define ll long long
#define inf 2000000009
//#define inf 0x3f3f3f3f // 这个数太小了，，被坑了
const int maxn = 200010;
ll n, q, k;
ll a[maxn], pre[maxn]; // pre[j] = min(a[j]-j),0<=j<=i
ll suf[maxn]; // suf[i] = min(a[j]), i<=j<n
ll sum;
void init() {
pre[0] = a[0] - 0;
for (int i = 1; i < n; ++i) {
pre[i] = min(pre[i-1], a[i] - i);
}
suf[n] = inf;
for (int i = n - 1; i >= 0; --i) {
suf[i] = min(a[i], suf[i+1]);
}
sum = 0;
for (int i = 0; i < n; ++i) {
sum += a[i];
}
}
int cal() {
scanf("%lld", &k);
/*
if (n == 1000 && q == 999 && a[0] == 1000000000) { // debug
printf("k:%d\n", k);
bool flag = 1;
for (int i = 0; i < n; ++i) {
if (a[i] != 1000000000) {
printf("a[%d]:%d\n", i, a[i]);
flag = 0;
break;
}
}
if (flag) {
printf("all 1000000000 for a\n");
}
return 0;
}
*/
// k = 1000000000; // debug
if (k <= n) { // add [k,...,1] to minist topk elems.
return min(pre[k-1] + k, suf[k]);
}
ll num = k - (n - 1); // 用于统计操作数剩余量
ll mn; // 最小值
ll left = 0; // 每个元素超出当前最小值的部分 的总和
if ((k - n) % 2 == 0) { // n 和 k 奇偶性相同
--num;
mn = min(pre[n-1] + k, suf[n]);
left = sum + 1LL * (k + (k - n + 1)) * n / 2 - 1LL * n * mn; // 防爆long long
} else {
if (n == 1) { // specail judge
mn = suf[n-1];
} else {
mn = min(pre[n-2] + k, suf[n-1]);
}
left = sum + 1LL * (k + (k - n + 2)) * (n - 1) / 2 - 1LL * n * mn; // 防爆long long
}
num /= 2; // (increase,decrease)的对数
num = max(0LL, num - left);
num = (num + n - 1) / n; // mininum 需要 -1 的次数 ，需要向上取整
// printf("mn:%d num:%d\n", mn, num); // debug
return mn - num;
}
void solve() {
scanf("%lld%lld", &n, &q);
for (int i = 0; i < n; ++i) {
scanf("%lld", &a[i]);
}
sort(a, a + n);
init();
while (q--) {
printf("%d%c", cal(), !q ? '\n' : ' ');
}
}
void debug() {
n = 1000;
q = 1000;
for (int i = 0; i < n; ++i) {
a[i] = 1000000000;
}
init();
printf("%d\n", cal());
}
int main() {
int t = 1;
// scanf("%d", &t);
while (t--) {
// debug();
solve();
}
}
/*
*/
欢迎关注同名公众号
对方正在debug
今日份 听取wa声一片
那些杀不死你的，终将使你更加强大（暴风哭泣
