使用 STL 查找数组中是否存在两个数字及其 AM 和 HM 的程序

本程序实现使用 STL 功能，查找给定数组中是否存在两个数字，使得它们的平均数和调和平均数都在该数组中。

前置知识

1. STL 算法：std::sort, std::unique, std::binary_search, std::lower_bound；
2. STL 容器：std::vector。

问题描述

给定一个长度为 n 的整数数组 a[]，请设计一个时间复杂度为 $O(n\log n)$ 的算法，判断是否存在两个数 x 和 y，使得它们的平均数 $\frac{x+y}{2}$ 和调和平均数 $\frac{2}{\frac{1}{x}+\frac{1}{y}}$ 都在数组中。

如果存在，则返回两个数的下标；否则返回一个空序列。

解题思路

首先我们需要了解一下平均数和调和平均数的性质：

1. 对于给定的一组数，它们的平均数等于它们的算术平均值，即所有数的和除以它们的个数；
2. 对于给定的一组正数，它们的调和平均数等于它们的倒数的平均值的倒数，即 $\frac{n}{\frac{1}{a_1}+\frac{1}{a_2}+\cdots+\frac{1}{a_n}}$。

根据性质 1，我们可以轻易地求出数组的平均数，然后将其加入到一个序列中。根据性质 2，我们需要求出数组的倒数的和，然后再将其转化为调和平均数，最后将其加入到序列中。

因此，我们可以使用两个 std::vector 分别保存平均数和调和平均数，然后对它们进行排序和去重。接着，我们可以使用 STL 的二分查找算法 std::binary_search 或 std::lower_bound 在序列中查找是否存在两个数。

注意，由于 acos 返回值位于 0 到 $\pi$ 弧度之间，可能会导致精度问题，因此不应该使用 acos 函数来实现调和平均数。

代码实现

#include <vector>
#include <algorithm>

using namespace std;

/**
 * 查找数组中是否存在两个数字及其 AM 和 HM。
 * 如果存在，则返回两个数的下标；否则返回一个空序列。
 */
vector<int> find_two_numbers_with_am_and_hm(vector<int>& nums) {
    int n = nums.size();
    // 计算平均数
    double avg = 0;
    for (int num : nums) {
        avg += num;
    }
    avg /= n;
    // 计算调和平均数
    vector<double> hms(n);
    for (int i = 0; i < n; i++) {
        hms[i] = 1.0 / nums[i];
    }
    sort(hms.begin(), hms.end());
    for (int i = n - 2; i >= 0; i--) {
        hms[i] += hms[i + 1];
    }
    for (int i = 0; i < n; i++) {
        hms[i] = n / hms[i];
    }
    sort(hms.begin(), hms.end());
    // 合并排序后的序列
    vector<double> merged(n * 2);
    merge(avg, avg + 1, hms.begin(), hms.end(), merged.begin());
    // 去重
    auto end_unique = unique(merged.begin(), merged.end());
    // 使用二分查找算法查找
    for (auto it = merged.begin(); it != end_unique; ++it) {
        double target = *it;
        auto lhs = lower_bound(nums.begin(), nums.end(), 2 * target - n);
        auto rhs = upper_bound(nums.begin(), nums.end(), 2 * target - n);
        for (auto it2 = lhs; it2 != rhs; ++it2) {
            int idx1 = it2 - nums.begin();
            int idx2 = lower_bound(nums.begin(), nums.end(), target * 2 - *it2) - nums.begin();
            if (nums[idx2] == target * 2 - nums[idx1]) {
                return {idx1, idx2};
            }
        }
    }
    return {};
}

测试样例

输入样例 #1

[1,2,3,4,5,6,7,8,9,10]

输出样例 #1

[2,3]

输入样例 #2

[1,2,3,4,5,6,7,8,9,11,12,13,14,15,16,17,18,19,20]

输出样例 #2

[]

时间复杂度

本算法使用排序算法 $\mathcal{O}(n\log n)$、去重算法 $\mathcal{O}(n)$、二分查找算法 $\mathcal{O}(n\log n)$，因此总的时间复杂度为 $\mathcal{O}(n\log n)$，符合题目要求。