web-dev-qa-db-ja.com

ベクトルのベクトルの最大/最小を見つける

Vector of vectorの最大/最小アイテムを見つける最も効率的で標準的な（C++ 11/14）方法は何ですか？

std::vector<std::vector<double>> some_values{{5,0,8},{3,1,9}};

必要な最大要素は9

必要な最小要素はです

c++c++11vectormaxmin
15
Humam Helfawi

2次元配列（または場合によってはベクトル）の最大要素を計算する効率的な方法には、計算にn*n要素間の比較が含まれるため、何をするかに関係なくO(n^2)の複雑さが伴います。使いやすさの点で最良の方法は、ベクトルのベクトルにstd::max_elementを使用することです。詳細は調べません。ここに 参照 を示します。

5
Anony-mouse

一般的なタイプTのイテレータ（またはスロー）を最大に戻すマルチスレッドソリューションを次に示します（operator<がTに定義されている場合）。最も重要な最適化は、C++の列優先順を利用するために「列」に対して内部最大演算を実行することです。

#include <vector>
#include <algorithm>

template <typename T>
typename std::vector<T>::const_iterator max_element(const std::vector<std::vector<T>>& values)
{
    if (values.empty()) throw std::runtime_error {"values cannot be empty"};

    std::vector<std::pair<typename std::vector<T>::const_iterator, bool>> maxes(values.size());

    threaded_transform(values.cbegin(), values.cend(), maxes.begin(),
                       [] (const auto& v) {
                           return std::make_pair(std::max_element(v.cbegin(), v.cend()), v.empty());
                       });

    auto it = std::remove_if(maxes.begin(), maxes.end(), [] (auto p) { return p.second; });

    if (it == maxes.begin()) throw std::runtime_error {"values cannot be empty"};

    return std::max_element(maxes.begin(), it,
                            [] (auto lhs, auto rhs) {
                                return *lhs.first < *rhs.first;
                            })->first;
}

threaded_transformは（まだ）標準ライブラリの一部ではありませんが、使用できる実装があります。

#include <vector>
#include <thread>
#include <algorithm>
#include <cstddef>

template <typename InputIterator, typename OutputIterator, typename UnaryOperation>
OutputIterator threaded_transform(InputIterator first, InputIterator last, OutputIterator result, UnaryOperation op, unsigned num_threads)
{
    std::size_t num_values_per_threads = std::distance(first, last) / num_threads;

    std::vector<std::thread> threads;
    threads.reserve(num_threads);

    for (int i = 1; i <= num_threads; ++i) {
        if (i == num_threads) {
            threads.Push_back(std::thread(std::transform<InputIterator,
                                      OutputIterator, UnaryOperation>,
                                      first, last, result, op));
        } else {
            threads.Push_back(std::thread(std::transform<InputIterator,
                                      OutputIterator, UnaryOperation>,
                                      first, first + num_values_per_threads,
                                      result, op));
        }
        first  += num_values_per_threads;
        result += num_values_per_threads;
    }

    for (auto& thread : threads) thread.join();

    return result;
}

template <typename InputIterator, typename OutputIterator, typename UnaryOperation>
OutputIterator threaded_transform(InputIterator first, InputIterator last, OutputIterator result, UnaryOperation op)
{
    return threaded_transform<InputIterator, OutputIterator, UnaryOperation>(first, last, result, op, std::thread::hardware_concurrency());
}
8
Daniel

boost::multi_array<double, 2>の代わりにstd::vector<std::vector<double>>を使用した場合、次のように簡単です。

auto minmax = std::minmax_element(values.data(), values.data() + values.num_elements());

ライブデモ 。

6
Chris Drew

少なくともすべての要素を確認する必要があるため、匿名マウスで述べたように、複雑さは少なくともO（n ^ 2）になります。

#include <vector>
#include <limits>
#include <algorithm>

int main() {
    std::vector<std::vector<double>> some_values;
    double max = std::numeric_limits<double>::lowest();
    for (const auto& v : some_values)
    {
        double current_max = *std::max_element(v.cbegin(), v.cend());
        max = max < current_max ? current_max : max; // max = std::max(current_max, max);
    }
}
5
Yola

