「刷题记录」P7476 「C.E.L.U-02」苦涩

题目背景

回想起自己的过往的人生，\(\text{YQH}\) 觉得心中充满了苦涩。如果人生能再来一次，我一定会少做一些傻事，少真香几次，然后大胆地去追寻自己的爱。可惜没有这样一个机会了。

题目描述

在 \(\text{YQH}\) 的梦中，他看到自己过去的记忆正在不断浮现在自己脑中。这些记忆带给他的是满满的苦涩。他想要强行忘记一些来减轻自己的苦涩。
\(\text{YQH}\) 的脑中可以被分成 \(n\) 个片区，每个片区相当于一个存放记忆的可重集，初始为空。他将进行 \(m\) 次这三种操作：
操作 \(1\)：区间 \(l\sim r\) 的片区中都浮现了一个苦涩值为 \(k\) 的记忆。
操作 \(2\)：\(\text{YQH}\) 开始清理 \(l\sim r\) 片区的记忆。如果一个片区 \(k\in[l,r]\) 且 \(k\) 中苦涩值最大的记忆与 \(l\sim r\) 片区中苦涩值最大的记忆相等，则将这个苦涩值最大的记忆忘记。如果在同一个片区有多个相同的苦涩值最大的记忆，则只忘记一个。如果这些片区内没有记忆，则无视。
操作 \(3\)：\(\text{YQH}\) 想知道，\(l\sim r\) 片区中苦涩值最大的记忆的苦涩值是多少，如果不存在，输出 \(-1\)。

输入格式

第一行两个数，\(n,m\)。
接下来 \(m\) 行，第一个数代表操作种类 \(op\)，对于操作 \(1\)，有三个数 \(l,r,k\)，对于操作 \(2\) 或 \(3\)，有两个数 \(l,r\)。

输出格式

对于每个操作 \(3\) 输出一行，代表答案。

样例 #1

样例输入 #1

5 4
1 1 3 2
1 2 4 3
2 3 3
3 1 3

样例输出 #1

3

样例 #2

样例输入 #2

6 6
1 1 6 2
1 3 3 2
1 3 4 3
2 3 4
3 3 3
3 4 4

样例输出 #2

2
2

提示

样例解释

样例解释一

下面为各操作之后 \(\text{YQH}\) 的大脑的状态：
第一次操作：\(\{2\},\{2\},\{2\},\varnothing,\varnothing\)
第二次操作：\(\{2\},\{2,3\},\{2,3\},\{3\},\varnothing\)
第三次操作：\(\{2\},\{2,3\},\{2\},\{3\},\varnothing\)
第四次操作询问 区间 \(1\sim 3\) 的最大值，所以答案是 \(3\)。

样例解释二

下面为各操作之后 \(\text{YQH}\) 的大脑的状态：
第一次操作：\(\{2\},\{2\},\{2\},\{2\},\{2\},\{2\}\)
第二次操作：\(\{2\},\{2\},\{2,2\},\{2\},\{2\},\{2\}\)
第三次操作：\(\{2\},\{2\},\{2,2,3\},\{2,3\},\{2\},\{2\}\)
第四次操作：\(\{2\},\{2\},\{2,2\},\{2\},\{2\},\{2\}\)
第五次操作询问 \(3\) 的最大值，所以答案是 \(2\)。
第六次操作询问 \(4\) 的最大值，所以答案是 \(2\)。

数据范围

Subtask	n	m	特殊性质
\(1(10pts)\)	\(\leq10^3\)	\(\le10^3\)	\(\diagdown\)
\(2(20pts)\)	\(\leq5\times10^4\)	\(\leq5\times10^4\)	没有操作 2
\(3(10pts)\)	\(\leq5\times10^4\)	\(\leq5\times10^4\)	操作 2 中 \(l=r\)
\(4(20pts)\)	\(\leq5\times10^4\)	\(\leq5\times10^4\)	\(\diagdown\)
\(5(20pts)\)	\(\leq2\times10^5\)	\(\leq2\times10^5\)	操作 2 中 \(l=r\)
\(6(20pts)\)	\(\leq2\times10^5\)	\(\leq2\times10^5\)	\(\diagdown\)

对于 \(100\%\) 的数据，\(n,m\le2\times10^5,k\le10^9\)

思路

