【Codeforces】 CF 2009 G1

Yunli’s Subarray Queries (easy version)

#莫队 #数据结构

题目描述

This is the easy version of the problem. In this version, it is guaranteed that $r=l+k-1$ for all queries.

For an arbitrary array $b$, Yunli can perform the following operation any number of times:

• Select an index $i$. Set $b_i=x$ where $x$ is any integer she desires ($x$ is not limited to the interval $[1,n]$).

Denote $f(b)$ as the minimum number of operations she needs to perform until there exists a consecutive subarray${}^{\text{∗}}$ of length at least $k$ in $b$.

Yunli is given an array $a$ of size $n$ and asks you $q$ queries. In each query, you must output ${\sum }_{j=l+k-1}^{r}f([a_l,a_{l+1},\dots ,a_j])$. Note that in this version, you are only required to output $f([a_l,a_{l+1},\dots ,a_{l+k-1}])$.

${}^{\text{∗}}$If there exists a consecutive subarray of length $k$ that starts at index $i$ ($1\le i\le |b|-k+1$), then $b_j=b_{j-1}+1$ for all $i\le ;j\le i+k-1$.

输入格式

The first line contains $t$ ($1\le t\le 10^4$) — the number of test cases. The first line of each test case contains three integers $n$, $k$, and $q$ ($1\le k\le n\le 2\cdot 10^5$, $1\le q\le 2\cdot 10^5$) — the length of the array, the length of the consecutive subarray, and the number of queries. The following line contains $n$ integers $a_1,a_2,\dots ,a_n$ ($1\le a_i\le n$). The following $q$ lines contain two integers $l$ and $r$ ($1\le l\le r\le n$, $r=l+k-1$) — the bounds of the query. It is guaranteed that the sum of $n$ over all test cases does not exceed $2\cdot 10^5$ and the sum of $q$ over all test cases does not exceed $2\cdot 10^5$.

输出格式

Output ${\sum }_{j=l+k-1}^{r}f([a_l,a_{l+1},\dots ,a_j])$ for each query on a new line.

样例 #1

样例输入 #1

3
7 5 3
1 2 3 2 1 2 3
1 5
2 6
3 7
8 4 2
4 3 1 1 2 4 3 2
3 6
2 5
5 4 2
4 5 1 2 3
1 4
2 5

样例输出 #1

2
3
2
2
2
2
1

解法

解题思路

$Easy$版本的窗口大小是固定的，也就是每次给定一个固定的窗口大小和起点，找最小需要被修改的次数，使其内部完全都是连续的$k$个数。

首先，如何判断窗口内的每个数是否是连续递增的，且相差为$1$呢？

例如以下的数列：
$$[1,2,5,6,7,8,9]$$

可以发现，对于这个窗口$[1,2]$是连续的$[5,6,7,8,9]$也是连续的，它们的值-下标的大小是一样的，比如前者是$0$，后者是$2$。 这样问题就迎刃而解了，我们只需要维护这个窗口中出现最多的那个数的次数，然后用窗口大小减去这个次数，就是要修改的最少次数了。

而对于多个询问，而不存在修改的问题，我们容易想到使用莫队算法来离线处理，当指针移动的时候就使用上述的方法来维护一个存放出现次数的$mutiset$，每次更新答案即可。

代码

 
int n, m, k, len;
struct node {
	int l, r, id;
	bool operator<(node& x) {
		if ((l - 1) / len + 1 != (x.l - 1) / len + 1) return l < x.l;
		if (((l - 1) / len + 1) & 1) return r < x.r;
		else return r > x.r;
	}
}q[N];

void solve() {
	cin >> n >> k >> m;
 
	len = sqrt(m);
	vector<int>a(n + 1);
	for (int i = 1; i <= n; ++i) {
		cin >> a[i];
	}
 
	for (int i = 1; i <= m; ++i) {
		int l, r;
		cin >> l >> r;
		q[i] = { l,r,i };
	}
	
	map<int, int>mp;
	multiset<int>mst;
	sort(q + 1, q + 1 + m);
	
	auto add = [&](int idx)->void {
		mst.extract(mp[a[idx] - idx]);
		mp[a[idx] - idx]++;
		mst.insert(mp[a[idx] - idx]);
		};
 
	auto del = [&](int idx)->void {
		mst.extract(mp[a[idx] - idx]);
		mp[a[idx] - idx]--;
		mst.insert(mp[a[idx] - idx]);
		};
 
	int l = 1, r = 0;
	vector<int>res(m + 1);
	for (int i = 1; i <= m; ++i) {
		while (l > q[i].l) 	add(--l);
		while (l < q[i].l) del(l++);
		while (r < q[i].r) add(++r);
		while (r > q[i].r) del(r--);
 
		res[q[i].id] = k - *mst.rbegin();
		
	}
 
	for (int i = 1; i <= m; ++i) {
		std::cout << res[i] << "\n";
		q[i] = { 0,0,0 };
	}
 
}
signed main() {
	ios::sync_with_stdio(0);
	std::cin.tie(0);
	std::cout.tie(0);
	int t = 1;
	cin >> t;
	while (t--) {
		solve();
	}
};