double of vectorのすべてのvectorを反復処理するカスタムイテレータを作成する場合、単純なstd::minmax_element仕事をする

イテレータは次のようなものです：

class MyIterator : public std::iterator<std::random_access_iterator_tag, double>
{
public:
    MyIterator() : container(nullptr), i(0), j(0) {}

    MyIterator(const std::vector<std::vector<double>>& container,
               std::size_t i,
               std::size_t j) : container(&container), i(i), j(j)
    {
        // Skip empty container
        if (i < container.size() && container[i].empty())
        {
            j = 0;
            ++(*this);
        }
    }
    MyIterator(const MyIterator& rhs) = default;
    MyIterator& operator = (const MyIterator& rhs) = default;

    MyIterator& operator ++() {
        if (++j >= (*container)[i].size()) {
            do {++i;} while (i < (*container).size() && (*container)[i].empty());
            j = 0;
        }
        return *this;
    }
    MyIterator operator ++(int) { auto it = *this; ++(*this); return it; }

    MyIterator& operator --() {
        if (j-- == 0) {
            do  { --i; } while (i != 0 && (*container)[i].empty());
            j = (*container)[i].size();
        }
        return *this;
    }
    MyIterator operator --(int) { auto it = *this; --(*this); return it; }

    double operator *() const { return (*container)[i][j]; }


    bool operator == (const MyIterator& rhs) const {
        return container == rhs.container && i == rhs.i && j == rhs.j;
    }
    bool operator != (const MyIterator& rhs) const { return !(*this == rhs); }

private:
    const std::vector<std::vector<double>>* container;
    std::size_t i;
    std::size_t j;
};

そして使い方は

// Helper functions for begin/end
MyIterator MyIteratorBegin(const std::vector<std::vector<double>>& container)
{
    return MyIterator(container, 0, 0);
}

MyIterator MyIteratorEnd(const std::vector<std::vector<double>>& container)
{
    return MyIterator(container, container.size(), 0);
}

int main() {
    std::vector<std::vector<double>> values = {{5,0,8}, {}, {3,1,9}};

    auto b = MyIteratorBegin(values);
    auto e = MyIteratorEnd(values);
    auto p = std::minmax_element(b, e);

    if (p.first != e) {
        std::cout << "min is " << *p.first << " and max is " << *p.second << std::endl;
    }
}

実例

4
Jarod42

プレーンfor loop 仕方：

T max_e = std::numeric_limits<T>::min();
for(const auto& v: vv) {
    for(const auto& e: v) {   
        max_e = std::max(max_e, e);
    }
}
4
Chen OT

accumulate 関数を使用して、次のように記述できます。

#include <algorithm>
#include <iostream>
#include <vector>

int main()
{
  std::vector<std::vector<double>> m{ {5, 0, 8}, {3, 1, 9} };

  double x = std::accumulate(m.begin(), m.end(), m[0][0],
                             [](double max, const std::vector<double> &v)
                             {
                               return std::max(max,
                                               *std::max_element(v.begin(),
                                                                 v.end()));
                             });

  std::cout << x << '\n';
  return 0;
}

しかし、私は古くて良いfor-loopを好みます。

この例を拡張して、最小値と最大値の両方を見つけることができます。

std::accumulate(m.begin(), m.end(),
                std::make_pair(m[0][0], m[0][0]),
                [](std::pair<double, double> minmax, const std::vector<double> &v)
                {
                  auto tmp(std::minmax_element(v.begin(), v.end()));

                  return std::make_pair(
                    std::min(minmax.first, *tmp.first),
                    std::max(minmax.second, *tmp.second));
                });

残念ながら、ベクトルのベクトルはメモリに隣接して格納されていないため、すべての値を含む単一のブロックがありません（これが、ベクトルのベクトルが行列の適切なモデルではない理由の1つです）。

要素が多く含まれている場合は、vector of vectorを利用できます。

各サブベクトルは自律型であるため、 std :: async を使用して、各サブベクトルの最大値を含む先物ベクトルを非同期で埋めることができます。

3
manlio

Eric Nieblerの range-v ライブラリを使用すると、これをかなり簡単に行うことができます（明らかに標準ではありませんが、そう遠くない将来になるでしょう）。

