STL Algorithmen funktionieren ja nur auf einem einzelnen Containter. Also könnte ich drüber loopen und aus den jeweils ersten Elementen jedes Zeilenvektors einen neuen Vektor machen und das gleich dann für das jeweils zweite Element aller Zeilen usw. aber das ist wahrscheinlich ineffektiv.

Was ist sowieso generell schneller? Sortieren und dann den ersten Eintrag abgreifen oder minimum Algorithmen?

Danke für Eure Hilfe

STL Algorithmen funktionieren ja nur auf einem einzelnen Containter.

Auf Iteratoren um genau zu sein. Und was diese Container als Template-Parameter haben, ist Wurst. Musst du höchstens die Variante der Funktion nehmen, bei der Du eine Funktion mit übergeben musst.

Suchst du sowas:

auto it = std::min_element(vec.begin(), vec.end(), [](const std::vector<int>& v, const std::vector<int>& v2){
        return std::accumulate(v.begin(), v.end(), 0) < std::accumulate(v2.begin(), v2.end(), 0);
    });

Was ist sowieso generell schneller? Sortieren und dann den ersten Eintrag abgreifen oder minimum Algorithmen?

Denk mal darüber nach, wie man ein Minimum aus einer Menge findet. Wie viele Operationen sind dazu nötig?

Wenn die Spaltenlänge fest ist, wieso dann vector von vector? Das ist höchst ineffizient. Speicher doch einfach alles in einem Vector. Und wenn du schon dabei bist, und wenn du öfters Operationen machst, die pro Spalte anstatt pro Zeile berechnet werden, dann speicher sie auch gleich im row-major Format. Dann wird die Lösung deiner Frage trivial.

Falls du tatsächlich einen guten Grund hattest, deine Daten im column-major Format zu speichern, dann musst du hier eben jeweils in 14-er Schritten durch das Array gehen. Dazu kann man sich auch schick einen Zeileniterator schreiben, der diesen Vorgang abstrahiert. Dann kann man auch wieder die STL-Minimumssuche einsetzen.

---vec1---
---vec2---
---vec3---
...
---vecN---

Die Zeilen der Matrix sind also transponierte Spaltenvektoren.

Jetzt suche ich aber das Minimum aus allen ersten Einträgen von vec1 bis vecN, das minumum als allen zweiten Einträgen von vec1 bis vecN usw. Das heisst, pro Spalte das Minimum und da hilft mir die Lambda von dir ja nicht weiter oder?

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

using namespace std;

int main() {
    vector<vector<double>> v = {
        { 11,12,5,14 },
        { 10,11,12,13 },
        { 17,23,42,3 }
    };

    for (size_t col = 0; col < 4; ++col) {
        cout << "Col " << col << " hat Minimum: "
             << min_element(v.begin(), v.end(),
                            [col](const vector<double> &a, const vector<double> &b) { return a[col] < b[col]; })
                    ->at(col)
             << '\n';
    }
}