Problem p02904 - Generation 2

Orig Description

Score : 700 points
Problem StatementSnuke has a permutation (P_0,P_1,\cdots,P_{N-1}) of (0,1,\cdots,N-1).
Now, he will perform the following operation exactly once:
Choose K consecutive elements in P and sort them in ascending order.
Find the number of permutations that can be produced as P after the operation.
Constraints
2 \leq N \leq 200000
2 \leq K \leq N
0 \leq P_i \leq N-1
P_0,P_1,\cdots,P_{N-1} are all different.
All values in input are integers.
InputInput is given from Standard Input in the following format:
N K
P_0 P_1 \cdots P_{N-1}
OutputPrint the number of permutations that can be produced as P after the operation.
Sample Input 15 3
0 2 1 4 3
Sample Output 12
Two permutations can be produced as P after the operation: (0,1,2,4,3) and (0,2,1,3,4).
Sample Input 24 4
0 1 2 3
Sample Output 21
Sample Input 310 4
2 0 1 3 7 5 4 6 8 9
Sample Output 36

Extracted Specification

An integer N (2 ≤ N ≤ 200000), representing some quantity or size.
An integer K (2 ≤ K ≤ N), representing some quantity or size.
A list of integers P of size N, where each integer is between 0 and N-1 and all integers are unique.

### Example Input:

```
5
3
0 2 1 4 3
```

### Function Signature:
Write a function f(N, K, P) that takes in the input.
def f(N: int, K: int, P: List[int]):
    '''
    N: an integer
    K: an integer
    P: a list of integers
    '''

Test Case Generator

Certainly! Below is the test case generator for the given competitive programming problem:

```python
import random

def tcgen():
    # Generate N within the constraints
    N = random.randint(2, 200000)
    
    # Generate K within the constraints
    K = random.randint(2, N)
    
    # Generate a permutation of (0, 1, ..., N-1)
    P = list(range(N))
    random.shuffle(P)
    
    return N, K, P

# Example usage
N, K, P = tcgen()
print(N)
print(K)
print(' '.join(map(str, P)))
```

### Explanation:
1. **N**: We generate a random integer `N` such that \(2 \leq N \leq 200000\).
2. **K**: We generate a random integer `K` such that \(2 \leq K \leq N\).
3. **P**: We generate a permutation of the integers from 0 to \(N-1\), shuffle them to ensure randomness.

This generator ensures that the constraints of the problem are respected and provides valid random test cases. You can run the `tcgen` function to get a new test case every time.

Extract Arguments

def extract_arguments(fh):
    N, K = map(int, fh.readline().strip().split())
    P = list(map(int, fh.readline().strip().split()))
    return N, K, P