Orig Description
Score : 500 points
Problem StatementYou are given a sequence (P_1,P_2,...,P_N) which is a permutation of the integers from 1 through N.
You would like to sort this sequence in ascending order by repeating the following operation:
Choose an element in the sequence and move it to the beginning or the end of the sequence.
Find the minimum number of operations required.
It can be proved that it is actually possible to sort the sequence using this operation.
Constraints
1 \leq N \leq 2\times 10^5
(P_1,P_2,...,P_N) is a permutation of (1,2,...,N).
All values in input are integers.
InputInput is given from Standard Input in the following format:
N
P_1
:
P_N
OutputPrint the minimum number of operations required.
Sample Input 14
1
3
2
4
Sample Output 12
For example, the sequence can be sorted in ascending order as follows:
Move 2 to the beginning. The sequence is now (2,1,3,4).
Move 1 to the beginning. The sequence is now (1,2,3,4).
Sample Input 26
3
2
5
1
4
6
Sample Output 24
Sample Input 38
6
3
1
2
7
4
8
5
Sample Output 35
Extracted Specification
An integer N (1 ≤ N ≤ 2 × 10^5), representing some quantity or size.
A list of integers P of size N, which is a permutation of the integers from 1 to N.
### Example Input:
```
4
1 3 2 4
```
### Function Signature:
Write a function f(N, P) that takes in the input.
```python
def f(N: int, P: List[int]):
'''
N: an integer
P: a list of integers
'''
```
Test Case Generator
Certainly! To generate test cases for this problem, where you need to sort a permutation of integers using the specified operation, we will create a function that generates a random permutation of integers from 1 to \(N\) and outputs this permutation along with its length \(N\).
Here is the test case generator for this problem:
```python
import random
def tcgen():
# Define the constraints
N = random.randint(1, 2 * 10**5) # N is a random integer between 1 and 200,000
# Generate a random permutation of integers from 1 to N
P = list(range(1, N + 1))
random.shuffle(P)
return N, P
# Example of how to use the test case generator
N, P = tcgen()
print(N)
for num in P:
print(num)
```
**Explanation:**
1. **N generation:** We generate \(N\) as a random integer between 1 and 200,000, adhering to the constraints provided.
2. **Permutation generation:** We create a list `P` that contains integers from 1 to \(N\) in ascending order and then shuffle it to create a random permutation.
3. **Return values:** The function returns the length \(N\) and the permutation `P`.
This generator ensures that each generated test case is valid according to the problem constraints and simulates the complexity that may be encountered in actual competitive programming scenarios.
Extract Arguments
def extract_arguments(fh):
N = int(fh.readline().strip())
P = [int(fh.readline().strip()) for _ in range(N)]
return N, P