vector<vector<double>> some_values{{5,0,8},{3,1,9}};

auto joined = some_values | ranges::view::join;
auto p = std::minmax_element(joined.begin(), joined.end());

p.firstはmin要素のイテレーターです。 p.second MAXに。

（range-v3にはminmax_elementの実装がありますが、残念ながらForwardRangeとview :: joinが必要なため、InputRangeしか提供されないため、使用できません。）

3
edflanders

最も簡単な方法は、最初に1つのベクトルの最大/最小要素を決定する関数を使用することです。

    double getMaxInVector(const vector<double>& someVec){}

この場合の参照渡し（読み取り専用）は、時間とスペースの効率が大幅に向上します（ベクトル全体をコピーする関数は必要ありません）。したがって、ベクトルのベクトルの最大/最小要素を決定する関数では、次のようなネストされたループがあります。

    for(size_t x= 0; x < some_values.size(); x++){
        for(size_t y = 0; y < x.size(); y++){
            // y represents the vectors inside the vector of course
            // current max/min = getMax(y)
            // update max/min after inner loop finishes and x increments
            // by comparing it with previous max/min

上記のソリューションの問題は、その非効率性です。私の知る限りでは、このアルゴリズムは一般にO（n ^ 2log（n））の効率で実行されますが、これは非常に印象的ではありません。しかし、もちろん、それはまだ解決策です。ベクトルの最大値/最小値を見つけることができる標準的なアルゴリズムがあるかもしれませんが、独自のものを書く方が常により効果的です。アルゴリズムを一般的に同じにするため、与えられた方法を使用しても、通常、効率の向上という点では何も起こりません（最大/最小を決定する小さな関数の場合）。実際、標準的な関数は、実行時に処理する型を決定する必要があるテンプレートであるため、理論的には、標準的な関数の実行はわずかに遅くなります。

1
fahimg23

以下に示すように、some_valuesという名前のベクトルがあるとします。

7 4 2 0 
4 8 10 8 
3 6 7 6 
3 9 19* 14

以下に示すように、1次元ベクトルを定義します。

vector<int> oneDimVector;
for(int i = 0; i < 4; i++){
    for(int j = 0; j < 4; j++){
        oneDimVector.Push_back(some_values[i][j]);
    }
}

次に、以下に示すように、その1次元ベクトルの最大/最小要素を見つけます。

vector<int>::iterator maxElement = max_element(oneDimVector.begin(),oneDimVector.end());
vector<int>::iterator minElement = min_element(oneDimVector.begin(),oneDimVector.end());

次のように最大/最小要素を取得します

cout << "Max element is " << *maxElement << endl;
cout << "Min element is " << *minElement << endl;
0
oya163
vector<vector<int>> vv = { vector<int>{10,12,43,58}, vector<int>{10,14,23,18}, vector<int>{28,47,12,90} };
vector<vector<int>> vv1 = { vector<int>{22,24,43,58}, vector<int>{56,17,23,18}, vector<int>{11,12,12,90} };
int matrix1_elem_sum=0;
int matrix2_elem_sum = 0;
for (size_t i = 0; i < vv.size(); i++)
{
    matrix1_elem_sum += std::accumulate(vv[i].begin(), vv[i].end(), 0);
    matrix2_elem_sum += std::accumulate(vv1[i].begin(), vv1[i].end(), 0);

}
cout << matrix1_elem_sum <<endl;
cout << matrix2_elem_sum << endl;
int summ = matrix1_elem_sum + matrix2_elem_sum;
cout << summ << endl;

または最適化されたバリアント：

vector<vector<int>> vv = { vector<int>{10,12,43,58}, vector<int>{10,14,23,18}, vector<int>{28,47,12,90} };
vector<vector<int>> vv1 = { vector<int>{22,24,43,58}, vector<int>{56,17,23,18}, vector<int>{11,12,12,90} };
int summ=0;
int matrix2_elem_sum = 0;
for (size_t i = 0; i < vv.size(); i++)
{
    summ += std::accumulate(vv[i].begin(), vv[i].end(), 0)+ std::accumulate(vv1[i].begin(), vv1[i].end(), 0);


}
cout << summ << endl;
 }
0
BadCatss