Minimum Operations to Make Array Equal II — Editorial

Opening the reading…

Intuitionturning every position into units of one operation

Look at one position and compute diff = nums1[i] - nums2[i]. If diff is positive, that position has diff extra value and must give away diff units. If diff is negative, it needs -diff units. One operation transfers exactly k units from one position to another, so every required change must be divisible by k.

After converting each difference into operations, add the requirements on both sides. The total number of units that must be removed must equal the total number that must be added; otherwise no sequence of transfers can finish the job. When the two totals match, each operation can pair one required decrement with one required increment, so the number of operations is exactly that common total.

Approachone scan, with feasibility checks before counting

Keep pos and neg as the number of k-sized transfers that positions need to give and receive, because each operation pairs one transfer from each total.

Scan every corresponding pair and compute nums1[i] - nums2[i], because the operation changes values at fixed indices and does not rearrange the arrays.

Skip a zero difference, because an already equal position needs no transfer and contributes to neither side.

If k is zero and a difference is nonzero, return -1 immediately, because every operation would change nothing; if all differences are zero, the answer remains zero.

For nonzero k, reject any difference that is not divisible by k, because repeated changes by k can never reach the target value exactly.

Add diff / k to pos when diff is positive, or add (-diff) / k to neg when diff is negative, so both counters measure the same unit: one operation's worth of value.

After the scan, return pos when pos equals neg; otherwise return -1, because unmatched required increments or decrements cannot be supplied by any operation.

Complexitythe input is read once and no working collection is needed

MEASURE	BOUND	WHY
Time	O(n)	The scan processes each corresponding pair once, performing only constant-time arithmetic and checks per index, so no element is revisited or compared with every other element.
Space	O(1) extra	Only the counters and one difference are stored. The returned number is a scalar output, not working memory, and this bound does not degrade for any input shape.

Here, n is the common length of nums1 and nums2.

Annotated solutionC++ · one pass · constant extra space

CPPCount transferable k-sized units on both sides and return the balanced total.

#include <vector>
using namespace std;

class Solution {
public:
    long long minOperations(vector<int>& nums1, vector<int>& nums2, int k) {
        long long pos = 0;
        long long neg = 0;

        for (int i = 0; i < static_cast<int>(nums1.size()); ++i) {
            int diff = nums1[i] - nums2[i];

            if (diff == 0) {
                continue;
            }

            if (k == 0 || diff % k != 0) {
                return -1;
            }

            if (diff > 0) {
                pos += diff / k;
            } else {
                neg += (-diff) / k;
            }
        }

        if (pos != neg) {
            return -1;
        }

        return pos;
    }
};

The two counters are deliberately long long. A single difference fits in an int, but the sum of up to n differences divided by k can be much larger than a 32-bit signed integer. The final equality check is the conservation rule: every unit removed from one index must be added to another, so equal totals are both necessary and sufficient.