一共有三个操作，别看他描述的花里胡哨的，其实就是区间加，区间删除，区间查询。
但是，由于区间加的操作，它的叶节点存储的不止有一个数字，而是一个数列，所以他和普通的线段树还不同，它的节点还要再套点其他东西
那么，我们要套什么呢？
它不是还要查询最大值吗，那我们就套一个堆
又有问题了，有区间操作，怎么下传懒标？将堆与孩子的堆进行合并——左偏树，想到这里，恭喜你，掉坑里了
左偏树合并是将整个堆都合并过去，他又不只有一个孩子，它和一个孩子合并了，那其他孩子呢？所以左偏树不行
既然传懒标很麻烦，那我们就不穿懒标了呗，这里介绍一个小优化——标记永久化
什么意思呢，就是标记不下放，永远留在当前位置
我们用堆来记录懒标，但是本题中标记永久化的不彻底，还有一种情况需要下传懒标，当堆顶元素与要删除的元素相等时，我们要下放懒标记

代码

定义线段树：

struct tree {
	int len;// 代表区间长度
	ll maxx;// 代表这个区间的最大值
	priority_queue<ll> q;// 大根堆记录并维护懒标
}t[N << 4];

建树操作：

void build(int cur, int l, int r) {// 建树
	t[cur].len = r - l + 1;// 求len
	t[cur].maxx = -1;// 求max
	t[cur].q.push(-1);// -1压堆底
	if(l == r)	return ;// 到达叶子节点
	int mid = (l + r) >> 1;
	build(ls, l, mid);
	build(rs, mid + 1, r);
}

这些与普通线段树没什么差异
接下来就是标记永久化

void addlazy(int cur, ll v) {// 永久化懒标记
	t[cur].q.push(v);// 插入懒标记
	t[cur].maxx = t[cur].maxx > v ? t[cur].maxx : v;
	// 将max值与懒标记比大小
}

更新操作

void pushup(int cur) {
	t[cur].maxx = max(max(t[ls].maxx, t[rs].maxx), t[cur].q.top());
	// 将左右孩子的最大值与懒标记的最大值比大小
}

插入操作

void insert(int cur, int l, int r, int ql, int qr, ll k) {// 插入
	if(ql <= l && r <= qr) {
		addlazy(cur, k);// 永久化标记
		return ;
	}
	int mid = (l + r) >> 1;
	if(ql <= mid)	insert(ls, l, mid, ql, qr, k);
	if(qr > mid)	insert(rs, mid + 1, r, ql, qr, k);
	pushup(cur);// pushup更新
}

查询操作

ll ask(int cur, int l, int r, int ql, int qr) {// 查询最大苦涩值
	if(ql <= l && r <= qr) {
		return t[cur].maxx;// 返回这个区间的最大苦涩值
	}
	ll ans = t[cur].q.top();// 懒标记的最大值
	int mid = (l + r) >> 1;
	if(ql <= mid)	ans = max(ans, ask(ls, l, mid, ql, qr));
	// 左子树的最大苦涩值
	if(qr > mid)	ans = max(ans, ask(rs, mid + 1, r, ql, qr));
	// 右子树的最大苦涩值
	return ans;
}

删除操作

void del(int cur, int l, int r, int ql, int qr, ll k) {
	if(ql <= l && r <= qr && t[cur].maxx < k)	return ;
	// 如果这个区间的最大值都比不过k,那就没有要删除的
	if(t[cur].q.top() == k) {// 最大的懒标记与k相等
		t[cur].q.pop();// 弹出
		pushdown(cur, l, r, ql, qr, k);// 下放懒标记
		if(l == r) {// 到达叶子节点,修改最大值
			t[cur].maxx = t[cur].q.top();
			//叶结点的最大值就是懒标最大值
		}
		else	pushup(cur);//更新最大值
		return ;
	}
	int mid = (l + r) >> 1;
	if(ql <= mid)	del(ls, l, mid, ql, qr, k);
	// 在左子树中删除
	if(qr > mid)	del(rs, mid + 1, r, ql, qr, k);
	// 在右子树中删除
	pushup(cur);
}

完整代码

#include <iostream>
#include <cstdio>
#include <queue>
#define ls (cur << 1)
#define rs (cur << 1 | 1)
typedef long long ll;
using namespace std;
const int N = 2e5 + 5;
int n, m;

struct tree {
	int len;// 代表区间长度
	ll maxx;// 代表这个区间的最大值
	priority_queue<ll> q;// 大根堆记录并维护懒标
}t[N << 4];

inline ll read() {
	ll x = 0;
	int fg = 0;
	char ch = getchar();
	while(ch < '0' || ch > '9') {
		fg |= (ch == '-');
		ch = getchar();
	}
	while(ch >= '0' && ch <= '9') {
		x = (x << 3) + (x << 1) + (ch ^ 48);
		ch = getchar();
	}
	return fg ? ~x + 1 : x;
}

