You are given an integer array nums.

A tuple (i, j, k) of 3 distinct indices is called good if the values at those positions are all equal, meaning nums[i] == nums[j] == nums[k].

For any good tuple, its distance is defined as abs(i - j) + abs(j - k) + abs(k - i), where abs(x) represents the absolute value of x.

Your task is to find and return the minimum possible distance among all good tuples. If no good tuple exists in the array, return -1.

To understand the distance formula better, suppose we sort the three indices so that i < j < k. Then the distance simplifies to (j - i) + (k - j) + (k - i) = 2 * (k - i). This tells us the distance depends only on the gap between the smallest and largest index in the tuple. Therefore, to minimize the distance for a given value, we want to pick three indices (sharing the same value) that are as close together as possible.

For example, if a value appears at sorted positions [1, 3, 5, 8], the closest grouping of three consecutive positions would be [1, 3, 5] or [3, 5, 8], and we compute 2 * (k - i) for each window of three consecutive indices to find the smallest result.

The key observation comes from simplifying the distance formula. A good tuple requires all three values to be equal, so naturally we should group indices by their values first. Only values that appear at least three times can possibly form a good tuple.

Next, let's simplify the distance expression. For any three distinct indices, suppose we arrange them in increasing order as i < j < k. Then:

• abs(i - j) = j - i
• abs(j - k) = k - j
• abs(k - i) = k - i

Adding these together gives (j - i) + (k - j) + (k - i) = 2 * (k - i). The middle index j cancels out completely! This means the distance depends only on the smallest index i and the largest index k, and not at all on the middle one.

Since the distance is just 2 * (k - i), minimizing it means making the gap between the largest and smallest chosen index as small as possible. For a fixed value, we already have its indices stored in sorted order (because we collected them while traversing the array left to right). To make k - i as small as possible while still picking three indices, we should choose three consecutive indices from this sorted list.

Why consecutive? If we picked the smallest index i and the largest index k from a list, the gap k - i is fixed by that pair. To keep this gap minimal, both endpoints should be as close as possible, which happens when we slide a window of size three across the sorted list. For each window, the first and third elements give us the smallest possible k - i for that particular triple.

So the strategy becomes clear: for every value, scan through its sorted index list using a sliding window of three consecutive indices, compute 2 * (ls[h + 2] - ls[h]) for each window, and track the overall minimum. If no value has three or more indices, no good tuple exists, and we return -1.

Solution 1: Hash Table

We use a hash table g to store the list of indices for each number in the array. While traversing the array, we add each number's index to its corresponding list in the hash table. Define a variable ans to store the answer, with an initial value of infinity inf.

Step 1: Build the hash table.

We iterate through nums using enumerate to access both the index i and the value x. For each value, we append its index to the list g[x]. Because we traverse from left to right, each value's index list is automatically kept in sorted (increasing) order, which is essential for the next step.

g = defaultdict(list)
for i, x in enumerate(nums):
    g[x].append(i)

Step 2: Scan each index list with a sliding window.

Next, we iterate through each index list in the hash table. If the length of an index list for a particular number is greater than or equal to 3, it means there exists a valid triplet. To minimize the distance, we choose three consecutive indices from that number's index list.

For a sorted list ls, we slide a window of size three by letting h range from 0 to len(ls) - 3. Within each window, the smallest index is i = ls[h] and the largest is k = ls[h + 2]. The middle index does not matter because the distance simplifies to 2 * (k - i). We compute this distance and update ans with the minimum.

for ls in g.values():
    for h in range(len(ls) - 2):
        i, k = ls[h], ls[h + 2]
        ans = min(ans, (k - i) * 2)

Note that range(len(ls) - 2) naturally handles lists with fewer than three elements: when len(ls) < 3, the range is empty and the inner loop simply does not execute.

Step 3: Return the result.

Finally, if the answer is still the initial value inf, it means no valid triplet exists, so we return -1; otherwise, we return the calculated minimum distance.

return -1 if ans == inf else ans

Complexity Analysis:

• Time complexity: O(n), where n is the length of the array nums. Building the hash table takes O(n) time, and the total work across all index lists in the sliding-window scan is also O(n), since the combined length of all lists equals n.
• Space complexity: O(n), due to the hash table storing every index exactly once.