Question

2541. Minimum Operations to Make Array Equal II

中文文档

Description

You are given two integer arrays nums1 and nums2 of equal length n and an integer k. You can perform the following operation on nums1:

• Choose two indexes i and j and increment nums1[i] by k and decrement nums1[j] by k. In other words, nums1[i] = nums1[i] + k and nums1[j] = nums1[j] - k.

nums1 is said to be equal to nums2 if for all indices i such that 0 <= i < n, nums1[i] == nums2[i].

Return _the minimum number of operations required to make _nums1_ equal to _nums2. If it is impossible to make them equal, return -1.

 

Example 1:

Input: nums1 = [4,3,1,4], nums2 = [1,3,7,1], k = 3
Output: 2
Explanation: In 2 operations, we can transform nums1 to nums2.
1st operation: i = 2, j = 0. After applying the operation, nums1 = [1,3,4,4].
2nd operation: i = 2, j = 3. After applying the operation, nums1 = [1,3,7,1].
One can prove that it is impossible to make arrays equal in fewer operations.

Example 2:

Input: nums1 = [3,8,5,2], nums2 = [2,4,1,6], k = 1
Output: -1
Explanation: It can be proved that it is impossible to make the two arrays equal.

 

Constraints:

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

Solutions

Solution 1: Single Pass

We use a variable $x$ to record the difference in the number of additions and subtractions, and a variable $ans$ to record the number of operations.

We traverse the array, and for each position $i$, if $k=0$ and $a_i \neq b_i$, then it is impossible to make the two arrays equal, so we return $-1$. Otherwise, if $k \neq 0$, then $a_i - b_i$ must be a multiple of $k$, otherwise it is impossible to make the two arrays equal, so we return $-1$. Next, we update $x$ and $ans$.

Finally, if $x \neq 0$, then it is impossible to make the two arrays equal, so we return $-1$. Otherwise, we return $\frac{ans}{2}$.

The time complexity is $O(n)$, and the space complexity is $O(1)$, where $n$ is the length of the array.

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

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;
  }
}

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;
  }
};

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
}

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);
}

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)
  }
}

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);
}