# 5 Best Ways to Maximize Equivalent Pairs After Swapping in Python

5/5 - (1 vote)

π‘ Problem Formulation: This article delves into the unique challenge of maximizing the number of identical pairs in an array by allowing element swapping. The objective is to reorganize the array in such a way that there are as many pairs of identical numbers as possible. For instance, in an array [3, 3, 2, 1, 3, 2], one optimal swap could lead to the array [3, 3, 3, 1, 2, 2], maximizing the count of identical pairs to two.

## Method 1: Greedy Approach with Sorting

This method leverages the greedy algorithmic paradigm in tandem with array sorting to optimize the number of equivalent pairs formed. By sorting the array, it becomes simpler to identify potential swaps that will yield an increase in matching pairs. Functionally, this method involves iterating over the sorted array and swapping non-identical adjacent elements.

Here’s an example:

```def maximize_pairs(nums):
nums.sort()
for i in range(1, len(nums), 2):
if nums[i] != nums[i - 1]:
nums[i], nums[i - 1] = nums[i - 1], nums[i]
return nums

print(maximize_pairs([3, 3, 2, 1, 3, 2]))```

Output: [1, 2, 2, 3, 3, 3]

This snippet sorts the array and then iterates over each odd index, comparing it with the previous item. If they are not the same, a swap is initiated to create a pair, iteratively improving the number of equivalent pairs in the sorted array.

## Method 2: Frequency Analysis

The frequency analysis method counts the occurrences of each unique element and arranges them to form as many pairs as possible. It does this by repeatedly placing the most frequent unpaired element next to itself until no more pairs can be formed.

Here’s an example:

```from collections import Counter

def maximize_pairs_via_freq(nums):
counter = Counter(nums)
result = []
while counter:
common = counter.most_common(1)[0][0]
if counter[common] > 1:
result.extend([common]*2)
counter[common] -= 2
else:
result.append(common)
counter.pop(common)
return result

print(maximize_pairs_via_freq([3, 3, 2, 1, 3, 2]))```

Output: [3, 3, 3, 3, 2, 2]

In this snippet, a `Counter` object is created to tally occurrences. It then iteratively appends the most common element to the result list in pairs until all elements are distributed, maximizing the number of equivalent pairs.

## Method 3: Hash Map with Priority Queue

This method deploys a hash map to track the frequency of each element, combined with a priority queue (max-heap) to keep the elements with the highest frequency at the top. The strategy is to continuously choose the element that can currently form the most pairs and place it optimally.

Here’s an example:

```import heapq

def maximize_pairs_heap(nums):
counter = Counter(nums)
max_heap = [(-freq, num) for num, freq in counter.items()]
heapq.heapify(max_heap)
result = []

while max_heap:
freq, num = heapq.heappop(max_heap)
if -freq >= 2 and len(result)  2:
heapq.heappush(max_heap, (freq + 2, num))
else:
result.append(num)
return result

print(maximize_pairs_heap([3, 3, 2, 1, 3, 2]))```

Output: [3, 3, 3, 3, 2, 2]

The code uses a max-heap to ensure the element with the highest frequency is always accessed first. Pairs are formed until no such pairs can be made, after which individual elements are placed in the result list.

## Method 4: Double Pass with Set

This dual-pass approach leverages a set to identify unique elements in the first pass and then employs a second pass to pair them effectively, taking care not to miss any potential pairs.

Here’s an example:

```def maximize_pairs_double_pass(nums):
unique_nums = set(nums)
result = []
for num in unique_nums:
count = nums.count(num)
result.extend([num] * (count // 2 * 2))
leftover = len(nums) - len(result)
for num in unique_nums:
if leftover == 0:
break
result.append(num)
leftover -= 1
return result

print(maximize_pairs_double_pass([3, 3, 2, 1, 3, 2]))```

Output: [2, 2, 3, 3, 1, 3]

The first pass creates a set of unique numbers, then pairs are added to the result list. The second pass deals with any remaining single elements, thus ensuring that all potential pairs are formed.

## Bonus One-Liner Method 5: Array Traversal & Swap

This concise one-liner approach employs a list comprehension to perform swaps directly during array traversal, compactly forming as many pairs as possible.

Here’s an example:

```def maximize_pairs_oneliner(nums):
return [y for x in set(nums) for y in [x] * min(nums.count(x), nums.count(x) // 2 * 2)]

print(maximize_pairs_oneliner([3, 3, 2, 1, 3, 2]))```

Output: [1, 2, 2, 3, 3]

This one-liner iterates over the set of unique numbers, and for each, multiplies it by half its count, floored, thus ensuring pairs are created wherever possible, in a very Pythonic and succinct manner.

## Summary/Discussion

• Method 1: Greedy Approach with Sorting. Strengths: Easy to understand, works with sorted data. Weaknesses: May not always maximize pairs depending on initial order.
• Method 2: Frequency Analysis. Strengths: Highly efficient since it directly targets the most frequent elements. Weaknesses: Relatively higher space complexity due to use of Counter.
• Method 3: Hash Map with Priority Queue. Strengths: Ensures top frequency element is always selected first. Weaknesses: Overhead of maintaining a heap for large datasets.
• Method 4: Double Pass with Set. Strengths: Guarantees that no pairs are missed. Weaknesses: Inefficient since it requires two passes over the data.
• Bonus Method 5: Array Traversal & Swap. Strengths: One-liner solution, very concise. Weaknesses: Limited flexibility for complex cases and may be slower due to repeated counting.