Problem p02904 - Generation 1

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

Sure! To generate test cases for this problem, we need to consider creating permutations of length \(N\) and selecting a random \(K\) such that \(2 \leq K \leq N\).

Here's the test case generator for the given problem:

```python
import random

def tcgen():
    # Constraints
    min_N = 2
    max_N = 200000

    # Randomly generate N within the specified range
    N = random.randint(min_N, max_N)
    
    # Generate the permutation of (0, 1, ..., N-1)
    P = list(range(N))
    random.shuffle(P)
    
    # Randomly choose K such that 2 <= K <= N
    K = random.randint(2, N)
    
    return N, K, P

# Example usage
if __name__ == "__main__":
    N, K, P = tcgen()
    print(N)
    print(K)
    print(' '.join(map(str, P)))
```

### Explanation:
1. **N**: Generate a random integer \(N\) within the range [2, 200000].
2. **P**: Generate a permutation of integers from 0 to \(N-1\).
3. **K**: Generate a random integer \(K\) within the range [2, \(N\)].
4. **Output**: Print the values in the format specified by the problem statement.

This generator will create diverse test cases covering various scenarios for the given problem. Here is an example of how it could be used:

```python
if __name__ == "__main__":
    N, K, P = tcgen()
    print(N)
    print(K)
    print(' '.join(map(str, P)))
```

When you run the script, it will print a randomly generated test case, for example:

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

This output represents a permutation of size 5, with a subarray of size 3 to be sorted.

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

# if __name__ == "__main__":
#     input_path = sys.argv[1]
#     with open(input_path, 'r') as fh:
#     N, K, P = extract_arguments(fh)
#     f(N, K, P)