Problem p02904 - Generation 3

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 permutation of integers P of size N, where each integer P[i] (0 ≤ P[i] ≤ N-1) is unique and all elements are different.

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

Sure! Below is a test case generator for the given problem statement.

```python
import random

def tcgen():
    N = random.randint(2, 200000)
    K = random.randint(2, N)
    
    P = list(range(N))
    random.shuffle(P)
    
    return N, K, P

# Function to format the test case for the problem statement
def format_test_case(N, K, P):
    return f"{N} {K}\n" + " ".join(map(str, P))

# Example usage:
N, K, P = tcgen()
test_case = format_test_case(N, K, P)
print(test_case)
```

### Explanation:
1. **N** is chosen randomly between 2 and 200,000.
2. **K** is chosen randomly between 2 and N.
3. **P** is generated as a permutation of numbers from 0 to N-1 and then shuffled to ensure randomness.

### Example Output:
```plaintext
5 3
0 2 1 4 3
```

This output corresponds to the sample input provided in the problem statement. You can generate multiple test cases by calling the `tcgen()` function multiple times. The `format_test_case` function formats the output to match the expected input format for the competitive programming problem.

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