You are given two integer arrays nums1 and nums2, both of the same length n.

A pair of indices (i, j) is called a good pair if the value at index i in the first array equals the value at index j in the second array, i.e., nums1[i] == nums2[j].

Your task is to find the smallest possible index sum i + j among all good pairs.

• If at least one good pair exists, return the minimum value of i + j.
• If the two arrays share no common values at all (meaning no good pair can be formed), return -1.

Example:

Suppose nums1 = [1, 2, 3] and nums2 = [2, 4, 1].

• The value 1 appears at index 0 in nums1 and index 2 in nums2, giving a good pair (0, 2) with sum 0 + 2 = 2.
• The value 2 appears at index 1 in nums1 and index 0 in nums2, giving a good pair (1, 0) with sum 1 + 0 = 1.

The minimum index sum among all good pairs is 1, so the answer is 1.

The key challenge is to do this efficiently: rather than checking every possible (i, j) combination (which would take O(n^2) time), you can record the earliest occurrence of each value in nums2 using a hash map, then scan nums1 once to compute the best answer in O(n) time.

The brute-force approach would be to check every pair (i, j), compare nums1[i] with nums2[j], and track the smallest i + j. That works, but it costs O(n^2) time. The natural question is: where is the wasted work?

The key observation is this: for any value x that appears in both arrays, the only occurrence of x in nums2 that ever matters is its first (smallest-index) occurrence. If x appears at indices j1 < j2 in nums2, then for any i in nums1, the pair (i, j1) always gives a smaller sum than (i, j2). So all later occurrences of x in nums2 can be safely ignored.

This insight immediately suggests a preprocessing step: walk through nums2 once and record, in a hash map d, the earliest index of each distinct value. Since we iterate from left to right, we simply skip a value if it's already in the map — the first index we stored is guaranteed to be the smallest.

Once that map exists, the problem collapses into a single pass over nums1. For each element nums1[i], a lookup tells us in O(1) whether the value exists in nums2, and if so, the best possible partner index d[nums1[i]]. The candidate sum is i + d[nums1[i]], and we keep the minimum across all i.

By symmetry, the same argument applies to nums1: only the first occurrence of each value in nums1 could ever produce the minimum, but since we take min over all candidates anyway, scanning every element of nums1 handles this automatically without extra logic.

Finally, initializing the answer to inf gives a clean way to detect the "no good pair" case — if it never gets updated, no common value exists, and we return -1. The result is an O(n) time, O(n) space solution that trades a hash map for the quadratic comparison loop.

The solution uses a hash map to eliminate the nested loop and achieve linear time. The implementation breaks down into three clear steps.

Step 1: Build the hash map from nums2.

d = {}
for i, x in enumerate(nums2):
    if x not in d:
        d[x] = i

We iterate through nums2 and store each value x as a key, mapped to its index i. The guard if x not in d ensures that only the first occurrence of each value is recorded. Because the traversal goes left to right, the stored index is automatically the smallest one for that value — which is the only index that could ever contribute to a minimum sum.

Step 2: Scan nums1 and compute candidate sums.

ans = inf
for i, x in enumerate(nums1):
    if x in d:
        ans = min(ans, i + d[x])

We initialize ans to infinity as a sentinel meaning "no good pair found yet." Then, for each element x = nums1[i]:

• We check in O(1) whether x exists in the map d.
• If it does, (i, d[x]) is a good pair, and d[x] is the best possible partner index in nums2 for this value. The candidate index sum is i + d[x].
• We update ans with min(ans, i + d[x]), so after the loop finishes, ans holds the smallest sum across all good pairs.

Note that we don't need to deduplicate values in nums1: if a value repeats, its later occurrences produce strictly larger sums, and the min operation discards them naturally.

Step 3: Handle the no-pair case.

return -1 if ans == inf else ans

If ans was never updated, the two arrays share no common element, so we return -1. Otherwise, we return the computed minimum.

Complexity Analysis

• Time complexity: O(n) — one pass over nums2 to build the map and one pass over nums1 to query it, with each hash map operation taking O(1) on average.
• Space complexity: O(n) — in the worst case, every element of nums2 is distinct and the map stores n entries.

Alternative perspective: the roles of the two arrays are symmetric. One could equally build the map from nums1 and iterate over nums2; correctness and complexity are identical. A brute-force double loop comparing all (i, j) pairs would also work but would run in O(n^2), which the hash map approach improves upon decisively.