1806 还原排列的最少操作步数

题目描述：
给你一个偶数 n​​​​​​ ，已知存在一个长度为 n 的排列 perm ，其中 perm[i] == i​（下标 从 0 开始 计数）。
一步操作中，你将创建一个新数组 arr ，对于每个 i ：
如果 i % 2 == 0 ，那么 arr[i] = perm[i / 2]
如果 i % 2 == 1 ，那么 arr[i] = perm[n / 2 + (i - 1) / 2]
然后将 arr​​ 赋值​​给 perm 。
要想使 perm 回到排列初始值，至少需要执行多少步操作？返回最小的 非零 操作步数。

示例 1：
输入：n = 2
输出：1
解释：最初，perm = [0,1]
第 1 步操作后，perm = [0,1]
所以，仅需执行 1 步操作

示例 2：
输入：n = 4
输出：2
解释：最初，perm = [0,1,2,3]
第 1 步操作后，perm = [0,2,1,3]
第 2 步操作后，perm = [0,1,2,3]
所以，仅需执行 2 步操作

示例 3：
输入：n = 6
输出：4

提示：
2 <= n <= 1000
n​​​​​​ 是一个偶数

方法1：
主要思路：解题链接汇总
（1）模拟过程；

class Solution {
public:
    bool test(vector<int>&arr) {//判断当前数组是否复原
		for (int i = 0; i < arr.size(); ++i) {
			if (arr[i] != i) {
				return false;
			}
		}
		return true;
	}
	int reinitializePermutation(int n) {
		int res = 0;
		vector<int> perm(n, 0);
		for (int i = 1; i < n; ++i) {//对数组进行初始化
			perm[i] = i;
		}

		vector<int> arr(n);//辅助数组
		do {
			++res;//统计变换的次数
			for (int i = 0; i < n; i += 2) {//生成新的数组
				arr[i] = perm[i / 2];
				arr[i + 1] = perm[n / 2 + i / 2];
			}
			swap(arr, perm);//交换两个数组
		} while (!test(perm));//判断当前数组是否复原
		return res;
	}
};

//go语言实现

func test(arr []int) bool {
    for i:=0;i<len(arr);i++ {
        if arr[i]!=i {
            return false
        }
    }
    return true
}
func reinitializePermutation(n int) int {
    res := 0
    perm := make([]int,n)
    for i:=1;i<n;i++ {
        perm[i]=i
    }
    arr := make([]int,n)
    for true {
        res++
        for i:=0;i<n;i+=2 {
            arr[i]=perm[i/2]
            arr[i+1]=perm[n/2+i/2]
        }
        perm,arr=arr,perm
        if test(perm) {
            break
        }
    }
    return res
}