根据转换后的值查找最小元素

Finding minimum element based on a transformed value

本文关键字：查找 元素 转换      更新时间：2023-10-16

这是我从代码审查中得到的任务。我想根据一种特殊的比较谓词，从一个集合中选择一个最小值。这样的:

struct Complex { ... };
float calcReduction(Complex elem);
Complex findMinValueWithPredicates(const std::vector<Complex>& values)
{
  auto it = std::min_element(values.begin(), values.end(), 
                             [](const Complex& a, const Complex& b) { 
                               return calcReduction(a) < calcReduction(b); 
                             });
  if (it == values.end()) throw std::runtime_error("");
  return *it;
}

在这里我找到了基于谓词的最小元素。该谓词计算两个值的约简到float，然后比较这些浮点数。工作很好，看起来很整洁。

你能看出问题所在吗?是的，对于一组N元素，calcReduction()被称为2N次，而计算N次就足够了——每个元素一次。

解决这个问题的一种方法是编写显式计算: 
Complex findMinValueExplicit(const std::vector<Complex>& values)
{
  float minReduction = std::numeric_limits<float>::max();
  Complex minValue;
  for (Complex value : values)
  {
    float reduction = calcReduction(value);
    if (reduction < minReduction)
    {
      minReduction = reduction;
      minValue = value;
    }
  }
  if (minReduction == std::numeric_limits<float>::max()) throw std::runtime_error("");
  return minValue;
}

它工作得很好，我们只有N调用calcReduction()。然而，与显式调用min_element相比，它看起来太啰嗦了，意图也不那么明确。因为当你调用min_element时很容易猜到你会找到一个最小元素。

我现在唯一的想法是创建我自己的算法，如min_element_with_reduction，接受范围和约简函数。听起来有道理，但我不知道是否有现成的解决办法。

对于如何用明确的意图和一些现成的解决方案来解决这个任务有什么想法吗?Boost受到欢迎。c++ 17和范围看起来很有趣。

您可以使用boost::range库。

