【Codeforces】CF 2021 C2

Adjust The Presentation (Hard Version)

#数据结构 #模拟

题目描述

This is the hard version of the problem. In the two versions, the constraints on $q$ and the time limit are different. In this version, $0\le q\le 2\cdot 10^5$. You can make hacks only if all the versions of the problem are solved.

A team consisting of $n$ members, numbered from $1$ to $n$, is set to present a slide show at a large meeting. The slide show contains $m$ slides.

There is an array $a$ of length $n$. Initially, the members are standing in a line in the order of $a_1,a_2,\dots ,a_n$ from front to back. The slide show will be presented in order from slide $1$ to slide $m$. Each section will be presented by the member at the front of the line. After each slide is presented, you can move the member at the front of the line to any position in the lineup (without changing the order of the rest of the members). For example, suppose the line of members is $[3,1,2,4]$. After member $3$ presents the current slide, you can change the line of members into either $[3,1,2,4]$, $[1,3,2,4]$, $[1,2,3,4]$ or $[1,2,4,3]$.

There is also an array $b$ of length $m$. The slide show is considered good if it is possible to make member $b_i$ present slide $i$ for all $i$ from $1$ to $m$ under these constraints.

However, your annoying boss wants to make $q$ updates to the array $b$. In the $i$-th update, he will choose a slide $s_i$ and a member $t_i$ and set $b_{s_i}:=t_i$. Note that these updates are persistent, that is changes made to the array $b$ will apply when processing future updates.

For each of the $q+1$ states of array $b$, the initial state and after each of the $q$ updates, determine if the slideshow is good.

输入格式

Each test contains multiple test cases. The first line contains the number of test cases $t$ ($1\le t\le 10^4$). The description of the test cases follows.

The first line of each test case contains three integers $n$, $m$ and $q$ ($1\le n,m\le 2\cdot 10^5$; $0\le q\le 2\cdot 10^5$) — the number of members and the number of sections.

The second line of each test case contains $n$ integers $a_1,a_2,\dots ,a_n$ ($1\le a_i\le n$) — the initial order of the members from front to back. It is guaranteed that each integer from $1$ to $n$ appears exactly once in $a$.

The third line of each test case contains $m$ integers $b_1,b_2,\dots ,b_m$ ($1\le b_i\le n$) — the members who should present each section.

Each of the next $q$ lines contains two integers $s_i$ and $t_i$ ($1\le s_i\le m$, $1\le t_i\le n$) — parameters of an update.

It is guaranteed that the sum of $n$, the sum of $m$ and the sum of $q$ over all test cases do not exceed $2\cdot 10^5$ respectively.

输出格式

For each test case, output $q+1$ lines corresponding to the $q+1$ states of the array $b$. Output “YA” if the slide show is good, and “TIDAK” otherwise.

You can output the answer in any case (upper or lower). For example, the strings “yA”, “Ya”, “ya”, and “YA” will be recognized as positive responses.

样例 #1

样例输入 #1

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

样例输出 #1

YA
TIDAK
YA
YA
TIDAK
YA
TIDAK
YA
YA

解法

解题思路

在$easy$版本中，我们知道，$b$中每个数第一次出现时，必须保证这个数在$a$中的下标(假设为$i$)，那么$a[i-1]$这个数字在$b$中出现过。

即，如下的数列是不合法，因为$4$对应的$a$中位置的前一个数是$3$，而$3$不在$b$中$4$之前出现过。
$$a[1,2,3,4,5]b[1,2,4,3,5]$$

那么，我们知道，每个数都只与第一次出现有关，它对它前面一个第一次出现的数，和后面第一个出现的数有影响。

因此我们维护一个$pos$数组，表示每个数第一次出现的位置。

考虑修改操作对答案的影响，修改操作我们看做删除后再插入。

那么删除的影响是什么？

$1.$ 如果删除的那个数不是第一次出现的数，那么显然没有影响。
$2.$ 如果删除的那个数是第一次出现的数，那么它对它前驱和后继的影响就该删去，然后它的后继对它的前驱的影响就要增加。

插入的影响又是什么？ 其实就是反过来再来一遍：

$1.$ 如果插入的那个数不是第一次出现的数，那么显然没有影响。
$2.$ 如果插入的那个数是第一次出现的数，那么它对它前驱和后继的影响就该增加，然后它的后继对它的前驱的影响就该删除。

对于如何判断某个数是否是第一个出现的数，我们可以对每种数$(a[i]\le n)$开一个$std::set$，用于动态维护存在的下标即可。

代码

void solve() {
	int n, m, q;
	std::cin >> n >> m >> q;


	std::vector<int>a(n + 1), b(m + 1), pos(n + 1);
	for (int i = 1; i <= n; ++i) {
		std::cin >> a[i];
		pos[a[i]] = i;
	}

	for (int i = 1; i <= m; ++i) {
		std::cin >> b[i];
	}

	std::set<int>fst;
	fst.insert(0);

	std::vector<std::set<int>>st(n + 1);

	int cnt = 0;
	auto add = [&](int num, int idx, int f) {
		auto nxt = fst.upper_bound(idx);
		if (nxt != fst.end()) {
			if (pos[num] + 1 != pos[b[*nxt]]) {
				cnt += f;  // 增加 nxt 对 self 的影响
			}
		}

		auto pre = prev(fst.lower_bound(idx));
		if (pos[b[*pre]] + 1 != pos[num]) {
			cnt += f;
		}

		if (nxt != fst.end()) {
			if (pos[b[*pre]] + 1 != pos[b[*nxt]]) {
				cnt -= f;
			}
		}

		};

	for (int i = 1; i <= m; i++) {
		if (st[b[i]].empty()) {
			add(b[i], i, 1);
			fst.insert(i);
		}
		st[b[i]].insert(i);
	}

	std::cout << (cnt ? "TIDAK" : "YA") << "\n";

	while (q--) {
		int s, t;
		std::cin >> s >> t;

		if (*st[b[s]].begin() == s) {
			fst.erase(s);
			add(b[s], s, -1);
			st[b[s]].erase(s);
			if (!st[b[s]].empty()) {
				add(b[s], *st[b[s]].begin(), 1);
				fst.insert(*st[b[s]].begin());
			}
		}
		else {
			st[b[s]].erase(s);
		}

		b[s] = t;

		if (!st[t].empty() && *st[t].begin() > s) {
			fst.erase(*st[t].begin());
			add(t, *st[t].begin(), -1);
		}
		st[t].insert(s);
		if (*st[t].begin() == s) {
			add(t, *st[t].begin(), 1);
			fst.insert(s);
		}
		std::cout << (cnt ? "TIDAK" : "YA") << "\n";

	}

}

signed main() {
	std::ios::sync_with_stdio(0);
	std::cin.tie(0);
	std::cout.tie(0);

	int t = 1;
	std::cin >> t;

	while (t--) {
		solve();
	}
};```