Codeforces1539F Strange Array (思维 最大连续子段和)

题目链接: Strange Array

大致题意

给你一个长度为n的数组a, 对于每一个元素ai, 你需要选择一段区间[l, r], 且满足i ∈ [l, r].

我们把这个区间排序后, i这个位置的元素离中心元素的距离称为 奇怪值, 而你要找到每一个元素的最大奇怪值.

本题中对于中心元素的定义: 若为数组长度为奇数, 则为(l + r) / 2, 若为偶数, 则为(l + r + 1) / 2.
本题对于排序时相等元素的处理方式: 可以按照任意顺序排列

解题思路

这个题的题意还是挺难理解的 and 写博客之前看了大佬们的题解, 太强了QAQ, 不是我这种小蒟篛能推导证明的
本文不给出公式性的证明, 因为博主太菜了QAQ, 主要聊聊我对于这个题的想法

我们如果要从原数组中选择一段区间[l, r], 还包含这个元素x, 那么要么离中心元素尽可能靠左, 要么尽可能靠右.
这相当于, 我们希望我们选取的元素, 要么①尽可能多的小于x, 要么②尽可能多的大于x. (相等的情况一会再说)

---

我们不妨先考虑情况①, 为了方便下文说明, 我们做如下定义:
big表示大于x的值的个数, small表示小于x的值的个数.

我们需要知道对于元素x所在位置index, 其左侧区间[1, index - 1], 设numl = small - big, 当我从index - 1开始向左扩展的过程中, 扩展到哪里numl最大. (不妨假设扩展到了l1位置时numl最大)

同理, 我们需要知道 右侧区间[index + 1, n] 中, 设numr = small - big, 从index + 1开始向右扩展的过程中, 扩展到哪里numr最大. (不妨假设扩展到了r1的位置时numr最大)

最终, 对于元素x, 情况①我们选取的最优区间一定满足[l, r] = [l1, r1]. 对于情况②分析同理

---

作为队内老DS选手, 我很快想到了这属于一个区间询问问题, 属于最大连续子段和问题.

我们通常用线段树来维护最大连续子段和问题, 初始树中的元素不妨都设为-1, 对于情况①而言, 我们从小到大的往树内修改元素, 把对应位置修改为1即可.

树中维护三个信息, lmax, rmax, sum. 表示最大连续左/右子段和, 以及区间总和. (详细信息维护见代码)

这样对于上述的numl, 相当于求[1, index - 1]区间的最大连续右子段和, numr相当于求[index + 1, r]区间的最大连续左子段和

我们同样对于情况①考虑, 我们不妨将序列按照二维排序, { value, index }, 表示排序的值, 和其下标, 按照值从小到大的顺序排列. 每次我们把小于等于当前元素的位置都进行修改, 然后分别查询lnum和rnum. 令num = lnum + rnum, 则答案为num / 2.

关于为什么小于等于当前元素的位置都进行修改:

因为相等的元素我们可以任意排列, 我们可以把相等的元素看作小于那一类的(因为排好序后都可以放在其左侧). 这样我们可以最大化答案.

关于答案为什么是num / 2, 此时相当于有num个小于x的元素, 以及一个元素x (大于x的元素可以认为抵消掉了), 排好序后, x的位置一定是在最右侧, 我们可以模拟一下, 发现num / 2就是结果.

---

对于情况②, 分析大致同于情况①, 但是最后的答案应为 (num + 1) / 2, 同样可以模拟一下发现规律.

---

额外的: 我并不确定大小元素相抵消的说法你们能不能理解, 于是这里额外再多说两句.

我们假设有序列[1, 2, 3, 4, 5, 6, 7], 我们令x = 5. 那么排好序后我们可以认为这个序列变为[3, 4, 5]. 我们可以看作区间[1, 2] 和 [6, 7]抵消了. 这样剩下三个元素, 我们发现中心元素为4, 距离为 元素个数 / 2 = 1.

AC代码

#include <bits/stdc++.h>
#define rep(i, n) for (int i = 1; i <= (n); ++i)
using namespace std;
typedef long long ll;
const int N = 2E5 + 10;
pair<int, int> a[N];
int res[N];

struct node {
	int l, r;
	int sum, lmax, rmax;
}t[N << 2];
void pushup(node& p, node&l, node& r) {
	p.sum = l.sum + r.sum;
	p.lmax = max(l.lmax, l.sum + r.lmax);
	p.rmax = max(r.rmax, r.sum + l.rmax);
}
void pushup(int x) { pushup(t[x], t[x << 1], t[x << 1 | 1]); }

void build(int l, int r, int x = 1) {
	t[x] = { l, r, -1, 0, 0 };
	if (l == r) return;
	int mid = l + r >> 1;
	build(l, mid, x << 1), build(mid + 1, r, x << 1 | 1);
	pushup(x);
}

void modify(int a, int c, int x = 1) {
	if (t[x].l == t[x].r) {
		t[x].sum = t[x].lmax = t[x].rmax = 1;
		return;
	}
	int mid = t[x].l + t[x].r >> 1;
	modify(a, c, x << 1 | (a > mid));
	pushup(x);
}

node ask(int l, int r, int x = 1) {
	if (l > r) { return { 0, 0, 0, 0, 0 }; }
	if (l <= t[x].l and r >= t[x].r) return t[x];
	int mid = t[x].l + t[x].r >> 1;
	if (r <= mid) return ask(l, r, x << 1);
	if (l > mid) return ask(l, r, x << 1 | 1);
	node res;
	node left = ask(l, r, x << 1), right = ask(l, r, x << 1 | 1);
	pushup(res, left, right);
	return res;
}
int main()
{
	int n; cin >> n;
	rep(i, n) scanf("%d", &a[i].first), a[i].second = i;
	sort(a + 1, a + 1 + n);

	build(1, n);
	int pos = 1;
	rep(i, n) {
		auto [val, index] = a[i];
		while (pos <= n and a[pos].first <= val) modify(a[pos++].second, 1);

		auto left = ask(1, index - 1);
		auto right = ask(index + 1, n);
        int num = left.rmax + right.lmax;
		res[index] = num / 2;
	}

	build(1, n);
	pos = n;
	for (int i = n; i >= 1; --i) {
		auto [val, index] = a[i];
		while (pos >= 1 and a[pos].first >= val) modify(a[pos--].second, 1);

		auto left = ask(1, index - 1);
		auto right = ask(index + 1, n);
        int num = left.rmax + right.lmax;
		res[index] = max(res[index], (num + 1) / 2);
	}

	rep(i, n) printf("%d%c", res[i], " \n"[i == n]);
	return 0;
}

END