计算将数组转换为目标数组所需的最少分组数

import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class ArrayGroupingConverter {

    /**
     * 计算将 arr1 转换为 arr2 所需的最少分组数。
     * 
     * @param arr1 原始数组
     * @param arr2 目标数组
     * @return 最少分组数
     */
    public static int calculateMinGroups(int[] arr1, int[] arr2) {
        // 1. 构建 arr2 的元素到索引的映射
        Map<Integer, Integer> indexByValue = mapIndices(arr2);

        // 初始化分组计数器为 1 (至少一个分组)
        int groupCount = 1;

        // 获取 arr1 第一个元素在 arr2 中的索引，作为当前分组的起始索引
        int prevIndexInTarget = indexByValue.get(arr1[0]);

        // 2. 遍历 arr1，从第二个元素开始
        for (int i = 1; i < arr1.length; i++) {
            // 获取当前 arr1 元素在 arr2 中的索引
            int currentIndexInTarget = indexByValue.get(arr1[i]);

            // 3. 判断当前元素与前一个元素在 arr2 中是否连续
            if (currentIndexInTarget == prevIndexInTarget + 1) {
                // 如果连续，则它们属于同一个分组，更新前一个索引
                prevIndexInTarget++;
            } else {
                // 如果不连续，则需要开启一个新的分组
                groupCount++;
                // 更新前一个索引为当前元素的索引，作为新分组的起始
                prevIndexInTarget = currentIndexInTarget;
            }
        }

        return groupCount;
    }

    /**
     * 辅助方法：将数组元素映射到其索引。
     * 
     * @param arr 要映射的数组
     * @return 元素到索引的映射
     */
    public static Map<Integer, Integer> mapIndices(int[] arr) {
        return IntStream.range(0, arr.length)
            .boxed()
            .collect(Collectors.toMap(
                i -> arr[i], // 键：数组元素
                Function.identity() // 值：元素索引
            ));
    }

    public static void main(String[] args) {
        int[] arr1 = {1, 4, 3, 2};
        int[] arr2 = {1, 2, 4, 3};
        System.out.println("原始数组: " + java.util.Arrays.toString(arr1));
        System.out.println("目标数组: " + java.util.Arrays.toString(arr2));
        System.out.println("所需的最少分组数: " + calculateMinGroups(arr1, arr2)); // 预期输出: 3

        int[] arr3 = {1, 2, 3, 4};
        int[] arr4 = {1, 2, 3, 4};
        System.out.println("\n原始数组: " + java.util.Arrays.toString(arr3));
        System.out.println("目标数组: " + java.util.Arrays.toString(arr4));
        System.out.println("所需的最少分组数: " + calculateMinGroups(arr3, arr4)); // 预期输出: 1

        int[] arr5 = {4, 3, 2, 1};
        int[] arr6 = {1, 2, 3, 4};
        System.out.println("\n原始数组: " + java.util.Arrays.toString(arr5));
        System.out.println("目标数组: " + java.util.Arrays.toString(arr6));
        System.out.println("所需的最少分组数: " + calculateMinGroups(arr5, arr6)); // 预期输出: 4
    }
}

原始数组: [1, 4, 3, 2]
目标数组: [1, 2, 4, 3]
所需的最少分组数: 3

原始数组: [1, 2, 3, 4]
目标数组: [1, 2, 3, 4]
所需的最少分组数: 1

原始数组: [4, 3, 2, 1]
目标数组: [1, 2, 3, 4]
所需的最少分组数: 4