ich hab ein Bottleneck in meiner Anwendung (sagt mir zumindest mein Profiler^^) bei meinem Algorithmus, welcher die "ähnlichsten Paare" aus zwei vectoren (bzw. sequentiellen Containern) suchen soll.

Ein Beispiel (die Container sind sortiert):

Input: 
a = 5, 7, 9 
b = 6, 10, 11, 13

Output:
c = -1, -1, -4

Die "ähnlichsten Paare" (also die mit geringster quadratischer Abweichung) wären hier:

5 und 6 -> Differenz = -1
9 und 10 -> Differenz = -1
7 und 11 -> Differenz = -4

Im output c sollen die Differenzen der ähnlichsten Paare gespeichert werden.

Mein bisheriger Algorithmus sieht so aus (noch nicht templatisiert etc.):

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

void find_minimum_index(std::vector<int> const &a, std::vector<int> const &b, int &index_a, int &index_b)
{
	int min_deviation = std::numeric_limits<int>::max();

	for (size_t i = 0; i < a.size(); ++i)
	{
		for (size_t j = 0; j < b.size(); ++j)
		{
			int cur_deviation = std::abs(a[i] - b[j]);
			if (cur_deviation < min_deviation)
			{
				min_deviation = cur_deviation;
				index_a = i;
				index_b = j;
			}
		}
	}
}

std::vector<int> most_common_pairs(std::vector<int> a, std::vector<int> b)
{
	std::vector<int> result;
	result.reserve(std::min(a.size(), b.size()));

	while (!a.empty() && !b.empty())
	{
		int index_a, index_b;
		find_minimum_index(a, b, index_a, index_b);

		result.push_back(a[index_a] - b[index_b]);

		a.erase(a.begin() + index_a);
		b.erase(b.begin() + index_b);
	}
	return result;
}

int main()
{
	std::vector<int> a = { 5, 7, 9 };
	std::vector<int> b = { 6, 10, 11, 13 };

	std::vector<int> c = most_common_pairs(a, b);

	for (auto const &item : c)
	{
		std::cout << item << '\n'; // Output: -1, -1, -4
	}
}

Kann man da noch was optimieren/verbessern? Die Funktion most_common_pairs wird halt extrem oft mit sehr langen vectoren als input Parametern aufgerufen, was ziemlich dauert...

7 und 6 ist "ähnlicher" als 7 und 11.

6 wurde schon im Schritt davor eleminiert, durch den Vergleich mit 5 (5 und 6 sind einander genauso ähnlich wie 7 und 6).

Nachdem ein Paar gebildet wurde wird dieses aus den vectoren a und b entfernt, daher bleibt als bestes Paar 7 und 11 übrig.

1 7
6 9

Ist die Lösung 7-6, 1-9 oder 1-6, 7-9?

Für beide Fälle gibt es bessere Ansätze wie deiner, aber ich mache mir nicht die Mühe, beide sauber aufzuschreiben.

Frage: Bei den Listen

1 7
6 9

Ist die Lösung 7-6, 1-9 oder 1-6, 7-9?

Meinst du die Listen jetzt vertikal oder horizontal gelesen? Ich gehe mal von horizontal aus, also

a = 1, 7
b = 6, 9

Lösung wäre dann entsprechend 7-6 und 1-9, also

c = 1, -8

parrybear schrieb:

Für beide Fälle gibt es bessere Ansätze wie deiner, aber ich mache mir nicht die Mühe, beide sauber aufzuschreiben.

Ok, und unsauber?
Komplexität ist ja momentan ungefähr O(n^3) (a und b sind meistens ziemlich gleich lang)... wäre schön wenn man das irgendwie drücken könnte.

Mein Vorschlag wäre alle Paare generieren, sortieren und der Reihe nach durchgehen.

std::vector<int> most_common_pairs(std::vector<int> a, std::vector<int> b)
{
  std::vector<std::tuple<int, std::size_t, std::size_t>> pairs;
  for (std::size_t i=0; i<a.size(); ++i)
    for (std::size_t j=0; j<b.size(); ++j)
      pairs.emplace_back(std::abs(a[i]-b[j]), i, j);
  std::sort(pairs.begin(), pairs.end());
  std::vector<bool> used_a(a.size());
  std::vector<bool> used_b(b.size());
  std::vector<int> result;
  for (auto& t : pairs) {
    int d, i, j;
    std::tie(d, i, j) = t;
    if (!used_a[i] && !used_b[j]) {
      result.push_back(d);
      used_a[i] = used_b[j] = true;
    }
  }
  return result;
}

Laufzeit ist O(n^2 log n).

Geht vielleicht noch besser, aber vielleicht reicht das ja schon?

1 4
3 5

sein?

Und was soll die Lösung bei

1 4
3 5

sein?

Optimalerweise 4-5 und 1-3, also

-1, -2

Mein Algorithmus macht das aber auch noch falsch merke ich gerade, das scheint noch komplizierter zu werden...

EDIT:

parrybear schrieb:

Mein Vorschlag wäre alle Paare generieren, sortieren und der Reihe nach durchgehen.

