Minimum Moves To Make Array Complementary - Leetcode Solution

Problem Statement:

You are given an integer array nums of even length (i.e., n % 2 == 0). Pair up the elements of the array into n / 2 pairs such that: Each element of nums is in exactly one pair, and The sum of the elements in each pair is equal. Return the minimum number of moves to make every pair of elements complementary. A pair of elements (a, b) is complementary if a + b == target. The value of target is the sum of the elements in nums divided by n / 2.

Solution:

To solve this problem, we need to first understand what a complementary pair is. A complementary pair is a pair of elements that add up to a certain target value. In this problem, the target value is the sum of all the elements in the array divided by n/2.

The idea behind this solution is that if we know the sum of each pair, we can calculate what the second element of the pair should be in order for it to be a complementary pair. If we know this, we can then iterate through the array, counting the number of moves needed to make each pair complementary.

First, we create a frequency table of all the sums of each pair using a HashMap. We iterate through the array, and for each pair, we calculate the sum of the pair and record it in the HashMap. If the sum already exists in the HashMap, we increment its frequency by 1. Once we have the frequency table, we can determine the second element of the pair that would make it complementary by subtracting the sum from the target value.

Next, we iterate through the array again, and for each pair, we calculate the target value by subtracting the sum of the pair from the sum of all the elements in the array. We then check if the complement of the first element is present in our frequency table, and if it is, we decrement its frequency by 1. If the frequency becomes 0, we remove the sum from the HashMap. We do this for all pairs, and count the number of moves required to make each pair complementary. We return the total number of moves required.

Time Complexity:

The time complexity of this solution is O(n), where n is the length of the array. We iterate through the array twice, once to create the frequency table, and once to count the number of moves required.

Space Complexity:

The space complexity of this solution is O(n/2), which is the maximum possible size of the frequency table.

Code:

public int minMoves(int[] nums) { int n = nums.length; int target = 0; Map<Integer, Integer> freq = new HashMap<>(); int moves = 0;

// Calculate the sum of all the elements in the array and the target value
for (int num : nums) {
    target += num;
}
target /= n/2;

// Create a frequency table of all the sums of each pair
for (int i = 0; i < n/2; i++) {
    int sum = nums[i] + nums[n-1-i];
    if (freq.containsKey(sum)) {
        freq.put(sum, freq.get(sum)+1);
    } else {
        freq.put(sum, 1);
    }
}

// Count the number of moves required to make each pair complementary
for (int i = 0; i < n/2; i++) {
    int sum = nums[i] + nums[n-1-i];
    int complement = target - sum;
    if (freq.containsKey(complement)) {
        int freqCount = freq.get(complement);
        if (complement == sum) {
            if (freqCount >= 2) {
                freq.put(complement, freqCount-2);
            } else {
                freq.remove(complement);
            }
        } else {
            if (freqCount >= 1) {
                freq.put(complement, freqCount-1);
            } else {
                freq.remove(complement);
            }
        }
    }
}

// Calculate the total number of moves required
for (Integer value : freq.values()) {
    moves += value;
}

return moves;

}

1