CF1617C Paprika and Permutation 题解 贪心

Paprika and Permutation

传送门

Paprika loves permutations. She has an array $a_1,a_2,\dots ,a_n$. She wants to make the array a permutation of integers $1$ to $n$.

In order to achieve this goal, she can perform operations on the array. In each operation she can choose two integers $i$ ($1\le i\le n$) and $x$ ($x>0$), then perform $a_i:=a_i\mathrm{mod}x$ (that is, replace $a_i$ by the remainder of $a_i$ divided by $x$). In different operations, the chosen $i$ and $x$ can be different.

Determine the minimum number of operations needed to make the array a permutation of integers $1$ to $n$. If it is impossible, output $-1$.

A permutation is an array consisting of $n$ distinct integers from $1$ to $n$ in arbitrary order. For example, $[2,3,1,5,4]$ is a permutation, but $[1,2,2]$ is not a permutation ($2$ appears twice in the array) and $[1,3,4]$ is also not a permutation ($n=3$ but there is $4$ in the array).

Input

Each test contains multiple test cases. The first line contains a single integer $t$ ($1\le t\le 10^4$) — the number of test cases. Description of the test cases follows.

The first line of each test case contains an integer $n$ ($1\le n\le 10^5$).

The second line of each test case contains $n$ integers $a_1,a_2,\dots ,a_n$. ($1\le a_i\le 10^9$).

It is guaranteed that the sum of $n$ over all test cases does not exceed $2\cdot 10^5$.

Output

For each test case, output the minimum number of operations needed to make the array a permutation of integers $1$ to $n$, or $-1$ if it is impossible.

Example

input

4
2
1 7
3
1 5 4
4
12345678 87654321 20211218 23571113
9
1 2 3 4 18 19 5 6 7

output

1
-1
4
2

Note

For the first test, the only possible sequence of operations which minimizes the number of operations is:

• Choose $i=2$, $x=5$. Perform $a_2:=a_2\mathrm{mod}5=2$.

For the second test, it is impossible to obtain a permutation of integers from $1$ to $n$.

题目翻译

红辣椒喜欢排列组合。她有一个数组 $a_1,a_2,\dots ,a_n$ 。她想把数组变成一个从 $1$ 到 $n$ 的整数的置换。

为了实现这个目标，她可以对数组进行运算。在每次操作中，她可以选择两个整数 $i$ （ $1\le i\le n$ ）和 $x$ （ $x>0$ ），然后执行 $a_i:=a_i\mathrm{mod}x$ （即用 $a_i$ 除以 $x$ 的余数替换 $a_i$ ）。在不同的操作中，所选的 $i$ 和 $x$ 可能不同。可能会不同。

确定使数组成为整数 $1$ 至 $n$ 的排列所需的最少运算次数。如果不可能，则输出 $-1$ .

排列是由 $n$ 个不同的整数组成的数组，这些整数从 $1$ 到 $n$ 按任意顺序排列。例如， $[2,3,1,5,4]$ 是一个排列，但 $[1,2,2]$ 不是一个排列（ $2$ 在数组中出现了两次）， $[1,3,4]$ 也不是一个排列（ $n=3$ ，但数组中有 $4$ ）。

输入

每个测试包含多个测试用例。第一行包含一个整数 $t$ ( $1\le t\le 10^4$ ) - 测试用例数。测试用例说明如下。

每个测试用例的第一行都包含一个整数 $n$ ( $1\le n\le 10^5$ )。

每个测试用例的第二行包含 $n$ 个整数 $a_1,a_2,\dots ,a_n$ .( $1\le a_i\le 10^9$ ).

保证所有测试用例中 $n$ 的总和不超过 $2\cdot 10^5$ 。

输出

对于每个测试用例，输出使数组成为从 $1$ 到 $n$ 的整数排列所需的最少操作数，如果不可能，则输出 $-1$ 。

提示

对于第一个测试，唯一可能的操作序列是将操作次数减至最少：

• 选择 $i=2$ ， $x=5$ 。执行 $a_2:=a_2\mathrm{mod}5=2$ 。

对于第二个测试，不可能得到从 $1$ 到 $n$ 的整数排列。

注明

$以上来自CodeForces，翻译来源：DeepL。$
洛谷 MarkDown 格式还是太难绷了。

解题思路

题目要求将原序列通过对一个数取模或不取模，使得原序列中的元素可以组成 $1\sim n$ 的序列，要求最小的取模次数（如果无解，则输出 $-1$）。

为了取模次数最小，要注意：

• 对于一个数最多取一次模（显然）；
• 对于值在 $[1,n]$ 范围内的且之前没有相同值的元素不做修改。

然后考虑取模操作。先给出结论：一个正整数 $x$ 与一个小于等于 $x$ 的正整数 $y$ 相除后余数一定在 $[0,\lfloor \frac{n-1}{2}\rfloor ]$ 区间内。证明如下：

• 对于“$0$”，就是 $x$ 整除 $y$ 的情况；
• 对于“$\lfloor \frac{n-1}{2}\rfloor$”，显然为了余数尽可能大，则除数要尽可能大，当除数为 $\lceil \frac{n+1}{2}\rceil$ 时，余数最大。

那么解法显然就是先在输入序列元素时记录下值在区间 $[1,n]$ 内且之前没有相同值的元素，对于它们后期不做修改。再将序列从小到大排序，若元素 $a_i$ 满足 $a_i<\lfloor \frac{i}{2}\rfloor$ 则一定无解，直接输出 $-1$ 即可。

AC Code

#include<bits/stdc++.h>
using namespace std;
char buf[1048576], *p1, *p2;
template<typename T>inline void Super_Quick_Read(T &x) {
	bool f = 1;
	x = 0;
	char ch = (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 20, stdin), p1 == p2) ? 0 : *p1++);
	while (ch < '0' || ch > '9') {
		if (ch == '-') f = !f;
		ch = (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 20, stdin), p1 == p2) ? 0 : *p1++);
	}
	while (ch >= '0' && ch <= '9')x = (x << 1) + (x << 3) + (ch ^ 48), ch = (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 20, stdin), p1 == p2) ? 0 : *p1++);
	x = (f ? x : -x);
	return;
}
template<typename T>inline void Quick_Write(T x) {
	if (x < 0) putchar('-'), x = -x;
	if (x > 9) Quick_Write(x / 10);
	putchar(x % 10 + '0');
	return;
}
int n, a[200005];
bool Vis[200005];
int T[200005], Top;
int Answer;
signed main() {
	int t;
	Super_Quick_Read(t);
	bool flag;
	while (t--) {
		for (register int i = 1; i <= n; ++i) T[i] = Vis[i] = 0;
		Top = 0, Answer = 0, flag = 0, Super_Quick_Read(n);
		for (register int i = 1; i <= n; ++i) Super_Quick_Read(a[i]);
		sort(a + 1, a + n + 1);
		for (register int i = 1; i <= n; ++i) if (a[i] >= 1 && a[i] <= n && !Vis[a[i]]) Vis[a[i]] = 1;
			else T[++Top] = a[i];
		Top = 0;
		for (register int i = 1; i <= n; ++i)
			if (!Vis[i]) {
				++Top;
				if (T[Top] <= i << 1) {
					flag = 1;
					break;
				} else ++Answer;
			}
		if (flag) puts("-1");
		else Quick_Write(Answer), puts("");
	}
	return 0;
}