CF997E. Good Subsegments(线段树，单调栈)

最新推荐文章于 2025-03-14 16:40:25 发布

原创最新推荐文章于 2025-03-14 16:40:25 发布 · 383 阅读

0 ·

CC 4.0 BY-SA版权

本文介绍CF997E.GoodSubsegments题目的一种高效解法，利用单调栈维护区间信息，通过离线询问的方法处理区间询问，最终达到O(mlgn)的时间复杂度。

CF997E. Good Subsegments

Description

给定一个序列，多次询问一个区间内的连续段个数。
$\leq 2\times 10^{5}$

Solution

算得上是经典题了吧。

Part one

先考虑求全部的连续段个数。

相当于求区间内 $m x - m n + 1 - l e n = 0$ 的子区间个数，且显然有 $\geq 0$ ，因此相当于维护最小值及其个数。于是我们考虑从前往后枚举区间右端点 $r$ ，维护所有右端点为 $r$ 的区间的信息。

不难观察到前缀 $m x$ 和前缀 $m n$ 的单调性，每次我们加入一个 $p_r$ 时，会让一段后缀的 $m x$ 和一段后缀的 $m n$ 改变，且改变的这一段后缀 $m x$ 会变成 $p_r$ ， $m n$ 同理。于是我们用单调栈分别维护前缀 $m x, m n$ 的连续段，每次弹栈的时候做区间加就可以维护我们需要的信息了。

这样的时间复杂度是 $O (m l g n)$ 的。

Part two

再考虑区间询问，上述枚举右端点的做法启示我们离线询问。考虑每个右端点的询问，限制 $[l, r]$ 相当于是只能统计左端点在 $l$ 后面的连续段。

然后我们考虑维护 $c_l$ 表示当前右端点为 $r$ （枚举的右端点），左端点为 $l$ 的连续段个数，然后询问就是一段区间和。这个直接在线段树上打 $t a g$ ，表示这个区间的最小值为 $0$ 的点都有多少次新增的贡献即可维护。

实现时注意下传 $t a g$ 的标记即可。
时间复杂度 $O (m l g n)$ 。

Code

#include <bits/stdc++.h>
 
using namespace std;
 
template<typename T> inline bool upmin(T &x, T y) { return y < x ? x = y, 1 : 0; }
template<typename T> inline bool upmax(T &x, T y) { return x < y ? x = y, 1 : 0; }
 
#define MP(A,B) make_pair(A,B)
#define PB(A) push_back(A)
#define SIZE(A) ((int)A.size())
#define LEN(A) ((int)A.length())
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define fi first
#define se second
 
typedef long long ll;
typedef unsigned long long ull;
typedef long double lod;
typedef pair<int, int> PR;
typedef vector<int> VI; 
 
const lod eps = 1e-9;
const lod pi = acos(-1);
const int oo = 1 << 30;
const ll loo = 1ll << 62;
const int mods = 1e9 + 7;
const int MAXN = 300005;
const int INF = 0x3f3f3f3f; //1061109567
/*--------------------------------------------------------------------*/
 
namespace FastIO{
	constexpr int SIZE = (1 << 21) + 1;
	int num = 0, f;
	char ibuf[SIZE], obuf[SIZE], que[65], *iS, *iT, *oS = obuf, *oT = obuf + SIZE - 1, c;
	#define gc() (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)), (iS == iT ? EOF : *iS ++)) : *iS ++)
	inline void flush() {
		fwrite(obuf, 1, oS - obuf, stdout);
		oS = obuf;
	}
	inline void putc(char c) {
		*oS ++ = c;
		if (oS == oT) flush();
	}
	inline void getc(char &c) {
		for (c = gc(); c < 'A' || c > 'Z' ; c = gc());
	}
	template<class I>
	inline void read(I &x) {
		for (f = 1, c = gc(); c < '0' || c > '9' ; c = gc()) if (c == '-') f = -1;
		for (x = 0; c >= '0' && c <= '9' ; c = gc()) x = (x << 3) + (x << 1) + (c & 15);
		x *= f;
	}
	template<class I>
	inline void print(I x) {
		if (x < 0) putc('-'), x = -x;
		if (!x) putc('0');
		while (x) que[++ num] = x % 10 + 48, x /= 10;
		while (num) putc(que[num --]);
	}
	struct Flusher_{~Flusher_(){flush();}} io_Flusher_;
}
using FastIO :: read;
using FastIO :: print;
using FastIO :: putc;

