Question

我有一个矢量矢量

的矢量

std::vector<std::vector<std::vector<double>>> mountain_table

我想找到它最高的这个向量的坐标i，j，k。我知道我应该使用max_element，但我不知道如何在3d矢量中使用它。

我该如何获得这些坐标？

Answer 1

我建议将数据线性化，以便能够使用标准算法。我们的想法是提供一些函数来从3D坐标中获取索引，而反之亦然：

template<class T>
class Matrix3D // minimal
{
public:
    using value_type = T;
    using iterator   = std::vector<value_type>::iterator;

private:
    std::vector<value_type> _data;
    size_t _sizex, _sizey, _sizez;

    size_t index_from_coords(size_t x, size_t y, size_t z) const
    {
        return x*_sizex*_sizey + y*_sizey + z;
    }
    std::tuple<size_t, size_t, size_t> coords_from_index(size_t index) const
    {
        const size_t x = index / (_sizex * _sizey);
        index = index % x;
        const size_t y = index / _sizey;
        const size_t z = index % _sizey;
        return make_tuple(x, y, z);
    }

public:
    Matrix3D(size_t sizex, sizey, sizez) : _sizex(sizex), ... {}
    T& operator()(size_t x, size_t y, size_t z) // add const version
    {
        return _data[index_from_coords(x, y, z)];
    }
    std::tuple<size_t, size_t, size_t> coords(iterator it)
    {
        size_t index = std::distance(begin(_data), it);
        return coords_from_index(index);
    }
    iterator begin() { return begin(_data); }
    iterator end()   { return end(_data);   }
}

用法：

Matrix3D<double> m(3, 3, 3);
auto it = std::max_element(m.begin(), m.end()); // or min, or whatever from http://en.cppreference.com/w/cpp/header/algorithm
auto coords = m.coords(it);
std::cout << "x=" << coords.get<0>() << ... << "\n";

这是未经测试且不完整的代码，可为您提供更好的数据设计。我很乐意在下面的评论中回答关于这个想法的进一步问题;）

Answer 2

通过循环遍历矩阵，检查最高值并记录其索引，我将如何做到这一点。

size_t highestI = 0;
size_t highestJ = 0;
size_t highestK = 0;

double highestValue = -std::numeric_limits<double>::infinity(); // Default value (Include <limits>)

for (size_t i = 0; i < mountain_table.size(); ++i)
{
    for (size_t j = 0; j < mountain_table[i].size(); ++j)
    {
        for (size_t k = 0; k < mountain_table[i][j].size(); ++k)
        {
            if (mountain_table[i][j][k] > highestValue)
            {
                highestValue = mountain_table[i][j][k]; // Highest 
                // value needed to figure out highest indexes
                // Stores the current highest indexes
                highestI = i; 
                highestJ = j;
                highestK = k;
            }
        }
    }
}

这可能不是最有效的算法，但它以可理解的方式完成工作。

Answer 3

由于max_element函数非常简短且易于实现，我建议您自己编写类似的东西以适合您的确切场景。

// For types like this I would suggest using a type alias
using Vector3d = std::vector<std::vector<std::vector<double>>>;

std::array<size_t, 3> max_element(const Vector3d& vector) {
    std::std::array<size_t, 3> indexes;
    double biggest = vector[0][0][0];
    for (unsigned i = 0; i < vector.size(); ++i)
        for (unsigned j = 0; j < vector[i].size(); ++j)
            for (unsigned k = 0; k < vector[i][j].size(); ++k)
                if (value > biggest) {
                    biggest =  value;
                    indexes = { i, j, k };
                }
    return indexes;
}

我可以给你的另一个建议是编写自定义类Vector3d，使用方便的函数，如operator()(int x, int y, int z)等，并在内部以简单vector<double>大小{{1}保存数据}}

Answer 4

std::size_t rv[3] = {0};
std::size_t i = 0;
double max_value = mountain_table[0][0][0];
for (const auto& x : mountain_table) {
  std::size_t j = 0;
  for (const auto& y : x) {
    auto it = std::max_element(y.begin(), y.end());
    if (*it > max_value) {
      rv[0] = i; rv[1] = j; rv[2] = it - y.begin();
      max_value = *it;
    }
    ++j;
  }
  ++i;
}

Answer 5

我认为您不能将std::max_element用于此类数据。您可以使用std::accumulate()：

using dvect = std::vector<double>;
using ddvect = std::vector<dvect>;
using dddvect = std::vector<ddvect>;
dddvect mx = { { { 1, 2, 3 }, { -1, 3 }, { 8,-2, 3 } },
               { {}, { -1, 25, 3 }, { 7, 3, 3 } },
               { { -1, -2, -3 }, {}, { 33 } } };

struct max_value {
    size_t i = 0;
    size_t j = 0;
    size_t k = 0;

    double value = -std::numeric_limits<double>::infinity();

    max_value() = default;
    max_value( size_t i, size_t j, size_t k, double v ) : i( i ), j( j ), k( k ), value( v ) {}

    max_value operator<<( const max_value &v ) const
    {
        return value > v.value ? *this : v;
    }

};

auto max = std::accumulate( mx.begin(), mx.end(), max_value{}, [&mx]( const max_value &val, const ddvect &ddv ) {
    auto i = std::distance( &*mx.cbegin(), &ddv );
    return std::accumulate( ddv.begin(), ddv.end(), val, [i,&ddv]( const max_value &val, const dvect &dv ) {
        auto j = std::distance( &*ddv.cbegin(), &dv );
        return std::accumulate( dv.begin(), dv.end(), val, [i,j,&dv]( const max_value &val, const double &d ) {
            auto k = std::distance( &*dv.cbegin(), &d );
            return val << max_value( i, j, k, d );
        } );
    } );
} );

live example。如果C ++ 14或更高版本允许，代码可以简化，但我不确定它会更糟，努力和数据重组最有可能更好地工作（例如，你可以在单个向量上使用std::max_element()）。另一方面，此布局支持锯齿状矩阵，如示例所示（不同大小的子阵列）

Answer 6

您应该使用＆＃34;用于＆＃34;循环，因为你没有3d矢量。

for (size_t i = 0; i <mountain_table.size(); ++i)
{
  for (size_t j = 0; j < mountain_table[i].size() ++j)
    {
     // find max element index k here and check if it is maximum.
     // If yes save i, j, k and update max val
    }
}

在矢量矢量向量中找到最大位置

6 个答案: