2026-06-22：不同频率的最小数对。用go语言，给定一个整数数组 nums，你需要从中找到两个不同的数 x 和 y，要求 x 比 y 小，而且它们在数

福大大架构师每日一题

发布于 2026-06-24 15:56:57

200

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

2026-06-22：不同频率的最小数对。用go语言，给定一个整数数组 nums，你需要从中找到两个不同的数 x 和 y，要求 x 比 y 小，而且它们在数组里出现的次数不一样。

在所有符合条件的组合里，先优先选择 x 尽可能小的那一组；如果有多组的 x 一样，再选择 y 尽可能小的那一组。

最后返回这两个数组成的数组 [x, y]。

如果根本找不到这样的两个数，就返回 [-1, -1]。

1 <= nums.length <= 100。

1 <= nums[i] <= 100。

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

输出： [1,3]。

解释：

最小的值是 1，频率为 2。比 1 大且频率与 1 不同的最小值是 3，其频率为 1。因此，答案是 [1, 3]。

题目来自力扣3852。

一、代码完整分步执行过程

步骤1：遍历原数组，统计数字频次、记录全局最小值x候选

1. 初始化空哈希映射 cnt，作用：key=数组数字，value=该数字出现次数；
2. 初始化变量 mn（用来存全局最小数字），赋值为整型最大值，保证任意数组数字都能覆盖它；
3. 逐个取出数组中每一个元素 x：
- • 将该数字在映射表中的计数 +1，完成频次统计；
- • 对比当前元素和 mn，如果当前数字更小，就更新 mn；
4. 遍历结束后得到两个关键信息：
- • cnt：完整记录数组所有不重复数字的出现次数；
- • mn：整个数组里数值最小的数字，也就是我们第一优先级要选的 x；
5. 取出 mn 对应的出现次数，存入变量 cntMin，即目标 x 的频次。

以示例 [1,1,2,2,3,4] 举例：

• 频次映射结果：1:2，2:2，3:1，4:1；
• 全局最小数字 mn = 1，cntMin = 2。

步骤2：遍历频次映射，寻找满足条件的最小y

要求 y 满足两点：① y 的出现次数不等于 cntMin；② 后续要保证 y > mn；

1. 初始化变量 minY（存储符合频次条件的最小数字），赋值整型最大值；
2. 遍历频次映射里每一组（数字y，对应频次c）：
- • 判断：如果当前数字的频次 c ≠ cntMin（和x频次不一样）；
- • 满足频次条件时，对比当前y和 minY，若y更小，更新 minY；
3. 本轮遍历结束后，minY 是全数组中频次和x不相等的所有数字里数值最小的那一个。

示例遍历过程：

• y=1，频次2 == cntMin(2)，跳过；
• y=2，频次2 == cntMin(2)，跳过；
• y=3，频次1 ≠ 2，minY更新为3；
• y=4，频次1 ≠ 2，4比3大，不更新minY；最终 minY = 3。

步骤3：合法性校验，构造返回结果

1. 判断 minY 是否仍等于初始的整型最大值：
- • 等于：代表数组里所有数字的出现频次全部相同，不存在符合要求的数对，返回 [-1, -1]；
- • 不等于：存在合法y，此时 mn < minY 天然成立（因为mn是全局最小数字，minY是另一个不同数字），直接返回数组 [mn, minY]。

示例中 minY=3 有效，返回 [1, 3]，和题目输出一致。

边界场景补充逻辑

场景：数组所有数字频次完全一致，例如 [5,5,6,6,7,7]

• mn=5，cntMin=2；
• 遍历所有y：5、6、7频次全是2，minY保持最大值；
• 判定无合法数对，返回 [-1,-1]。

二、时间复杂度分析

设数组长度为 n，数组中不重复数字的数量为 k（k ≤ n）。

1. 第一次遍历原数组：循环 n 次，单次哈希读写为 O(1)，耗时 O(n)；
2. 第二次遍历频次哈希表：循环 k 次，k最大等于n，耗时 O(n)；总操作：两段线性遍历，无嵌套循环。 总时间复杂度：O(n)

三、额外空间复杂度分析

额外开辟的存储空间只有哈希映射 cnt，最多存储 k 个键值对，k ≤ n；其余变量（mn、cntMin、minY）均为常数级固定空间，不随数组长度变化。 总额外空间复杂度：O(n) （最坏情况数组所有数字互不重复，哈希表存储n组数据）

Go完整代码如下：

package main

import (
    "fmt"
    "math"
)

func minDistinctFreqPair(nums []int) []int {
    cnt := map[int]int{}
    mn := math.MaxInt
    for _, x := range nums {
        cnt[x]++
        mn = min(mn, x)
    }

    cntMin := cnt[mn]
    minY := math.MaxInt
    for y, c := range cnt {
        if c != cntMin {
            minY = min(minY, y)
        }
    }

    if minY == math.MaxInt {
        return []int{-1, -1}
    }
    return []int{mn, minY}
}

func main() {
    nums := []int{1, 1, 2, 2, 3, 4}
    result := minDistinctFreqPair(nums)
    fmt.Println(result)
}

Python完整代码如下：

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

from typing import List
import math

def min_distinct_freq_pair(nums: List[int]) -> List[int]:
    # 统计频次
    cnt = {}
    mn = math.inf
    for x in nums:
        cnt[x] = cnt.get(x, 0) + 1
        mn = min(mn, x)
    
    # 获取最小值的频次
    cnt_min = cnt[mn]
    
    # 找到频次不等于 cnt_min 的最小值
    min_y = math.inf
    for y, c in cnt.items():
        if c != cnt_min:
            min_y = min(min_y, y)
    
    # 如果没找到，返回 [-1, -1]
    if min_y == math.inf:
        return [-1, -1]
    return [mn, min_y]


def main():
    nums = [1, 1, 2, 2, 3, 4]
    result = min_distinct_freq_pair(nums)
    print(result)


if __name__ == "__main__":
    main()

C++完整代码如下：

#include <iostream>
#include <vector>
#include <unordered_map>
#include <climits>

using namespace std;

vector<int> minDistinctFreqPair(vector<int>& nums) {
    unordered_map<int, int> cnt;
    int mn = INT_MAX;

    for (int x : nums) {
        cnt[x]++;
        mn = min(mn, x);
    }

    int cntMin = cnt[mn];
    int minY = INT_MAX;

    for (auto& p : cnt) {
        int y = p.first;
        int c = p.second;
        if (c != cntMin) {
            minY = min(minY, y);
        }
    }

    if (minY == INT_MAX) {
        return {-1, -1};
    }
    return {mn, minY};
}

int main() {
    vector<int> nums = {1, 1, 2, 2, 3, 4};
    vector<int> result = minDistinctFreqPair(nums);
    cout << "[" << result[0] << ", " << result[1] << "]" << endl;
    return0;
}