ll Ans[MAXN], c[MAXN << 2], tagc[MAXN << 2];
int MX = 0, tag[MAXN << 2], mn[MAXN << 2], s[MAXN << 2], stkmx[MAXN], stkmn[MAXN], p[MAXN];
void up(int x) {
	mn[x] = min(mn[x << 1], mn[x << 1 | 1]);
	s[x] = (mn[x << 1] == mn[x]) * s[x << 1] + (mn[x << 1 | 1] == mn[x]) * s[x << 1 | 1];
}
void down(int x) {
	if (tag[x] != 0) {
		mn[x << 1] += tag[x], mn[x << 1 | 1] += tag[x]; 
		tag[x << 1] += tag[x], tag[x << 1 | 1] += tag[x];
		tag[x] = 0;
	}
	if (tagc[x] != 0) {
		if (mn[x << 1] == mn[x]) c[x << 1] += tagc[x] * s[x << 1], tagc[x << 1] += tagc[x];
		if (mn[x << 1 | 1] == mn[x]) c[x << 1 | 1] += tagc[x] * s[x << 1 | 1], tagc[x << 1 | 1] += tagc[x];
		tagc[x] = 0;
	}
}
void build(int x, int l, int r) {
	if (l == r) { mn[x] = r - l + 1, s[x] = 1; return; }
	int mid = (l + r) >> 1;
	build(x << 1, l, mid);
	build(x << 1 | 1, mid + 1, r);
	up(x);
}
void update(int x, int l, int r, int L, int R, int y) {
	if (l >= L && r <= R) { mn[x] += y, tag[x] += y;  return; }
	down(x);
	int mid = (l + r) >> 1;
	if (R <= mid) update(x << 1, l, mid, L, R, y);
	else if (L > mid) update(x << 1 | 1, mid + 1, r, L, R, y);
	else update(x << 1, l, mid, L, mid, y), update(x << 1 | 1, mid + 1, r, mid + 1, R, y);
	up(x);
}
ll query(int x, int l, int r, int L, int R) {
	if (l >= L && r <= R) return c[x];
	down(x);
	int mid = (l + r) >> 1;
	if (R <= mid) return query(x << 1, l, mid, L, R);
	else if (L > mid) return query(x << 1 | 1, mid + 1, r, L, R);
	else return query(x << 1, l, mid, L, mid) + query(x << 1 | 1, mid + 1, r, mid + 1, R);
}
struct Qnode{ int l, r, id; } Q[MAXN];
signed main() {
#ifndef ONLINE_JUDGE
	freopen("a.in", "r", stdin);
#endif
	int n, m; 
	read(n);
	for (int i = 1; i <= n ; ++ i) read(p[i]);
	read(m);
	for (int i = 1; i <= m ; ++ i) read(Q[i].l), read(Q[i].r), Q[i].id = i;
	
	sort(Q + 1, Q + m + 1, [&](Qnode x, Qnode y){ return x.r < y.r; });
	build(1, 1, n);	
	for (int i = 1, topmx = 0, topmn = 0, nw = 1; i <= n ; ++ i) {
		while (topmx && p[stkmx[topmx]] < p[i]) update(1, 1, n, stkmx[topmx - 1] + 1, stkmx[topmx], -p[stkmx[topmx]]), -- topmx;
		while (topmn && p[stkmn[topmn]] > p[i]) update(1, 1, n, stkmn[topmn - 1] + 1, stkmn[topmn], p[stkmn[topmn]]), -- topmn;
		update(1, 1, n, 1, i, -1);
		update(1, 1, n, stkmx[topmx] + 1, i, p[i]);
		update(1, 1, n, stkmn[topmn] + 1, i, -p[i]);
		stkmx[++ topmx] = i;
		stkmn[++ topmn] = i;
		down(1), ++ tagc[1], c[1] += s[1];
		while (nw <= m && Q[nw].r == i) Ans[Q[nw].id] = query(1, 1, n, Q[nw].l, i), ++ nw;
	}
	for (int i = 1; i <= m ; ++ i) print(Ans[i]), putc('\n');
	return 0;
}