Problem p04052 - Generation 2

Orig Description

Score : 2000 points
Problem StatementYou are given a permutation P_1 ... P_N of the set {1, 2, ..., N}.
You can apply the following operation to this permutation, any number of times (possibly zero):
Choose two indices i,j (1 ≦ i < j ≦ N), such that j - i ≧ K and |P_i - P_j| = 1.
Then, swap the values of P_i and P_j.
Among all permutations that can be obtained by applying this operation to the given permutation, find the lexicographically smallest one.
Constraints
2≦N≦500,000
1≦K≦N-1
P is a permutation of the set {1, 2, ..., N}.
InputThe input is given from Standard Input in the following format:
N K
P_1 P_2 ... P_N
OutputPrint the lexicographically smallest permutation that can be obtained.
Sample Input 14 2
4 2 3 1
Sample Output 12
1
4
3
One possible way to obtain the lexicographically smallest permutation is shown below:
4 2 3 1
4 1 3 2
3 1 4 2
2 1 4 3
Sample Input 25 1
5 4 3 2 1
Sample Output 21
2
3
4
5
Sample Input 38 3
4 5 7 8 3 1 2 6
Sample Output 31
2
6
7
5
3
4
8

Extracted Specification

An integer N (2 ≤ N ≤ 500,000), representing some quantity or size.
An integer K (1 ≤ K ≤ N-1), representing some threshold or limit.
A list of integers P of size N, representing a permutation of integers from 1 to N.

### Example Input:

```
4 2
4 2 3 1
```

### 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 write a test case generator for the given problem, we will need to generate:

1. An integer \( N \) (2 ≤ \( N \) ≤ 500,000), representing the size of the permutation.
2. An integer \( K \) (1 ≤ \( K \) ≤ \( N-1 \)).
3. A permutation \( P \) of the set {1, 2, ..., \( N \)}.

Here's a Python function to generate a random test case for this problem:

```python
import random

def generate_test_case():
    # Generate random N between 2 and 500,000
    N = random.randint(2, 500000)
    
    # Generate random K between 1 and N-1
    K = random.randint(1, N-1)
    
    # Generate a permutation of the set {1, 2, ..., N}
    P = list(range(1, N + 1))
    random.shuffle(P)
    
    return N, K, P

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

This function `generate_test_case` will:

1. Randomly generate an integer \( N \) between 2 and 500,000.
2. Randomly generate an integer \( K \) between 1 and \( N-1 \).
3. Create a permutation of the set \{1, 2, ..., \( N \)\}.
4. Shuffle the permutation to ensure it is random.

To use the test case generator, you can call `generate_test_case()` which will return the values of \( N \), \( K \), and the permutation \( P \). The example usage provided will print the generated values in the expected format.

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)