Formatted question description: https://leetcode.ca/all/1806.html

# 1806. Minimum Number of Operations to Reinitialize a Permutation

## Level

Medium

## Description

You are given an **even** integer `n`

. You initially have a permutation `perm`

of size `n`

where `perm[i] == i`

**(0-indexed)**.

In one operation, you will create a new array `arr`

, and for each `i`

:

- If
`i % 2 == 0`

, then`arr[i] = perm[i / 2]`

. - If
`i % 2 == 1`

, then`arr[i] = perm[n / 2 + (i - 1) / 2]`

.

You will then assign `arr`

to `perm`

.

Return *the minimum non-zero number of operations you need to perform on perm to return the permutation to its initial value*.

**Example 1:**

**Input:** n = 2

**Output:** 1

**Explanation:** nums = [0,1] initially.

After the 1st operation, nums = [0,1]

So it takes only 1 operation.

**Example 2:**

**Input:** n = 4

**Output:** 2

**Explanation:** nums = [0,1,2,3] initially.

After the 1st operation, nums = [0,2,1,3]

After the 2nd operation, nums = [0,1,2,3]

So it takes only 2 operations.

**Example 3:**

**Input:** n = 6

**Output:** 4

**Constraints:**

`2 <= n <= 1000`

`n`

is even.

## Solution

Simply simulate the process. Create two arrays `init`

of `perm`

, each of which has length `n`

, and initialize `init[i] = perm[i] = i`

for `0 <= i < n`

. Then update `perm`

each time until `perm`

equals `init`

, and return the number of operations.

```
class Solution {
public int reinitializePermutation(int n) {
int[] init = new int[n];
int[] perm = new int[n];
for (int i = 0; i < n; i++) {
init[i] = i;
perm[i] = i;
}
int ops = 0;
while (true) {
ops++;
update(n, perm);
if (Arrays.equals(perm, init))
break;
}
return ops;
}
public void update(int n, int[] perm) {
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
if (i % 2 == 0)
arr[i] = perm[i / 2];
else
arr[i] = perm[n / 2 + (i - 1) / 2];
}
System.arraycopy(arr, 0, perm, 0, n);
}
}
```