将给定数组转换为目标数组所需的最少分组数

import java.util.Arrays;
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 process(int[] arr1, int[] arr2) {
        // 步骤 1: 建立目标数组的索引映射
        // key: 元素值, value: 该元素在 arr2 中的索引
        Map<Integer, Integer> indexByValue = mapIndices(arr2);

        // 步骤 2: 遍历源数组并计数
        // 至少有一个分组，即 arr1 的第一个元素
        int count = 1; 

        // 获取 arr1 第一个元素在 arr2 中的目标索引
        int prevIndex = indexByValue.get(arr1[0]);

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

            // 检查当前元素是否与前一个元素在 arr2 中保持连续顺序
            if (nextIndex == prevIndex + 1) {
                // 如果连续，更新 prevIndex，继续当前分组
                prevIndex++;
            } else {
                // 如果不连续，说明需要开始一个新的分组
                prevIndex = nextIndex; // 新分组的起始索引
                count++;               // 分组数加一
            }
        }

        return count;
    }

    /**
     * 辅助方法：将数组元素映射到其索引。
     *
     * @param arr 要映射的数组
     * @return 元素值到其索引的映射
     */
    public static Map<Integer, Integer> mapIndices(int[] arr) {
        return IntStream.range(0, arr.length) // 生成从 0 到 arr.length-1 的整数流
            .boxed() // 将 int 转换为 Integer 对象流
            .collect(Collectors.toMap( // 收集到 Map 中
                i -> arr[i], // key 是数组元素的值
                Function.identity() // value 是该元素的索引 i
            ));
    }

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

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

        int[] arr5 = {4, 3, 2, 1};
        int[] arr6 = {1, 2, 3, 4};
        System.out.println("源数组: " + Arrays.toString(arr5));
        System.out.println("目标数组: " + Arrays.toString(arr6));
        System.out.println("所需的最少分组数: " + process(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