Skip to content

462. Minimum Moves to Equal Array Elements II

Description

Given an integer array nums of size n, return the minimum number of moves required to make all array elements equal.

In one move, you can increment or decrement an element of the array by 1.

Test cases are designed so that the answer will fit in a 32-bit integer.

 

Example 1:

Input: nums = [1,2,3]
Output: 2
Explanation:
Only two moves are needed (remember each move increments or decrements one element):
[1,2,3]  =>  [2,2,3]  =>  [2,2,2]

Example 2:

Input: nums = [1,10,2,9]
Output: 16

 

Constraints:

  • n == nums.length
  • 1 <= nums.length <= 105
  • -109 <= nums[i] <= 109

Solutions

Solution 1: Sorting + Median

This problem can be abstracted to finding a point on a number line such that the sum of distances from $n$ points to this point is minimized. The answer is the median of the $n$ points.

The median has the property that the sum of distances from all numbers to the median is minimized.

Proof:

First, given a sorted sequence $a_1, a_2, \cdots, a_n$, we assume $x$ is the point that minimizes the sum of distances from $a_1$ to $a_n$. Clearly, $x$ must lie between $a_1$ and $a_n$. Since the distances from $a_1$ and $a_n$ to $x$ are equal and both equal to $a_n - a_1$, we can ignore $a_1$ and $a_n$ and only consider $a_2, a_3, \cdots, a_{n-1}$. This reduces the problem to finding a point within $a_2, a_3, \cdots, a_{n-1}$ that minimizes the sum of distances. By iterating this process, we conclude that the median of a sequence minimizes the sum of distances to the other numbers.

In this problem, we can first sort the array, then find the median, and finally calculate the sum of distances from all numbers to the median.

The time complexity is $O(n \log n)$, and the space complexity is $O(\log n)$.

Similar problems:

1
2
3
4
5
class Solution:
    def minMoves2(self, nums: List[int]) -> int:
        nums.sort()
        k = nums[len(nums) >> 1]
        return sum(abs(v - k) for v in nums)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
class Solution {
    public int minMoves2(int[] nums) {
        Arrays.sort(nums);
        int k = nums[nums.length >> 1];
        int ans = 0;
        for (int v : nums) {
            ans += Math.abs(v - k);
        }
        return ans;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
class Solution {
public:
    int minMoves2(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        int k = nums[nums.size() >> 1];
        int ans = 0;
        for (int& v : nums) {
            ans += abs(v - k);
        }
        return ans;
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
func minMoves2(nums []int) int {
    sort.Ints(nums)
    k := nums[len(nums)>>1]
    ans := 0
    for _, v := range nums {
        ans += abs(v - k)
    }
    return ans
}

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

1
2
3
4
5
function minMoves2(nums: number[]): number {
    nums.sort((a, b) => a - b);
    const k = nums[nums.length >> 1];
    return nums.reduce((r, v) => r + Math.abs(v - k), 0);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
impl Solution {
    pub fn min_moves2(mut nums: Vec<i32>) -> i32 {
        nums.sort();
        let k = nums[nums.len() / 2];
        let mut ans = 0;
        for num in nums.iter() {
            ans += (num - k).abs();
        }
        ans
    }
}

Comments