turns-00030.parquet:54815
e797ff758d85ce97d4fccb83degenerate_repetitionAbsentFinal dense release
USER
به شما جایگشت p 1 , p 2 , . . . , p n p 1 ,p 2 ,...,p n از اعداد ۱ تا n n داده شده است. شما میتوانید عملیات زیر را به هر تعداد دلخواهی(حتی صفر) روی جایگشت انجام دهید. دو عدد 1 ≤ i < j ≤ n 1≤i<j≤n انتخاب کنید که ∣ p i − p j ∣ = 1 ∣p i −p j ∣=1 و K ≤ j − i K≤j−i. بین تمام جایگشتهایی که از جایگشت اولیه میتوان به آنها رسید کوچکترین آنها از لحاظ لکسیکوگرافیکالی را پیدا کنید. ورودی در خط اول ورودی دو عدد n n و K K به ترتیب داده شدهاند. در خط دوم ورودی جایگشت p 1 , p 2 , . . . , p n p 1 ,p 2 ,...,p n داده شده است. 1 ≤ n ≤ 500 000 1≤n≤500 000 1 ≤ K ≤ n − 1 1≤K≤n−1 خروجی کوچکترین جایگشت از لحاظ لکسیکوگرافیکالی را در n n خط خروجی دهید. مثال ورودی نمونه ۱ 4 2 4 2 3 1 Plain text خروجی نمونه ۱ 2 1 4 3 Plain text ورودی نمونه ۲ 5 1 5 4 3 2 1 Plain text خروجی نمونه ۲ 1 2 3 4 5 Plain text ورودی نمونه ۳ 8 3 4 5 7 8 3 1 2 6 Plain text خروجی نمونه ۳ 1 2 6 7 5 3 4 8 python
ASSISTANT
To solve this problem, we need to determine the lexicographically smallest permutation achievable by performing the allowed swap operations on the given permutation. The operations allow you to swap two elements if they differ by exactly 1 and their positions are at least `K` apart.
### Approach:
1. **Understanding the Operations:**
- You can swap elements `p_i` and `p_j` if:
- `|p_i - p_j| = 1` (they differ by exactly 1).
- `j - i >= K` (their positions are at least `K` apart).
2. **Connected Components:**
- Elements that can be swapped directly or indirectly form connected components.
- Within each connected component, elements can be rearranged among themselves.
- To achieve the lexicographically smallest permutation, we should sort each connected component in increasing order and place them back into their respective positions.
3. **Implementation Steps:**
- **Map Values to Positions:** Create a mapping from each value to its current position in the permutation.
- **Union-Find (Disjoint Set Union - DSU):** Use DSU to group elements into connected components based on the swap conditions.
- **Sort Within Components:** For each connected component, sort the values and assign them to the sorted positions within the component.
4. **Edge Cases:**
- If `K = 1`, you can perform any adjacent swaps, allowing full sorting of the permutation.
- If `K` is large, the number of possible swaps decreases, and only specific elements might be sortable within their groups.
### Example Walkthrough:
Consider the first sample input:
```
4 2
4 2 3 1
```
- Initial permutation: `[4, 2, 3, 1]`
- Possible swaps:
- Swap `4` and `3` (positions 1 and 3) since `|4-3|=1` and `3-1=2 >= 2`.
- Swap `2` and `1` (positions 2 and 4) since `|2-1|=1` and `4-2=2 >= 2`.
- After performing these swaps, the lex smallest permutation achievable is `[2, 1, 4, 3]`.
### Python Implementation:
Below is the Python code that implements the above approach using the Union-Find data structure to group connected components and sort within them to achieve the desired permutation.
```python
import sys
import sys
import sys
import sys
def main():
import sys
import sys
sys.setrecursionlimit(1 << 25)
n, K = map(int, sys.stdin.readline().split())
p = list(map(int, sys.stdin.readline().split()))
pos = [0] * (n + 1)
for idx, val in enumerate(p):
pos[val] = idx
parent = list(range(n + 1))
def find(u):
while parent[u] != u:
parent[u] = parent[parent[u]]
u = parent[u]
return u
def union(u, v):
u_root = find(u)
v_root = find(v)
if u_root == v_root:
return
parent[v_root] = u_root
# Connect adjacent values if their positions differ by at least K
for val in range(1, n):
u = val
v = val +1
if abs(pos[u] - pos[v]) >= K:
union(u, v)
from collections import defaultdict
groups = defaultdict(list)
for val in range(1, n+1):
groups[find(val)].append(val)
# Assign sorted values to sorted positions within each group
# First, collect indices for each group
group_indices = defaultdict(list)
for val in range(1, n+1):
group_indices[find(val)].append(pos[val])
# Now, for each group, sort the values and sort the indices, then assign
result = [0]*n
for rep in groups:
vals = sorted(groups[rep])
indices = sorted(group_indices[rep])
for val, idx in zip(vals, indices):
result[idx] = val
for num in result:
print(num)
if __name__ == "__main__":
main()
```
### Explanation of the Code:
1. **Mapping Values to Positions:**
- We first create a list `pos` where `pos[v]` gives the current index of value `v` in the permutation.
2. **Union-Find Initialization:**
- Each value initially is in its own set. We use the `find` and `union` functions to group values that can be swapped directly or indirectly.
3. **Building the Connected Components:**
- For each pair of adjacent values `(v, v+1)`, if their positions differ by at least `K`, we unify their sets.
4. **Sorting Within Groups:**
- For each connected component, we sort the values and assign them to the sorted list of indices within the component to ensure the lex smallest order.
5. **Output:**
- Finally, we print the resulting permutation.
### Handling Large Inputs:
- The approach is efficient and handles large inputs (up to `500,000` elements) by using Union-Find with path compression, which ensures nearly constant time operations.
### Conclusion:
This approach ensures that within each connected component, the elements are sorted in the smallest possible order, resulting in the lexicographically smallest permutation achievable with the given swap constraints.