Erst jetzt gesehen, werd ich mir gleich mal anschauen, danke

was ist das genaue(!) guetekriterium, nach dem zwei potentielle loesungen verglichen werden sollen um die bessere loesung zu ermitteln?

Hier dürfte der Fall deutlich einfacher sein: Beide Listen sortieren und dann die kleinere in die größere matchen mittels dynamischem Programm. Vorher mal irgendwann beweisen, dass wenn a<b in Liste A und c<d in Liste B, dass dann ac und bd besser ist als ad und bc, die Paare also in beiden Listen sortiert vorliegen. Das schränkt den Suchraum deutlich ein, sodass man sich eigentlich nur noch merken muss bis zu welchem Element der langen Liste man schon vorgerückt ist.

Der Hauptunterschied zum TSP ist, dass man hier nicht fordert, dass die ausgewählten Verbindungen (Paare) einen zusammenhängenden Graphen ergeben... und das macht alles leichter.

Ja, wenn man eine Methode findet, die zeigt, das der zusammenhaengene Graph nicht die beste Loesung sein wird.

und warum bevorzugst du in parrybears beispiel die abstaende (1,-8) gegenueber der anderen loesung mit abstaenden (-2,-5)? die summe der absolut abstaende ist im zweiten fall (7) kleiner als im ersten (9), ebenso wie die summe der quadratischen abstaende (29 zu 65), die du im op mal erwaehnst.

Ja, das stimmt, dieses Problem hatte ich nicht bedacht...

Problem bei meinem jetzigen (und parrybears) Algorithmus ist, dass wenn es mehrere gleichgute Lösungen gibt es nicht egal ist welche man nimmt (wie in deinem Beispiel).

Das Ganze ist Teil einer Kostenfunktion für einen Optimierungsalgorithmus zur Auslegung von Bauteilen, deswegen ist mir das bis jetzt noch gar nicht aufgefallen (der Algorithmus optimiert schon, allerdings wahrscheinlich nicht so gut wie wenn der Algorithmus richtig wäre)...

Am besten wäre wohl wenn am Ende die Summe der Quadrate über den result vector minimal wäre. Allerdings darf ein einmal gebildetes Paar nicht weiter verwendet werden (sonst könnte man ja einfach alle Kombinationsmölichkeiten in O(n^2) erstellen und die n besten nehmen)... Weiß gerade nicht wie ich das lösen soll

Jester schrieb:

Der Hauptunterschied zum TSP ist, dass man hier nicht fordert, dass die ausgewählten Verbindungen (Paare) einen zusammenhängenden Graphen ergeben... und das macht alles leichter.

Ja, wenn man eine Methode findet, die zeigt, das der zusammenhaengene Graph nicht die beste Loesung sein wird.

Nein, es sagt niemand, dass die Lösung für ein einfacheres Problem nicht auch mal zufällig eine Lösung für ein schwierigeres Problem sein darf.

Hier tritt aber selbst dieser Fall nicht auf, da ja nur Paare gebildet werden und damit kein Knoten zweimal vorkommt -- also können auch keine Kreise entstehen.

Nein, es sagt niemand, dass die Lösung für ein einfacheres Problem nicht auch mal zufällig eine Lösung für ein schwierigeres Problem sein darf.

Ja, das stimmt. Ich hatte mir das so vorgestellt, das ich die Paare dann aneinanderhaenge und sich so ein Kreis ergibt, fuer den Fall das zufaelligerweise genau diese restlichen Kosten 0 waeren.

Wenn das gilt, löst es direkt das Problem wenn die Listen gleich lang sind, weil Du einfach nur sortieren musst und den kleinsten Eintrag aus A mit dem kleinsten Eintrag aus B paaren musst usw.

@happystudent: Versuch mal zu beweisen dass man Paare nicht verdrehen sollte. Also wenn ich a<b in Liste A und c<d in Liste B habe, dass dann die Paare ac und bd immer genauso gut oder besser als die Paarung ad und bc ist.

Ok. Sei

$a < b, c < d \text{ und } a,b,c,d \neq 0$

Dann folgt daraus für die Summe der Abstandsquadrate:

und damit ein Widerspruch zu unserer ursprünglichen Annahme dass a < b.
Die Bedingung ist somit nicht erfüllt und zwar für allgemeine a, b, c, d.

Hilft es vielleicht dass die vectoren streng monoton sind?

Und jetzt finde den Fehler. Tipp: was ist das Vorzeichen von (c-d)?

Hm, ungünstig ungeformt. Wie wärs damit:

was widerum ein Widerspruch wäre, da c < d gefordert war.

d \geq c\\
was widerum ein Widerspruch wäre, da c < d gefordert war.

Wenn c < d, ist d > c...

edit: mit anderen Worten, eigentlich hast Du die Aussage bewiesen. Es kommt nämlich eine Bedingung heraus, die nach Eingangsvoraussetzung erfüllt ist.

Wenn c < d, ist d > c...

Jester schrieb:

