2026-04-14：镜像对之间最小绝对距离。用go语言，给定一个整数数组 nums。如果存在两个下标 (i, j) 满足： 1.0 <= i < j < nums.length 2

福大大架构师每日一题

发布于 2026-04-14 16:38:03

文章被收录于专栏：福大大架构师每日一题福大大架构师每日一题

2026-04-14：镜像对之间最小绝对距离。用go语言，给定一个整数数组 nums。如果存在两个下标 (i, j) 满足：

1.0 <= i < j < nums.length

2.把 nums[i] 的数字倒序后得到的数（倒序会自动忽略前导零），等于 nums[j]

则称 (i, j) 为“镜像对”。

对每个镜像对计算下标差的绝对值 abs(i - j)，要求返回所有镜像对中最小的 abs(i - j)。

若数组中不存在任何镜像对，则返回 -1。

1 <= nums.length <= 100000。

1 <= nums[i] <= 1000000000。

输入： nums = [12,21,45,33,54]。

输出： 1。

解释：

镜像对为：

(0, 1)，因为 reverse(nums[0]) = reverse(12) = 21 = nums[1]，绝对距离为 abs(0 - 1) = 1。

(2, 4)，因为 reverse(nums[2]) = reverse(45) = 54 = nums[4]，绝对距离为 abs(2 - 4) = 2。

所有镜像对中的最小绝对距离是 1。

题目来自力扣3761。

大体步骤如下：

我们从数组第一个元素开始，依次遍历每一个元素，执行查询匹配 → 记录反转值两个核心操作：

第一步：遍历下标 0，元素 = 12

1. 查询匹配：在哈希表中查找当前元素 12 是否存在记录。此时哈希表为空，无匹配结果，不计算距离。
2. 记录反转值：计算 12 的反转值 = 21，将 21: 0 存入哈希表。哈希表状态：{21:0} 最小距离：仍为初始值（无镜像对）

第二步：遍历下标 1，元素 = 21

1. 查询匹配：在哈希表中查找当前元素 21 是否存在记录。哈希表中存在 21:0，匹配成功！
2. 计算距离：当前下标 1 - 匹配下标 0 = 1。这个距离小于初始最小距离，更新最小距离为 1。
3. 记录反转值：计算 21 的反转值 = 12，将 12: 1 存入哈希表（覆盖旧值）。哈希表状态：{21:0, 12:1} 最小距离：1

第三步：遍历下标 2，元素 = 45

1. 查询匹配：在哈希表中查找当前元素 45 是否存在记录。哈希表中无 45，无匹配结果，不计算距离。
2. 记录反转值：计算 45 的反转值 = 54，将 54: 2 存入哈希表。哈希表状态：{21:0, 12:1, 54:2} 最小距离：1

第四步：遍历下标 3，元素 = 33

1. 查询匹配：在哈希表中查找当前元素 33 是否存在记录。哈希表中无 33，无匹配结果，不计算距离。
2. 记录反转值：计算 33 的反转值 = 33，将 33: 3 存入哈希表。哈希表状态：{21:0, 12:1, 54:2, 33:3} 最小距离：1

第五步：遍历下标 4，元素 = 54

1. 查询匹配：在哈希表中查找当前元素 54 是否存在记录。哈希表中存在 54:2，匹配成功！
2. 计算距离：当前下标 4 - 匹配下标 2 = 2。这个距离大于当前最小距离 1，不更新最小距离。
3. 记录反转值：计算 54 的反转值 = 45，将 45: 4 存入哈希表。哈希表状态：{21:0, 12:1, 54:2, 33:3, 45:4} 最小距离：1

遍历结束后的最终处理

1. 检查最小距离：已经找到有效镜像对，最小距离为 1。
2. 返回结果：1。

时间复杂度 & 额外空间复杂度

1. 时间复杂度：O(n × d)

• n 是数组的长度（最多 100000）；
• d 是单个数字的最大位数（题目中数字最大为 10亿，最多 10 位，是固定常数）；
• 遍历数组仅执行一次，每个数字仅执行一次反转操作，哈希表的查询、插入操作都是 O(1) 级别；
• 因为位数 d 是固定常数，简化后时间复杂度可视为 O(n)（线性时间）。

2. 额外空间复杂度：O(n)

• 核心额外空间是哈希表，最坏情况下数组中所有元素的反转值都不重复，哈希表需要存储 n 个键值对；
• 其他变量（最小距离、临时变量）都是常数级空间，不影响复杂度；
• 因此额外空间复杂度为 O(n)。

总结

1. 执行逻辑：遍历数组时，用哈希表记录已遍历元素的反转值和下标，每次用当前元素去哈希表匹配，找到就计算距离，最终保留最小值；
2. 时间复杂度：O(n)（线性复杂度，适合处理十万级数据）；
3. 额外空间复杂度：O(n)。

Go完整代码如下：

package main

import (
    "fmt"
)

func minMirrorPairDistance(nums []int)int {
    reverseNum := func(x int)int {
        y := 0
        for x > 0 {
            y = y*10 + x%10
            x /= 10
        }
        return y
    }

    prev := make(map[int]int)
    n := len(nums)
    ans := n + 1

    for i, x := range nums {
        if idx, exists := prev[x]; exists {
            if i-idx < ans {
                ans = i - idx
            }
        }
        prev[reverseNum(x)] = i
    }

    if ans == n+1 {
        return-1
    }
    return ans
}

func main() {
    nums := []int{12, 21, 45, 33, 54}
    result := minMirrorPairDistance(nums)
    fmt.Println(result)
}

Python完整代码如下：

# -*-coding:utf-8-*-

def min_mirror_pair_distance(nums):
    def reverse_num(x):
        y = 0
        while x > 0:
            y = y * 10 + x % 10
            x //= 10
        return y
    
    prev = {}
    n = len(nums)
    ans = n + 1
    
    for i, x in enumerate(nums):
        if x in prev:
            if i - prev[x] < ans:
                ans = i - prev[x]
        prev[reverse_num(x)] = i
    
    return-1if ans == n + 1else ans

def main():
    nums = [12, 21, 45, 33, 54]
    result = min_mirror_pair_distance(nums)
    print(result)

if __name__ == "__main__":
    main()

C++完整代码如下：

#include <iostream>
#include <vector>
#include <unordered_map>
#include <algorithm>

using namespace std;

int minMirrorPairDistance(vector<int>& nums) {
    auto reverseNum = [](int x) -> int {
        int y = 0;
        while (x > 0) {
            y = y * 10 + x % 10;
            x /= 10;
        }
        return y;
    };

    unordered_map<int, int> prev;
    int n = nums.size();
    int ans = n + 1;

    for (int i = 0; i < n; i++) {
        int x = nums[i];
        if (prev.find(x) != prev.end()) {
            int idx = prev[x];
            if (i - idx < ans) {
                ans = i - idx;
            }
        }
        prev[reverseNum(x)] = i;
    }

    if (ans == n + 1) {
        return-1;
    }
    return ans;
}

int main() {
    vector<int> nums = {12, 21, 45, 33, 54};
    int result = minMirrorPairDistance(nums);
    cout << result << endl;
    return0;
}