算法说明

这个问题的核心是在环形数组中为多个查询高效地找到具有相同值的最近元素的距离。一个高效的解法是结合哈希表预处理和二分查找。

1. 预处理：我们首先遍历一次 nums 数组，使用一个哈希表 pos 来存储每个数字出现的所有下标。pos 的键是 nums 中的数字，值是该数字出现的所有下标组成的列表。由于我们是按顺序遍历 nums 的，所以每个下标列表自然就是有序的。

   // 例如: nums = [1,3,1,4,1,3,2]
   // pos = {
   //   1: [0, 2, 4],
   //   3: [1, 5],
   //   4: [3],
   //   2: [6]
   // }

2. 处理查询：遍历 queries 中的每一个查询下标 q。

   • 获取该下标对应的值 val = nums[q]。
   • 从哈希表 pos 中取出 val 对应的所有下标列表 indices。
   • 如果 indices 的长度小于等于 1，意味着 val 在 nums 中只出现了一次或零次，不存在“其他”相同元素，因此当前查询结果为 -1。

3. 定位与查找：

   • 在有序的 indices 列表中，使用二分查找（sort.SearchInts）来定位 q 自身的位置。假设 q 在 indices 中的下标为 p。
   • q 的最近邻居只可能是在 indices 列表中与它相邻的两个元素：indices[p-1] (前驱) 和 indices[p+1] (后继)。
   • 因为 indices 列表本身也代表了一个环（第一个元素是最后一个元素的后继），所以我们可以通过取模运算 (p-1+len)%len 和 (p+1)%len 来轻松找到环形邻居。

4. 计算最短距离：

   • 对于 q 和它的两个邻居（prevNeighbor, nextNeighbor），我们需要计算它们之间的环形距离。
   • 在一个长度为 n 的环中，两个下标 i 和 j 之间的距离是 min(|i-j|, n - |i-j|)。这代表了顺时针和逆时针两个方向中较短的路径。
   • 我们分别计算 q 到 prevNeighbor 和 q 到 nextNeighbor 的环形距离，然后取这两者中更小的一个，即为最终答案。

通过这种“预处理+查询”的模式，我们可以高效地响应每一个查询，而不需要每次都重新遍历整个 nums 数组。

示例 1 演练 (query = 5)

• 输入: nums = [1,3,1,4,1,3,2], queries = [0,3,5], n=7。
• 预处理: pos[3] = [1, 5]。
• 查询: q = 5，对应的值是 nums[5] = 3。
• 定位: indices = [1, 5]。q=5 在 indices 中的位置 p=1。
• 找邻居:
  • 前驱: indices[(1-1+2)%2] = indices[0] = 1。
  • 后继: indices[(1+1)%2] = indices[0] = 1。
  • 两个邻居都是 1。
• 算距离:
  • 计算 q=5 和邻居 1 之间的距离。
  • 直接距离: |5 - 1| = 4。
  • 环形绕路距离: n - |5 - 1| = 7 - 4 = 3。
  • 最短距离为 min(4, 3) = 3。
• 结果: query=5 的答案是 3。

🚀 完整可运行代码（Go）

复制以下代码到本地或在线 Go 环境中，直接运行即可验证结果。

package main

import (
	"fmt"
	"reflect"
	"sort"
)

func main() {
	// 测试用例
	testCases := []struct {
		nums     []int
		queries  []int
		expected []int
	}{
		{
			[]int{1, 3, 1, 4, 1, 3, 2},
			[]int{0, 3, 5},
			[]int{2, -1, 3},
		},
		{
			[]int{1, 2, 3, 4},
			[]int{0, 1, 2, 3},
			[]int{-1, -1, -1, -1},
		},
	}

	for i, tc := range testCases {
		result := solveQueries(tc.nums, tc.queries)
		fmt.Printf("测试用例 %d: 期望输出 = %v, 实际输出 = %v, 通过 = %t
", i+1, tc.expected, result, reflect.DeepEqual(result, tc.expected))
	}
}

func solveQueries(nums []int, queries []int) []int {
	n := len(nums)
	pos := make(map[int][]int)
	for i, x := range nums {
		pos[x] = append(pos[x], i)
	}

	ans := make([]int, len(queries))
	for i, q := range queries {
		x := nums[q]
		indices := pos[x]
		if len(indices) <= 1 {
			ans[i] = -1
			continue
		}

		p := sort.SearchInts(indices, q)
		
		prevNeighbor := indices[(p-1+len(indices))%len(indices)]
		distPrev := abs(q - prevNeighbor)

		nextNeighbor := indices[(p+1)%len(indices)]
		distNext := abs(q - nextNeighbor)

		minDist := min(min(distPrev, n - distPrev), min(distNext, n - distNext))
		ans[i] = minDist
	}
	return ans
}

func abs(x int) int {
	if x < 0 {
		return -x
	}
	return x
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}