Find the number of Dominant Pairs

Given an even-sized arrayarr[] of length n. A dominant pair (i, j) is defined as:

• i belongs to the first half of the array, (0 <= i < n/2)
• j belongs to the second half of the array, (n/2 <= j < n)
• The value at index i is at least five times the value at index j, (arr[i] >= 5 * arr[j])

The task is to find the count of total number of dominant pairs in the array.

Examples:

Input: arr[] = [10, 2, 2, 1]
Output: 2
Explanation: First half: [10, 2], Second half: [2, 1]. So valid pairs are:

• {0, 2}: 10 >= 5 × 2
• {0, 3}: 10 >= 5 × 1

So, total dominant pairs = 2.

Input: arr[] = [10, 8, 2, 1, 1, 2]
Output: 5
Explanation: First half: [10, 8, 2], Second half: [1, 1, 2]. So valid pairs are:

• {0, 3}: 10 >= 5 × 1
• {0, 4}: 10 >= 5 × 1
• {0, 5}: 10 >= 5 × 2
• {1, 3}: 8 >= 5 × 1
• {1, 4}: 8 >= 5 × 1

So, total dominant pairs = 5.

[Brute-Force Approach] Using 2 Nested Loops - O(n²) Time and O(1) Space

The idea is to count dominant pairs by checking all possible (i, j) pairs where i belongs to the first half and j belongs to the second half of the array. The brute-force approach uses two nested loops to compare each element from the first half with every element from the second half, ensuring the dominance condition (arr[i] >=5 * arr[j]) holds.

2

Time Complexity: O(n²), due to two nested loops iterating.
Space Complexity: O(1), as only a few extra variables are used.

[Expected Approach] Using Sorting + Two Pointers - O(n*log(n)) Time and O(1) Space

The idea is to efficiently count dominant pairs by leveraging sorting and the two-pointer technique. Instead of using nested loops, we sort the first half and second half separately to maintain order. Using a two-pointer approach, we iterate through the first half and move the right pointer in the second half until the dominance condition is violated. This ensures that for every valid left index, all valid right indices are counted efficiently.

Steps to implement the above idea:

• Sort the first half of the array in ascending order and the second half of the array in ascending order to allow efficient comparison using a two-pointer approach.
• Initialize a count variable to store the number of dominant pairs and set a right pointer at the start of the second half.
• Iterate through the first half of the array using a left pointer to find valid dominant pairs efficiently.
• Move the right pointer forward while the dominance condition (arr[left] >= 5 * arr[right]) holds true.
• Update the count variable by adding the number of valid elements in the second half that satisfy the condition.
• Return the final count, which represents the total number of dominant pairs found in the given array.

Below is the implementation of the above approach:

2

Time Complexity:O(n*log(n)), as sorting takes O(n log n), and two-pointer traversal takes O(n).
Space Complexity:O(1), as sorting is done in-place, and only a few extra variables are used.