2026-04-14: 镜像对之间最小绝对距离。用go语言, 给定一个整数数

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

1.0

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

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

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

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

1

1

输入： 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

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 = 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:

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 = 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

#include

#include

#include

using namespace std;

int minMirrorPairDistance(vector& nums) {

auto reverseNum = [](int x) -> int {

int y = 0;

while (x > 0) {

x /= 10;

}

return y;

};

unordered_map prev;

int n = nums.size;

int ans = n + 1;

for (int i = 0; i

int x = nums[i];

if (prev.find(x) != prev.end) {

int idx = prev[x];

if (i - idx

ans = i - idx;

}

}

prev[reverseNum(x)] = i;

}

if (ans == n + 1) {

return-1;

}

return ans;

}

int main {

vector nums = {12, 21, 45, 33, 54};

int result = minMirrorPairDistance(nums);

cout

return0;

}

我们相信人工智能为普通人提供了一种“增强工具”，并致力于分享全方位的AI知识。在这里，您可以找到最新的AI科普文章、工具评测、提升效率的秘籍以及行业洞察。

欢迎关注“福大大架构师每日一题”，发消息可获得面试资料，让AI助力您的未来发展。