void build(int cur, int l, int r) {// 建树
	t[cur].len = r - l + 1;// 求len
	t[cur].maxx = -1;// 求max
	t[cur].q.push(-1);// -1压堆底
	if(l == r)	return ;// 到达叶子节点
	int mid = (l + r) >> 1;
	build(ls, l, mid);
	build(rs, mid + 1, r);
}

void addlazy(int cur, ll v) {// 永久化懒标记
	t[cur].q.push(v);// 插入懒标记
	t[cur].maxx = t[cur].maxx > v ? t[cur].maxx : v;
	// 将max值与懒标记比大小
}

void pushup(int cur) {
	t[cur].maxx = max(max(t[ls].maxx, t[rs].maxx), t[cur].q.top());
	// 将左右孩子的最大值与懒标记的最大值比大小
}

void pushdown(int cur, int l, int r, int ql, int qr, ll k) {
// 把懒标记下放到[ql,qr]以外的其他区间中
	if(ql <= l && r <= qr)	return ;// 永久化标记
	int mid = (l + r) >> 1;
	if(ql > mid) {// 全在右子树上
		addlazy(ls, k);// 永久化标记
		pushdown(rs, mid + 1, r, ql, qr, k);// 下放标记
	}
	else {
		if(qr <= mid) {// 全在左子树上
			addlazy(rs, k);// 永久化标记
			pushdown(ls, l, mid, ql, qr, k);// 下放标记
		}
		else {// 跨左右子树
			pushdown(ls, l, mid, ql, qr, k);
			pushdown(rs, mid + 1, r, ql, qr, k);
		}
	}
	pushup(cur);
}

void insert(int cur, int l, int r, int ql, int qr, ll k) {// 插入
	if(ql <= l && r <= qr) {
		addlazy(cur, k);// 永久化标记
		return ;
	}
	int mid = (l + r) >> 1;
	if(ql <= mid)	insert(ls, l, mid, ql, qr, k);
	if(qr > mid)	insert(rs, mid + 1, r, ql, qr, k);
	pushup(cur);// pushup更新
}

void del(int cur, int l, int r, int ql, int qr, ll k) {
	if(ql <= l && r <= qr && t[cur].maxx < k)	return ;
	// 如果这个区间的最大值都比不过k,那就没有要删除的
	if(t[cur].q.top() == k) {// 最大的懒标记与k相等
		t[cur].q.pop();// 弹出
		pushdown(cur, l, r, ql, qr, k);// 下放懒标记
		if(l == r) {// 到达叶子节点,修改最大值
			t[cur].maxx = t[cur].q.top();
			//叶结点的最大值就是懒标最大值
		}
		else	pushup(cur);//更新最大值
		return ;
	}
	int mid = (l + r) >> 1;
	if(ql <= mid)	del(ls, l, mid, ql, qr, k);
	// 在左子树中删除
	if(qr > mid)	del(rs, mid + 1, r, ql, qr, k);
	// 在右子树中删除
	pushup(cur);
}

ll ask(int cur, int l, int r, int ql, int qr) {// 查询最大苦涩值
	if(ql <= l && r <= qr) {
		return t[cur].maxx;// 返回这个区间的最大苦涩值
	}
	ll ans = t[cur].q.top();// 懒标记的最大值
	int mid = (l + r) >> 1;
	if(ql <= mid)	ans = max(ans, ask(ls, l, mid, ql, qr));
	// 左子树的最大苦涩值
	if(qr > mid)	ans = max(ans, ask(rs, mid + 1, r, ql, qr));
	// 右子树的最大苦涩值
	return ans;
}

int main() {
	t[0].maxx = -1;
	t[0].q.push(-1);
	n = read();
	m = read();
	build(1, 1, n);
	for(int i = 1; i <= m; ++i) {
		int op = read();
		int l, r, k;
		if(op == 1) {
			l = read(), r = read(), k = read();
			insert(1, 1, n, l, r, k);// 插入节点
		}
		if(op == 2) {
			l = read(), r = read();
			k = ask(1, 1, n, l, r);// 找最大苦涩值
			if(k != -1)	del(1, 1, n, l, r, k);
			// 如果有最大苦涩值,删除
		}
		if(op == 3) {
			l = read(), r = read();
			printf("%lld\n", ask(1, 1, n, l, r));// 找最大苦涩值
		}
	}
	return 0;
}