Question

我尝试使用OpenMP作为初学者来优化贪婪功能。

不幸的是，我尝试了几件事没有成功。我只是在向量中搜索每对中的第一个元素，将其出现的索引（唯一）作为同一向量中的第二个元素。这是我的代码：

std::vector<int> function(std::vector<std::pair<int, int> >& pair_vector)
{
    unsigned int size = pairVector.size();
    std::vector<int> resVector(size);

    #pragma omp parallel
    {
        #pragma omp for
        for(unsigned int i = 0; i < size; ++i)
        {
            resVector[i] = -pairVector[i].first;

            for (unsigned int j = i; j < size; ++j)
            {
                if(pairVector[i].first == pairVector[j].second)
                {
                    resVector[i] = size - j; 
                    break;                                          
                }
            }                                                   
        }
    }

    return resVector;
}

有没有人看到这个有什么问题？

感谢。

编辑：

向量中的对数可以超过1.000.000。两种实现方式的结果相同。即使对于那么大的数据，也没有加速（即使有不同的计划类型）。

Answer 1

您使用的算法似乎是O（N ^ 2），但应该可以在O（NlogN）中使用。即使O（NlogN）解决方案是串行的，它仍应提供净加速。

这是针对您的问题的O（NlogN）解决方案。可以通过更好地使用STL来加强代码。

#include <algorithm>

std::vector<int> function(std::vector<std::pair<int, int> >& pair_vector) {
    unsigned int size = pair_vector.size();
    std::vector<int> resVector(size);

    std::vector<std::pair<int, int> > firsts(size);
    std::vector<std::pair<int, int> > seconds(size);
    for (int i=0; i<size; i++) {
        firsts[i] = std::pair<int, int>(pair_vector[i].first, i);
        seconds[i] = std::pair<int, int>(pair_vector[i].second, size-i);
    }

    std::sort(firsts.begin(), firsts.end());
    std::sort(seconds.begin(), seconds.end());

    int j=0;
    for (int i=0; i<size; i++) {
      while ((seconds[j].first < firsts[i].first)&&(j<size))
        j++;
      if (seconds[j].first == firsts[i].first)
        resVector[firsts[i].second] = seconds[j].second;
      else
        resVector[firsts[i].second] = -firsts[i].first;
    }

    return resVector;
}

OpenMP优化无效

1 个答案: