Problem p03346 - Generation 3

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, where each integer is between 1 and N, and all integers are distinct.

### 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

Sure! Here is a test case generator for the given problem statement:

```python
import random

def tcgen():
    # Generate a random N within the allowed constraint
    N = random.randint(1, 2 * 10**5)
    
    # Generate a 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
if __name__ == "__main__":
    N, P = tcgen()
    print(N)
    for p in P:
        print(p)
```

The `tcgen` function generates a random test case by:
1. Choosing a random integer `N` between 1 and 200,000 (inclusive).
2. Creating a list `P` that is a permutation of the integers from 1 to `N`.
3. Shuffling the list `P` to ensure it is in a random order.

The generated values of `N` and `P` can then be printed or used for testing purposes. Here is an example of how you might use the test case generator to print a test case. When running this script, it will generate a new random test case each time.

This test case generator ensures that the constraints specified in the problem statement are met, including that the sequence `P` is a permutation of the integers from 1 through `N`.

Extract Arguments

def extract_arguments(fh):
    N = int(fh.readline().strip())
    P = [int(fh.readline().strip()) for _ in range(N)]
    return N, P