D2. Red-Blue Operations (Hard Version)（思维/贪心/前缀和）-CSDN博客

本文链接：https://blog.csdn.net/weixin_43918473/article/details/130696066

建议先从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();
	}
}
/*

*/