auto reductionLambda = [](const Complex& a) { return calcReduction(a); };
auto it = boost::range::min_element(values | boost::adaptors::transformed( 
                             std::ref(reductionLambda));

范围本身也应该在c++ 17中成为标准c++。

编辑

正如我们在注释中所指出的，这也会使转换两次。

有趣的是:

#include <boost/iterator/iterator_adaptor.hpp>
#include <boost/assign.hpp>
#include <algorithm>
#include <iostream>
#include <vector>
#include <functional>

template <class Iterator, class UnaryFunction>
class memoizing_transform_iterator
  : public boost::iterator_adaptor<
        memoizing_transform_iterator<Iterator, UnaryFunction> // Derived
      , Iterator                                              // Base
      , std::decay_t<decltype(std::declval<UnaryFunction>()(std::declval<typename Iterator::value_type>()))> // Value
      , boost::forward_traversal_tag    // CategoryOrTraversal
    >
{
 public:
    memoizing_transform_iterator() {}
    explicit memoizing_transform_iterator(Iterator iter, UnaryFunction f)
      : memoizing_transform_iterator::iterator_adaptor_(iter), fun(f) {}
    static int total;
 private:
    friend class boost::iterator_core_access;
    void increment() { ++this->base_reference(); memoized = false; }
    using MemoType = std::decay_t<decltype(std::declval<UnaryFunction>()(std::declval<typename Iterator::value_type>()))>;      
    MemoType& dereference() const 
    {
        if (!memoized) {
            ++total;
            memoized = true;
            memo = fun(*this->base());
        }
        return memo;
    }
    UnaryFunction fun;
    mutable bool memoized = false;
    mutable MemoType memo;
};

template <class Iterator, class UnaryFunction>
auto make_memoizing_transform_iterator(Iterator i, UnaryFunction&& f)
{
    return memoizing_transform_iterator<Iterator, UnaryFunction>(i, f);
}

template<class I, class U>
int memoizing_transform_iterator<I, U>::total = 0;

// THIS IS COPIED FROM LIBSTDC++
template<typename _ForwardIterator>
   _ForwardIterator
     min_el(_ForwardIterator __first, _ForwardIterator __last)
     {
       if (__first == __last)
     return __first;
       _ForwardIterator __result = __first;
       while (++__first != __last)
     if (*__first < *__result)
       __result = __first;
       return __result;
     }

int main(int argc, const char* argv[])
{
    using namespace boost::assign;
    std::vector<int> input;
    input += 2,3,4,1,5,6,7,8,9,10;

    auto transformLambda = [](const int& a) { return a*2; };

    auto begin_it = make_memoizing_transform_iterator(input.begin(), std::ref(transformLambda));
    auto end_it = make_memoizing_transform_iterator(input.end(), std::ref(transformLambda));
    std::cout << *min_el(begin_it, end_it).base() << "n";
    std::cout <<begin_it.total;
    return 0;
}
基本上，我实现了一个迭代器来存储调用转换函子的结果。但奇怪的是，至少在在线编译器中，在比较它们的解引用值之前会复制迭代器(这样就违背了记忆的目的)。然而，当我简单地从libstdc++复制实现时，它就像预期的那样工作了。也许你可以在一台真正的机器上试用一下?示例如下:

小编辑:我在VS2015上进行了测试，它与std::min_element一起工作。

这里有一个解决方案，使用(已经与range-v3库一起工作，由即将推出的Ranges TS的作者实现)

#include <range/v3/all.hpp>
#include <iostream>
#include <limits>
using namespace ranges::v3;
int main()
{
    auto const expensive = [](auto x) { static int n; std::cout << n++ << " "; return x; };
    auto const v = view::closed_iota(1,10) | view::transform(expensive); 
    auto const m1 = *min_element(v);
    std::cout << "n" << m1 << "n";
    auto const inf = std::numeric_limits<int>::max();    
    auto const min = [](auto x, auto y) { return std::min(x, y); };
    auto const m2 = accumulate(v, inf, min);
    std::cout << "n" << m2 << "n";    
}

生活在Coliru 输出:

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 
1
19 20 21 22 23 24 25 26 27 28 
1

可以看到，使用min_element进行2N的比较，而使用accumulate只进行N的比较。

唯一缺少的是元迭代器。

元迭代器接受一个迭代器，并创建一个包含该迭代器副本的迭代器。它将所有操作都传递给所包含的迭代器，除非解引用返回所包含迭代器的副本。

无论如何，用于此操作的代码也可以用于创建size_t或int或类似torsor类的迭代器。

template<class It, class R>
struct reduced_t {
  It it;
  R r;
  friend bool operator<( reduced_t const& lhs, reduced_t const& rhs ) {
    return lhs.r < rhs.r;
  }
};
template<class It, class F>
reduced_t<It, std::result_of_t<F(typename std::iterator_traits<It>::reference)>>
reducer( It it, F&& f ) {
  return {it, std::forward<F>(f)(*it)};
}
template<class It, class F>
It reduce( It begin, It end, F&& f ) {
  if (begin==end)
    return begin;
  return std::accumulate(
    meta_iterator(std::next(begin)), meta_iterator(end),
    reducer(begin, f),
    [&](
      auto&& reduced, // reduced_t<blah...> in C++11
      It i
    ) {
      auto r2 = reducer( i, f );
      return (std::min)(reduced, r2);
    }
  ).it;
};

每个迭代器只调用一次f(*it)。

我不认为这是…显而易见的。技巧在于我们使用accumulate和元迭代器来实现min_element，然后我们可以让accumulate对转换后的元素进行操作(调用一次并返回)。

您可以使用原语以基于堆栈的编程风格重写它，但是有很多原语需要编写。也许post - range -v3.

在这一点上，我想象有一些高性能的组合编程库。如果我这样做了，我们可以这样做:

reducer( X, f )可以用order_by( get_n_t<1> )重写graph( deref |then| f )(X)来排序。

accumulate调用可以读取accumulate( skip_first(range), g(begin(range)), get_least( order_by( get_n_t<1> ) ) ) .

不确定这是否更清楚。

如果将minElem作为lambda参数，则可以使用min_element

Complex findMinValueWithPredicates(const std::vector<Complex>& values)
{
  float minElem = std::numeric_limits<float>::max();
  auto it = std::min_element(values.begin(), values.end(),
                             [&minElem](const Complex& a, const Complex& b) {
                               float tmp = calcReduction(a);
                               if (tmp < minElem) {
                                  minElem = tmp;
                                  return true;
                               }
                               return false;
                             });
  if (it == values.end()) throw std::runtime_error("");
  return *it;
}

编辑:为什么这个工作时，b不使用?25.4.7.21 min_element

21返回:[first,last)范围内的第一个迭代器i对于[first,last)范围内的每个迭代器j，如下所示(*j <*i)或comp(*j， *i) == false。如果first == last，则返回最后一个

因为b应该被命名为smallestYet(代码来自cplusplus.com)

template <class ForwardIterator>
  ForwardIterator min_element ( ForwardIterator first, ForwardIterator last )
{
  if (first==last) return last;
  ForwardIterator smallest = first;
  while (++first!=last)
    if (*first<*smallest)    // or: if (comp(*first,*smallest)) for version (2)
      smallest=first;
  return smallest;
}

这让我想到了我最喜欢的一句话:

"计算机科学中只有10个难题:缓存无效、命名和偏离1错误。"

  • 有人评论说，我们可能会off-by- 1，因为我们不使用b。
  • 我担心minElem缓存可能不正确。我意识到b这个名字应该更有意义，因为它是"解引用迭代器到最小元素"或smallestYet。
  • 最后，不是所有人都能理解二进制，当它没有以' b '结尾时。

这是另一个选择，但它仍然是有效的第二个解决方案。老实说，它看起来不太清楚，但有人可能会喜欢它。(我使用std::pair<float, Complex>来存储缩减结果和缩减的值)

std::pair<float, Complex> result{std::numeric_limits<float>::max(), {}};
auto output_function = [&result](std::pair<float, Complex> candidate) {
    if (candidate.first < result.first)
        result = candidate;
};
std::transform(values.begin(), values.end(), 
               boost::make_function_output_iterator(output_function),
               [](Complex x) { return std::make_pair(calcReduction(x), x); });

注:如果你的calcReduction花费很多，你考虑过在Complex对象中缓存结果吗?这将导致一个稍微复杂的实现，但您将能够使用普通的std::min_element，使您的意图清楚。

相关文章：