题解:P10540 [THUPC 2024 决赛] 古明地枣的袜子

每次操作 \((x, y)\) 表示将序列前 \(x\) 个数加上 \(y\)。我们可以将问题转化,序列在最终时刻位置 \(p\) 的值为这 \(r - l + 1\) 次操作中,满足 \(x_i \ge p\) 的所有 \(y_i\) 的和。也就是说,我们需要对所有的 \(p\),求出 \(\sum_{i=l}^r y_i [x_i \ge p]\) 的最大值。

由于 \(n\) 和 \(m\) 的规模较大,我们不能对于每次询问都去遍历所有的 \(p\)。注意到只有在输入中出现过的 \(x_i\) 及其相邻位置才有可能成为产生最大值的分界点,因此我们可以对 \(x_i\) 的出现频率进行根号分治与分块。

设定一个块长大小 \(B\),在代码实现中取值约为 \(1.2 \sqrt{n+m}\)。我们将出现过的 \(x_i\) 按照大小依次划分为若干个块。如果某一个 \(x_i\) 的出现次数大于等于 \(B\),我们就将其单独作为一个重块。对于这种重块,由于只对应单个值域节点,我们只需要预处理出整个序列中所有满足 \(x_i \ge p\) 的 \(y_i\) 的前缀和。在每次查询时,用操作区间右端点的前缀和减去左端点前缀和,即可在 \(O(1)\) 的时间内得到该位置在当前询问下的贡献。

如果连续的若干个 \(x_i\) 出现次数均小于 \(B\),我们就将它们合并成一个值域区间 \([L, R]\) 作为轻块,在遍历合并时保证在这个块中所有操作的总数尽量接近但不超过 \(B\)。对于每一个轻块,块内涉及到的操作数量较少。我们可以将属于该块的操作按照原序列顺序单独抽离出来,在值域上进行分治处理。

在分治的过程中,对于当前的一组操作,我们取它们 \(x_i\) 的中位数作为划分标准,将操作序列分成小于中位数的左半部分和大于中位数的右半部分。此时我们可以利用动态规划的思想,预处理出当前分治节点中,任意一个操作连续子区间所能得到的最大贡献。

具体地,设某一段子区间在当前分治节点右半部分产生的总和为,该区间内所有大于中位数的 \(y_i\) 之和。如果最终最优的位置 \(p\) 落在右半部分,那么当前子区间的最大贡献直接由右半部分对应映射区间的最大贡献得来;如果最优位置 \(p\) 落在左半部分,那么最大贡献就等于右半部分产生的 \(y_i\) 总和,加上左半部分对应映射区间的最大贡献。两者取最大值即可逐层向上合并。

对于每次查询 \([l, r]\),我们需要综合所有块对其产生的贡献并取最大值。对于每一个轻块,我们通过预处理的计数前缀和数组找出当前查询区间映射在块内的有效操作子区间,然后直接以 \(O(1)\) 的代价查表获取上述预处理好的内部最大贡献,最后再加上查询区间内所有满足 \(x_i > R\) 的操作的 \(y_i\) 的前缀和即可。

最后还需要注意一种边界情况。如果整个序列的最大值出现在所有操作涉及到的最大下标之后,此时由于没有任何操作能覆盖到那里,该位置的值恒为 \(0\)。因此如果最大的 \(x_i\) 并没有达到 \(n\),我们需要将所有询问的答案与 \(0\) 取一次最大值,以防在全为负数操作时产生误判。


#include<bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
namespace FastIO {
	const int BUFSIZE = 1 << 20;
	char ibuf[BUFSIZE], obuf[BUFSIZE];
	int ipos = 0, ilen = 0, opos = 0;
	inline char gc() {
		if (ipos == ilen) {
			ilen = fread(ibuf, 1, BUFSIZE, stdin);
			ipos = 0;
			if (ilen == 0) return EOF;
		}
		return ibuf[ipos++];
	}
	template<typename T>
	inline void read(T &x) {
		x = 0;
		int f = 1;
		char c = gc();
		while (c != '-' && (c < '0' || c > '9')) c = gc();
		if (c == '-') {
			f = -1;
			c = gc();
		}
		while (c >= '0' && c <= '9') {
			x = x * 10 + (c - '0');
			c = gc();
		}
		x *= f;
	}
	inline void write(long long x) {
		if (x == 0) {
			obuf[opos++] = '0';
			obuf[opos++] = '\n';
		} else {
			if (x < 0) {
				obuf[opos++] = '-';
				x = -x;
			}
			char tmp[25];
			int t = 0;
			while (x > 0) {
				tmp[t++] = '0' + x % 10;
				x /= 10;
			}
			while (t > 0) obuf[opos++] = tmp[--t];
			obuf[opos++] = '\n';
		}
		if (opos > BUFSIZE - 100) {
			fwrite(obuf, 1, opos, stdout);
			opos = 0;
		}
	}
	inline void flush() {
		fwrite(obuf, 1, opos, stdout);
		opos = 0;
	}
}
using namespace FastIO;
int n, m, a[500005], cnt[500005], B, tot, totv, v[500005], sumc[500005], t[25][1205], s[25][1205], cl[25][1205], cr[25][1205], totf;
long long b[500005], ans[500005], pre[500005], sm[25][1205], sc[25][1205], f[4000005];
struct Node {
	int l, r, id;
} query[500005];
struct Block {
	int l, r;
} block[500005];
void dfs(int d, int k, int &of) {
	int mid = a[s[d][(k + 1) / 2]], kl = 0, kr = 0, sl = 0, sr = 0, fl = 0, fr = 0;
	for (int i = 1; i <= k; i++) {
		int id = t[d][i];
		if (a[id] < mid) {
			t[d + 1][++kl] = id;
		}
	}
	for (int i = 1; i <= k; i++) {
		int id = s[d][i];
		if (a[id] < mid) {
			s[d + 1][++sl] = id;
		}
	}
	if (kl) {
		dfs(d + 1, kl, fl);
	}
	for (int i = 1; i <= k; i++) {
		int id = t[d][i];
		if (a[id] > mid) {
			t[d + 1][++kr] = id;
		}
	}
	for (int i = 1; i <= k; i++) {
		int id = s[d][i];
		if (a[id] > mid) {
			s[d + 1][++sr] = id;
		}
	}
	if (kr) {
		dfs(d + 1, kr, fr);
	}
	of = totf;
	int w = k + 1;
	totf += w * w;
	cl[d][0] = cr[d][0] = 0;
	sm[d][0] = sc[d][0] = 0;
	for (int i = 1; i <= k; i++) {
		int id = t[d][i];
		cl[d][i] = cl[d][i - 1] + (a[id] < mid);
		cr[d][i] = cr[d][i - 1] + (a[id] > mid);
		sm[d][i] = sm[d][i - 1] + (a[id] == mid ? b[id] : 0);
		sc[d][i] = sc[d][i - 1] + (a[id] > mid ? b[id] : 0);
	}
	for (int l = 1; l <= k; l++) {
		for (int r = l; r <= k; r++) {
			long long z = sm[d][r] - sm[d][l - 1] + sc[d][r] - sc[d][l - 1];
			if (kl) {
				int x = cl[d][l - 1] + 1, y = cl[d][r];
				if (x <= y) {
					z = max(z, z + f[fl + x * (kl + 1) + y]);
				}
			}
			if (kr) {
				int x = cr[d][l - 1] + 1, y = cr[d][r];
				long long u = 0;
				if (x <= y) {
					u = f[fr + x * (kr + 1) + y];
				}
				z = max(z, u);
			}
			f[of + l * w + r] = z;
		}
	}
}
signed main() {
	read(n);
	read(m);
	for (int i = 1; i <= n; i++) {
		read(a[i]);
		read(b[i]);
		cnt[a[i]]++;
	}
	for (int i = 1; i <= m; i++) {
		read(query[i].l);
		read(query[i].r);
		query[i].id = i;
		ans[i] = -INF;
	}
	B = max(1, (int)(1.2 * sqrt(n + m)));
	for (int i = 1; i <= n; i++) {
		if (cnt[i]) {
			v[++totv] = i;
		}
	}
	for (int i = 1; i <= totv;) {
		int l = i, s = 0;
		if (cnt[v[i]] >= B) {
			block[++tot] = {i, i};
			i++;
			continue;
		}
		while (i <= totv && cnt[v[i]] < B && s + cnt[v[i]] <= B) {
			s += cnt[v[i]];
			i++;
		}
		block[++tot] = {l, i - 1};
	}
	for (int j = 1; j <= tot; j++) {
		int L = v[block[j].l], R = v[block[j].r];
		if (block[j].l == block[j].r) {
			pre[0] = 0;
			for (int i = 1; i <= n; i++) {
				pre[i] = pre[i - 1] + (a[i] >= L ? b[i] : 0);
			}
			for (int i = 1; i <= m; i++) {
				int l = query[i].l, r = query[i].r;
				ans[query[i].id] = max(ans[query[i].id], pre[r] - pre[l - 1]);
			}
			continue;
		}
		int k = 0;
		pre[0] = sumc[0] = 0;
		for (int i = 1; i <= n; i++) {
			pre[i] = pre[i - 1] + (a[i] > R ? b[i] : 0);
			sumc[i] = sumc[i - 1] + (L <= a[i] && a[i] <= R);
			if (L <= a[i] && a[i] <= R) {
				t[0][++k] = i;
			}
		}
		for (int i = 1; i <= k; i++) {
			s[0][i] = t[0][i];
		}
		sort(s[0] + 1, s[0] + k + 1, [&](int x, int y) {
			return a[x] < a[y];
		});
		totf = 0;
		int ff = 0;
		dfs(0, k, ff);
		int w = k + 1;
		for (int i = 1; i <= m; i++) {
			int l = query[i].l, r = query[i].r;
			int x = sumc[l - 1] + 1, y = sumc[r];
			long long z = pre[r] - pre[l - 1];
			if (x <= y) {
				z += f[ff + x * w + y];
			}
			ans[query[i].id] = max(ans[query[i].id], z);
		}
	}
	if (v[totv] < n) {
		for (int i = 1; i <= m; i++) {
			ans[i] = max(ans[i], 0LL);
		}
	}
	for (int i = 1; i <= m; i++) {
		write(ans[i]);
	}
	flush();
	return 0;
}

posted @ 2026-11-11 15:10  xuyifei0302  阅读(3)  评论(0)    收藏  举报