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)