每日一道leetcode（2026.04.11）：三个相等元素之间的最小距离 II

[1. 题目](#1. 题目)
[2. 分析](#2. 分析)
[3. 代码实现](#3. 代码实现)

1. 题目

给你一个整数数组 nums。

如果满足 nums[i] == nums[j] == nums[k]，且 (i, j, k) 是 3 个不同下标，那么三元组 (i, j, k) 被称为有效三元组。

有效三元组的距离被定义为 abs(i - j) + abs(j - k) + abs(k - i)，其中 abs(x) 表示 x 的绝对值。返回一个整数，表示有效三元组的最小可能距离。如果不存在有效三元组，返回 -1。

示例 1：

输入： nums = [1,2,1,1,3]

输出： 6

解释：

最小距离对应的有效三元组是 (0, 2, 3) 。

(0, 2, 3) 是一个有效三元组，因为 nums[0] == nums[2] == nums[3] == 1。它的距离为 abs(0 - 2) + abs(2 - 3) + abs(3 - 0) = 2 + 1 + 3 = 6。

示例 2：

输入： nums = [1,1,2,3,2,1,2]

输出： 8

解释：

最小距离对应的有效三元组是 (2, 4, 6) 。

(2, 4, 6) 是一个有效三元组，因为 nums[2] == nums[4] == nums[6] == 2。它的距离为 abs(2 - 4) + abs(4 - 6) + abs(6 - 2) = 2 + 2 + 4 = 8。

示例 3：

输入： nums = [1]

输出： -1

解释：

不存在有效三元组，因此答案为 -1。

提示：

1 <= n == nums.length <= 10e5

1 <= nums[i] <= n

2. 分析

这道题和每日一道leetcode（2026.04.11）：三个相等元素之间的最小距离 I的题目描述是一模一样的，只是n的取值范围从100扩大到了10e5，所以如果是简单的三层遍历，定然会超时。

我这里的思路是先通过一层遍历，把我有出现过三次的数值的下标给收集起来，然后再挨个遍历这些出现次数大于等于三的下标，计算最短的距离。指的注意的是，三个不同下标的两两距离之和，只与两端的下标有关。设下标依次别为i，j，k，那么距离之和为(j-i)+(k-i)+(k-j)=2(k-i)。

3. 代码实现

java 复制代码

class Solution {
    public int minimumDistance(int[] nums) {
        int n = nums.length;
        //找出所有出现三次以上的数值
        int[] arr = new int[n + 1];
        Arrays.fill(arr, -1);
        Map<Integer, List<Integer>> map = new HashMap<>();
        for (int i = 0; i < n; i++) {
            if (arr[nums[i]] == -1) {
                arr[nums[i]] = i;
                continue;
            }
            if (!map.containsKey(nums[i])) {
                ArrayList<Integer> list = new ArrayList<>();
                list.add(arr[nums[i]]);
                map.put(nums[i], list);
            }
            map.get(nums[i]).add(i);
        }
        AtomicInteger minDistance = new AtomicInteger(Integer.MAX_VALUE);
        map.forEach((key, value) -> {
            int size = value.size();
            if (size < 3) {
                return;
            }
            for (int i = 0; i < size && i + 2 < size; i++) {
                minDistance.set(Math.min(minDistance.get(), Math.abs(value.get(i + 2) - value.get(i))));
            }
        });
        return minDistance.get() == Integer.MAX_VALUE ? -1 : minDistance.get() * 2;
    }
}