# Minimum Array Length After Pair Removals

## Problem Statement:

We are given a 0-indexed sorted array of integers nums. We can perform the following operation any number of times: Choose two indices, i and j, where i < j, such that nums[i] < nums[j]. Now, delete the elements at indices i and j from nums. The balance of the elements retain their original order, and the array is reindexed.

It should return an integer representing the least length of nums after performing any number (including zero) operations.

### Java Approach 1 Using Two Pointers

Output:

Code Explanation:

• The minLengthAfterRemovals method aims to find the minimum length of the array after specific removals. It takes a list of integers as input. The algorithm starts from the end of the array, comparing elements with the middle. If the element at the end is greater than the middle element, it indicates a removal requirement.
• For each such case, two elements need removal. The pointers move towards the middle, and removals are counted. The final result is the total length of the array minus the removals, providing the minimum length after removals.

Time complexity:

• The time complexity of minLengthAfterRemovals is O(n), where n is the length or size of the input list. Running through the array only once, and comparing elements from end to middle gives a linear time complexity.

Space complexity:

• The Space complexity is O(1). The additional space required by the algorithm does not depend on input size. It requires only a fixed number of variables (pointers, counters) and does not rely on additional data structures that grow with the input size.

Drawbacks:

• The Above approach only considers elements from the end towards the middle, potentially needing more optimal solutions that involve removing elements from both ends simultaneously. This one-sided traversal could overlook scenarios where a more efficient outcome is achieved through alternative removal patterns.

### Java Approach 2 Using heap

Output:

Code Explanation:

• The code calculates the minimum length after removing pairs of elements with the highest frequencies. It uses a frequency map to count occurrences of each number and a max heap to maintain the frequencies in descending order. The process iterates until there is only one element left in the heap.
• In each iteration, it removes two elements with the highest frequencies, decrements their frequencies, and adds them back to the heap if their frequencies are not zero. Finally, it calculates the sum of the remaining frequencies, representing the minimum length.

Time complexity:

• The time complexity is O(N log N), where N is the number of elements in the input list. This is due to the use of a max heap, which has a logarithmic time complexity for insertion and removal.

Space Complexity:

• The space complexity is O(N), as it depends on the size of the input list and the additional space used for the frequency map and max heap. The map stores the frequency of each element, and the max heap stores the frequencies in descending order.