Wo genau findet sich der Widerspruch zwischen c<=d und c<d?

edit: mit anderen Worten, eigentlich hast Du die Aussage bewiesen. Es kommt nämlich eine Bedingung heraus, die nach Eingangsvoraussetzung erfüllt ist.

Oh verdammt, ihr habt recht

Gut, dann ist das jetzt bewiesen, aber das bringt ja nur was bei gleichlangen Listen, richtig? Weil meistens sind die Listen halt unterschiedlich lang (die Länge ist zwar ungefähr gleich, aber fast nie identisch).

OE sei A die längere Liste. Entweder A[1] spielt mit, und (A[1], B[1]) ist das erste Paar und du musst nur noch den Rest A[2...] und B[2...] prüfen, oder A[1] fliegt raus und du vergleichst A[2...] gegen B[1...]. Das ganze bricht ab, wenn A und B gleich lang sind, dann müssen alle Paare rein. Da in jedem Schritt A ein Element kürzer wird, bricht der Algorithmus auch schnell ab.

happystudent schrieb:

Das Ganze ist Teil einer Kostenfunktion für einen Optimierungsalgorithmus [...]

Meinst du nicht, dass die Kostenfunktion ein wesentlicher Teil des Problems ist, und du genau mit der mal rausrücken solltest? Und zwar am besten schon im Anfangspost!

Obiger Algorithmus funktioniert auch nur mit der Summe der quadratischen Abstände als Kostenfunktion, denn du hast ja eine Eigenschaft der quadratischen Abstände in deinem letzten Beweis genutzt, um zu diesem Algorithmus zu kommen.

Wenn du jetzt endlich mal mit der Kostenfunktion rausrückst und es dann nicht die Summe der quadratischen Abstände ist, war u. U. bisher alles für die Katz.

Wenn du jetzt endlich mal mit der Kostenfunktion rausrückst und es dann nicht die Summe der quadratischen Abstände ist, war u. U. bisher alles für die Katz.

Naja, also der Algorithmus ist eigentlich schon die Kostenfunktion. Man hat halt zwei unterschiedlich lange Vektoren, die möglichst "ähnlich" zueinander gemacht werden sollen.

Da sie unterschiedlich lang sind, läuft das in zwei Schritten: Zuerst werden die ähnlichsten Paare bestimmt. Das ergibt dann zwei gleich lange Vektoren, die auf klassische Art und Weise verglichen werden können und einen Kostenwert x liefern.

Im zweiten Schritt wird dann mittels einer Heuristik noch ein zusätzlicher Kostenwert y bestimmt, der berücksichtigt wie unterschiedlich die Länge der beiden Vektoren ist. Die Gesamtkosten ergeben sich dann als z = x + y. Am besten wäre nämlich, wenn die beiden Vektoren genau gleich lang wären und identische Einträge hätten.

Es handelt sich dabei um eine physikalisches Model, das so parametriert werden soll, dass die von ihm produzierten Outputs einem vom Benutzer vorgegebenen Wunsch-Output entsprechen (bei gleichem Input). Im Prinzip sieht das so aus:

input = user input 1 // Model input
x_set = user input 2 // Gewünschter Model output

while (error is big)
    p = determine new parameters // Irgendeine Optimierungsmethode
    x_cur = ModelFunction(p, input) // Output des Models mit den aktuellen Parametern p
    error = CalculateErrorBetween(x_cur, x_set) // Fehlerberechnung
endwhile

Problem ist eben dass die Länge des Outputs des Modells (also die Länge des Vektors x_cur ) abhängig von den Parametern p ist.

Mit der oben beschriebenen Methode funktioniert es in einigen Fällen schon ziemlich gut, in anderen aber schlecht bis gar nicht. Außerdem ist die Laufzeit sehr hoch.

So, ich hoffe das waren dann alle relevanten Infos. Letztendlich sollte das Grundproblem sich dadurch aber nicht ändern?

Das ergibt dann zwei gleich lange Vektoren, die auf klassische Art und Weise verglichen werden können

Und warum sagst du nicht einfach, wie du sie genau vergleichst? Das ist immerhin das entscheidende Kriterium und macht den Unterschied aus, ob der Algorithmus passt oder nicht. Ich hab zwar eine Kristallkugel, die mir zu "auf klassische Art und Weise" ein trübes Bild liefert, aber das tut doch nun wirklich nicht Not hier auf so nebulöse Angaben aufzubauen.

Im zweiten Schritt wird dann mittels einer Heuristik noch ein zusätzlicher Kostenwert y bestimmt, der berücksichtigt wie unterschiedlich die Länge der beiden Vektoren ist.

Eine Heuristik wovon? Von dem Kostenwert der unterschiedlich langen Listen? Wenn du direkt an den ran kommst, wozu der Umweg?

Mit der oben beschriebenen Methode funktioniert es in einigen Fällen schon ziemlich gut, in anderen aber schlecht bis gar nicht.

Was kommt bei einem Beispiel raus, bei dem es nicht gut funktioniert? Und woher weißt du, dass es nicht gut funktioniert hat?