Skip to content

453. Minimum Moves to Equal Array Elements

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 n - 1 elements of the array by 1.

 

Example 1:

Input: nums = [1,2,3]
Output: 3
Explanation: Only three moves are needed (remember each move increments two elements):
[1,2,3]  =>  [2,3,3]  =>  [3,4,3]  =>  [4,4,4]

Example 2:

Input: nums = [1,1,1]
Output: 0

 

Constraints:

  • n == nums.length
  • 1 <= nums.length <= 105
  • -109 <= nums[i] <= 109
  • The answer is guaranteed to fit in a 32-bit integer.

Solutions

Solution 1: Mathematics

Let the minimum value of the array $\textit{nums}$ be $\textit{mi}$, the sum of the array be $\textit{s}$, and the length of the array be $\textit{n}$.

Assume the minimum number of operations is $\textit{k}$, and the final value of all elements in the array is $\textit{x}$. Then we have:

$$ \begin{aligned} \textit{s} + (\textit{n} - 1) \times \textit{k} &= \textit{n} \times \textit{x} \ \textit{x} &= \textit{mi} + \textit{k} \ \end{aligned} $$

Substituting the second equation into the first equation, we get:

$$ \begin{aligned} \textit{s} + (\textit{n} - 1) \times \textit{k} &= \textit{n} \times (\textit{mi} + \textit{k}) \ \textit{s} + (\textit{n} - 1) \times \textit{k} &= \textit{n} \times \textit{mi} + \textit{n} \times \textit{k} \ \textit{k} &= \textit{s} - \textit{n} \times \textit{mi} \ \end{aligned} $$

Therefore, the minimum number of operations is $\textit{s} - \textit{n} \times \textit{mi}$.

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

1
2
3
class Solution:
    def minMoves(self, nums: List[int]) -> int:
        return sum(nums) - min(nums) * len(nums)

1
2
3
4
5
class Solution {
    public int minMoves(int[] nums) {
        return Arrays.stream(nums).sum() - Arrays.stream(nums).min().getAsInt() * nums.length;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
class Solution {
public:
    int minMoves(vector<int>& nums) {
        int s = 0;
        int mi = 1 << 30;
        for (int x : nums) {
            s += x;
            mi = min(mi, x);
        }
        return s - mi * nums.size();
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
func minMoves(nums []int) int {
    mi := 1 << 30
    s := 0
    for _, x := range nums {
        s += x
        if x < mi {
            mi = x
        }
    }
    return s - mi*len(nums)
}

1
2
3
4
5
6
7
8
9
function minMoves(nums: number[]): number {
    let mi = 1 << 30;
    let s = 0;
    for (const x of nums) {
        s += x;
        mi = Math.min(mi, x);
    }
    return s - mi * nums.length;
}

Comments