如何使用 lambda 找到最小距离

Posted 2023-02-17

【中文标题】如何使用 lambda 找到最小距离

【英文标题】：How to find minimum distance using lambda

【发布时间】：2020-05-04 15:36:27

【问题描述】：

我有两个课程Entity 和Ship。 Ship 继承自 Entity。它们具有x 和y 作为属性，代表二维平面上的位置。

squared_distance 函数返回船只和实体之间的距离。

class Entity

    public:
    int id, x, y;

    Entity(int id, int x, int y) : id(id), x(x), y(y) 
;

class Ship : public Entity

    public:
    int orientation, speed, rum;

    Ship(int id, int x, int y, int ori, int s, int r): 
        Entity(id, x, y)
    
        orientation = ori;
        speed = s;
        rum = r;
    
;

int squared_distance(Entity e, Ship s)

    return pow((e.x - s.x), 2) + pow((e.y - s.y), 2);

我需要找到离船最近的实体。我有一个名为entities 的Entity 数组。一种方法是： 让ship 是Ship 的对象。

index 会将最近实体的索引提供给ship。

int min_distance = 10000000;
int index;
for (int i = 0; i < entities.size(); ++i)

    int curr_distance = squared_distance(entities[i], ship);

    if (curr_distance < min_distance)
    
        min_distance = curr_distance;
        index = i;
    

如何在算法库中使用带有std::min_element 的lambda 找到最近的实体？

【问题讨论】：

对不起，算法库中的std::min_element函数。

【参考方案1】：

int squared_distance(const Entity& e, const Ship& s)

    return pow((e.x - s.x), 2) + pow((e.y - s.y), 2);


std::min_element(std::begin(entities), std::end(entities), [&ship](const Entity& a, const Entity& b)  return squared_distance(a, ship) < squared_distance(b, ship); );

请注意，您需要更新 squared_distance 声明中的参数。

【参考方案2】：

您可以像这样将其转换为std::min_element：

auto closer = [&ship](const auto &e1, const auto &e2) 
                return squared_distance(e1, ship) 
                     < squared_distance(e2, ship);
              ;

auto it = std::min_element(std::begin(entities), std::end(entities), closer);

请注意，此算法（与大多数算法一样）会将iterator 返回到最近的船。您可以通过取消引用此迭代器来获得最近的船：

auto closest_ship = *it;

你也可以得到这艘船的索引（就像你的版本一样）：

int i = std::distance(std::begin(entities), it);

作为@S.M.在他们的回答中指出，您的 squared_distance 函数应该使用 const& 的参数，因为您不需要复制这些对象来比较它们。

【参考方案3】：

类似

#include <iterator>
#include <algorithm>

//...

auto it = std::min_element( std::begin( entities ), std::end( entities ),
                            [&ship]( const auto &first, const auto &second )
                            
                                return squared_distance( first, ship ) < squared_distance( second, ship );
                             );   

您可以单独定义 lambda，例如

auto less_distance = [&ship]( const auto &first, const auto &second )

    return squared_distance( first, ship ) < squared_distance( second, ship );
;   

那么算法的调用会是这样的

auto it = std::min_element( std::begin( entities ), std::end( entities ),
                            less_distance );