Question

任务描述如下：
我们有 n 个数字，我们必须找到数组中所有对的唯一和的数量。
例如：

3 2 5 6 3  
The sums of all the pairs(non-repeated) are 5 9 8 6 8 7 5 11 9 8  
Unique are 5 9 8 6 7 11  
Therefore output is 6

我想出了这个非常原始且耗时（意味着复杂性）的解决方案：

int n = 0;
    cin >> n;
    vector<int> vec(n);
    for (int i = 0; i < n; i++)
    {
        cin >> vec[i];
    }
    vector<int> sum;
    for (int i = 0; i < n; i++)
    {
        for (int j = i+1; j < n; j++)
        {
            sum.push_back(vec[i] + vec[j]);
        }
    }
    sort(sum.begin(), sum.end());
    for (int i = 0; i < sum.size()-1;)
    {
        if (sum[i] == sum[i + 1]) sum.erase(sum.begin() + i);
        else i++;
    }
    cout << endl << sum.size();

我觉得可以使用组合学或更简单的方法来解决。我想了很多，什么也想不出来。所以我的请求是是否有人可以改进解决方案。

Answer 1

如上所述，如果不计算所有对的总和就很难做到这一点，所以我不打算处理这个问题，我只想就有效的数据结构提出建议。

您的解决方案分析

您的代码预先添加所有内容 O(n^2)，然后对 O(n^2 log(n)) 进行排序，然后删除重复项。但是由于您要从向量中擦除，因此最终 complexity 与到列表末尾的元素数量呈线性关系。这意味着第二个循环将使算法的复杂性O(n^4)。

可以在不删除的情况下计算排序数组中的唯一元素

int count = 0;
for (int i = 0; i < sum.size()-1; ++i)
{
        if (sum[i] != sum[i + 1]) ++count
}

仅此一项更改就会使您的算法复杂度 O(n^2 log n)。

没有排序的替代品。

这里有 O(n^2) 和存储的替代方案，取决于输入值的范围而不是向量的长度（最后一个除外）。

我正在使用 0 到 10000 之间较小的 1000 个元素进行测试

vector<int> vec;
for(int i = 0; i < 1000; ++i){
    vec.push_back(rand() % 10000);
}

您的实现 sum_pairs1(vec)（18 秒）

int sum_pairs1(const vector<int> &vec){
    vector<int> sum;
    int n = vec.size();
    for (int i = 0; i < n; i++)
    {
        for (int j = i+1; j < n; j++)
        {
            sum.push_back(vec[i] + vec[j]);
        }
    }
    sort(sum.begin(), sum.end());
    for (int i = 0; i < sum.size()-1;)
    {
        if (sum[i] == sum[i + 1]) sum.erase(sum.begin() + i);
        else i++;
    }
    return sum.size();
}

如果您知道值总和的范围，您可以使用位集，有效利用内存 sum_pairs2<20000>(vec)（0.016 秒）。

template<size_t N>
int sum_pairs2(const vector<int> &vec){
    bitset<N> seen;
    int n = vec.size();
    for (int i = 0; i < n; i++)
    {
        for (int j = i+1; j < n; j++)
        {
            seen[vec[i] + vec[j]] = true;
        }
    }
    return seen.count();
}

如果你知道最大和不是那么高（向量不是很稀疏），但你在编译时不知道可以使用向量，你可以跟踪最小值和最大值来分配最小值可能并支持负值。

int sum_pairs2b(const vector<int> &vec){
    int VMAX = vec[0];
    int VMIN = vec[0]
    for(auto v : vec){
        if(VMAX < v) VMAX = v;
        else if(VMIN > v) VMIN = v;
    }
    vector<bool> seen(2*(VMAX - VMIN) + 1);
    int n = vec.size();
    for (int i = 0; i < n; i++)
    {
        for (int j = i+1; j < n; j++)
        {
            seen[vec[i] + vec[j] - 2*VMIN] = true;
        }
    }
    int count = 0;
    for(auto c : seen){
        if(c) ++count;
    }
    return count;
}

如果您想要一个更通用的解决方案，可以很好地处理稀疏数据 sum_pairs3<int>(vec)（0.097 秒）

template<typename T>
int sum_pairs3(const vector<T> &vec){
    unordered_set<T> seen;
    int n = vec.size();
    for (int i = 0; i < n; i++)
    {
        for (int j = i+1; j < n; j++)
        {
            seen.insert(vec[i] + vec[j]);
        }
    }
    return seen.size();
}

改进解决方案

1 个答案:

您的解决方案分析

没有排序的替代品。