最小移动次数使数组相等|豆包MarsCodeAI刷题

解题思路

1. 理解问题：

   • 我们需要将数组 A 转换为数组 B。

   • 允许的操作包括：

     1. 反转数组 A。
     2. 调整数组 A 中的任意元素值。

2. 数据结构选择：

   • 使用数组来存储和操作数据。

3. 算法步骤：

   • 步骤1：计算不反转数组 A 时的调整次数。
   • 步骤2：反转数组 A，然后计算反转后的调整次数。
   • 步骤3：比较两种情况下的调整次数，选择最小值。
   • 步骤4：如果反转数组 A 后进行了调整，则总操作次数为反转操作次数（1次）加上调整次数。

具体实现步骤

1. 计算调整次数：

   • 遍历数组 A 和 B，统计 A[i] 和 B[i] 不相等的元素个数。

2. 反转数组：

   • 使用双指针法反转数组 A。

3. 比较调整次数：

   • 比较不反转时的调整次数和反转后的调整次数，选择最小值。

import java.util.Arrays;

public class Main {
    public static int solution(int N, int[] A, int[] B) {
        // 反转数组 A
        int[] reversedA = reverseArray(A);
        
        // 计算不反转时的调整次数
        int nonReversedCount = calculateAdjustmentCount(A, B);
        
        // 计算反转后的调整次数
        int reversedCount = calculateAdjustmentCount(reversedA, B);
        
        // 返回最小操作次数
        return Math.min(nonReversedCount, reversedCount + 1); // +1 表示反转操作
    }

    // 反转数组
    private static int[] reverseArray(int[] array) {
        int[] reversed = Arrays.copyOf(array, array.length);
        int left = 0, right = array.length - 1;
        while (left < right) {
            int temp = reversed[left];
            reversed[left] = reversed[right];
            reversed[right] = temp;
            left++;
            right--;
        }
        return reversed; // 返回反转后的数组
    }

    // 计算调整次数
    private static int calculateAdjustmentCount(int[] A, int[] B) {
        int count = 0;
        for (int i = 0; i < A.length; i++) {
            if (A[i] != B[i]) {
                count++;
            }
        }
        return count; // 返回调整次数
    }

    public static void main(String[] args) {
        System.out.println(solution(3, new int[]{1, 2, 5}, new int[]{4, 2, 1}) == 2);
        System.out.println(solution(4, new int[]{7, 8, 6, 2}, new int[]{6, 2, 8, 7}) == 3);
        System.out.println(solution(2, new int[]{3, 9}, new int[]{9, 3}) == 1);
    }
}
### 关键点

-   **反转数组**：使用双指针法反转数组 `A`。
-   **计算调整次数**：遍历数组 `A` 和 `B`，统计不相等的元素个数。
-   **比较调整次数**：选择不反转和反转后的最小调整次数，并考虑反转操作的次数。

通过以上步骤，我们可以有效地计算出将数组 `A` 转换为数组 `B` 所需的最小操作次数。