跳转至

2541. 使数组中所有元素相等的最小操作数 II

题目描述

给你两个整数数组 nums1 和 nums2 ，两个数组长度都是 n ，再给你一个整数 k 。你可以对数组 nums1 进行以下操作：

  • 选择两个下标 i 和 j ，将 nums1[i] 增加 k ，将 nums1[j] 减少 k 。换言之，nums1[i] = nums1[i] + k 且 nums1[j] = nums1[j] - k 。

如果对于所有满足 0 <= i < n 都有 num1[i] == nums2[i] ，那么我们称 nums1 等于 nums2 。

请你返回使 nums1 等于 nums2 的 最少 操作数。如果没办法让它们相等，请你返回 -1 。

 

示例 1：

输入：nums1 = [4,3,1,4], nums2 = [1,3,7,1], k = 3
输出：2
解释：我们可以通过 2 个操作将 nums1 变成 nums2 。
第 1 个操作：i = 2 ，j = 0 。操作后得到 nums1 = [1,3,4,4] 。
第 2 个操作：i = 2 ，j = 3 。操作后得到 nums1 = [1,3,7,1] 。
无法用更少操作使两个数组相等。

示例 2：

输入：nums1 = [3,8,5,2], nums2 = [2,4,1,6], k = 1
输出：-1
解释：无法使两个数组相等。

 

提示：

  • n == nums1.length == nums2.length
  • 2 <= n <= 105
  • 0 <= nums1[i], nums2[j] <= 109
  • 0 <= k <= 105

解法

方法一：一次遍历

我们用变量 $x$ 记录加减次数的差值，用变量 $ans$ 记录操作次数。

遍历数组，对于每个位置 $i$，如果存在 $k=0$ 并且 $a_i \neq b_i$，则无法使两个数组相等，返回 $-1$。否则，如果 $k \neq 0$，则 $a_i - b_i$ 必须是 $k$ 的倍数，否则无法使两个数组相等，返回 $-1$。接下来，我们更新 $x$ 和 $ans$。

最后，如果 $x \neq 0$，则无法使两个数组相等，返回 $-1$。否则，返回 $\frac{ans}{2}$。

时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为数组长度。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
class Solution:
    def minOperations(self, nums1: List[int], nums2: List[int], k: int) -> int:
        ans = x = 0
        for a, b in zip(nums1, nums2):
            if k == 0:
                if a != b:
                    return -1
                continue
            if (a - b) % k:
                return -1
            y = (a - b) // k
            ans += abs(y)
            x += y
        return -1 if x else ans // 2

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
class Solution {
    public long minOperations(int[] nums1, int[] nums2, int k) {
        long ans = 0, x = 0;
        for (int i = 0; i < nums1.length; ++i) {
            int a = nums1[i], b = nums2[i];
            if (k == 0) {
                if (a != b) {
                    return -1;
                }
                continue;
            }
            if ((a - b) % k != 0) {
                return -1;
            }
            int y = (a - b) / k;
            ans += Math.abs(y);
            x += y;
        }
        return x == 0 ? ans / 2 : -1;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Solution {
public:
    long long minOperations(vector<int>& nums1, vector<int>& nums2, int k) {
        long long ans = 0, x = 0;
        for (int i = 0; i < nums1.size(); ++i) {
            int a = nums1[i], b = nums2[i];
            if (k == 0) {
                if (a != b) {
                    return -1;
                }
                continue;
            }
            if ((a - b) % k != 0) {
                return -1;
            }
            int y = (a - b) / k;
            ans += abs(y);
            x += y;
        }
        return x == 0 ? ans / 2 : -1;
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
func minOperations(nums1 []int, nums2 []int, k int) int64 {
    ans, x := 0, 0
    for i, a := range nums1 {
        b := nums2[i]
        if k == 0 {
            if a != b {
                return -1
            }
            continue
        }
        if (a-b)%k != 0 {
            return -1
        }
        y := (a - b) / k
        ans += abs(y)
        x += y
    }
    if x != 0 {
        return -1
    }
    return int64(ans / 2)
}

func abs(x int) int {
    if x < 0 {
        return -x
    }
    return x
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
function minOperations(nums1: number[], nums2: number[], k: number): number {
    const n = nums1.length;
    if (k === 0) {
        return nums1.every((v, i) => v === nums2[i]) ? 0 : -1;
    }
    let sum1 = 0;
    let sum2 = 0;
    for (let i = 0; i < n; i++) {
        const diff = nums1[i] - nums2[i];
        sum1 += diff;
        if (diff % k !== 0) {
            return -1;
        }
        sum2 += Math.abs(diff);
    }
    if (sum1 !== 0) {
        return -1;
    }
    return sum2 / (k * 2);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
impl Solution {
    pub fn min_operations(nums1: Vec<i32>, nums2: Vec<i32>, k: i32) -> i64 {
        let k = k as i64;
        let n = nums1.len();
        if k == 0 {
            return if nums1.iter().enumerate().all(|(i, &v)| v == nums2[i]) {
                0
            } else {
                -1
            };
        }
        let mut sum1 = 0;
        let mut sum2 = 0;
        for i in 0..n {
            let diff = (nums1[i] - nums2[i]) as i64;
            sum1 += diff;
            if diff % k != 0 {
                return -1;
            }
            sum2 += diff.abs();
        }
        if sum1 != 0 {
            return -1;
        }
        sum2 / (k * 2)
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
long long minOperations(int* nums1, int nums1Size, int* nums2, int nums2Size, int k) {
    if (k == 0) {
        for (int i = 0; i < nums1Size; i++) {
            if (nums1[i] != nums2[i]) {
                return -1;
            }
        }
        return 0;
    }
    long long sum1 = 0;
    long long sum2 = 0;
    for (int i = 0; i < nums1Size; i++) {
        long long diff = nums1[i] - nums2[i];
        sum1 += diff;
        if (diff % k != 0) {
            return -1;
        }
        sum2 += llabs(diff);
    }
    if (sum1 != 0) {
        return -1;
    }
    return sum2 / (k * 2);
}

评论