it-swarm.com.de

Was würde dazu führen, dass ein Algorithmus O (log log n) -Komplexität hat?

Diese frühere Frage behandelt einige der Faktoren, die dazu führen können, dass ein Algorithmus eine O (log n) -Komplexität aufweist.

Was würde dazu führen, dass ein Algorithmus die Zeitkomplexität O (log log n) hat?

93
templatetypedef

O (log log n) -Begriffe können an verschiedenen Stellen angezeigt werden, es gibt jedoch normalerweise zwei Hauptrouten, die zu dieser Laufzeit eintreffen.

Schrumpfen um eine Quadratwurzel

Wie in der Antwort auf die verknüpfte Frage erwähnt, besteht eine übliche Möglichkeit für einen Algorithmus, die Zeitkomplexität O (log n) aufzuweisen, darin, dass dieser Algorithmus wiederholt die Größe der Eingabe bei jeder Iteration um einen konstanten Faktor verringert. Ist dies der Fall, muss der Algorithmus nach O (log n) -Iterationen enden, da der Algorithmus nach O (log n) -Divisionen durch eine Konstante die Problemgröße auf 0 oder 1 verkleinern muss Die binäre Suche hat die Komplexität O (log n).

Interessanterweise gibt es eine ähnliche Möglichkeit, die Größe eines Problems zu verkleinern, das Laufzeiten der Form O (log log n) ergibt. Anstatt die Eingabe auf jeder Ebene in zwei Hälften zu teilen, was passiert, wenn wir die Quadratwurzel der Größe nehmen auf jeder Ebene?

Nehmen wir zum Beispiel die Nummer 65.536. Wie oft müssen wir dies durch 2 teilen, bis wir auf 1 kommen? Wenn wir das tun, bekommen wir

  • 65.536/2 = 32.768
  • 32.768/2 = 16.384
  • 16,384/2 = 8,192
  • 8,192/2 = 4,096
  • 4,096/2 = 2,048
  • 2,048/2 = 1,024
  • 1.024/2 = 512
  • 512/2 = 256
  • 256/2 = 128
  • 128/2 = 64
  • 64/2 = 32
  • 32/2 = 16
  • 16/2 = 8
  • 8/2 = 4
  • 4/2 = 2
  • 2/2 = 1

Dieser Prozess dauert 16 Schritte und es ist auch der Fall, dass 65.536 = 216.

Aber wenn wir auf jeder Ebene die Quadratwurzel ziehen, bekommen wir

  • 65.536 = 256
  • √256 = 16
  • √16 = 4
  • √4 = 2

Beachten Sie, dass es nur vier Schritte dauert, bis 2 erreicht ist. Warum ist das so? Nun, lassen Sie uns diese Sequenz in Zweierpotenzen umschreiben:

  • 65.536 = 216 = (216)1/2 = 28 = 256
  • √256 = √28 = (28)1/2 = 24 = 16
  • √16 = √24 = (24)1/2 = 22 = 4
  • √4 = √22 = (22)1/2 = 21 = 2

Beachten Sie, dass wir die Sequenz 2 befolgt haben16 → 28 → 24 → 22 → 21. Bei jeder Iteration halbieren wir den Exponenten der Zweierpotenz. Das ist interessant, weil dies auf das zurückgeht, was wir bereits wissen - Sie können die Zahl k nur in die Hälfte von O (log k) teilen, bevor sie auf Null fällt.

Nehmen Sie also eine beliebige Zahl n und schreiben Sie sie als n = 2k. Jedes Mal, wenn Sie die Quadratwurzel von n ziehen, halbieren Sie den Exponenten in dieser Gleichung. Daher können nur O (log k) Quadratwurzeln angewendet werden, bevor k auf 1 oder weniger fällt (in diesem Fall fällt n auf 2 oder weniger). Da n = 2kDies bedeutet, dass k = log2 n, und daher ist die Anzahl der Quadratwurzeln O (log k) = O (log log n). Wenn es einen Algorithmus gibt, der das Problem wiederholt auf ein Teilproblem der Größe reduziert, die die Quadratwurzel der ursprünglichen Problemgröße ist, wird dieser Algorithmus daher nach O (log log n) Schritten beendet.

Ein Beispiel aus der Praxis ist die Datenstruktur van Emde Boas-Baum (vEB-Baum). Ein vEB-Baum ist eine spezialisierte Datenstruktur zum Speichern von Ganzzahlen im Bereich von 0 ... N - 1. Sie funktioniert wie folgt: Der Wurzelknoten des Baums enthält √N Zeiger, die den Bereich von 0 ... N - aufteilen. 1 in √N Eimer, die jeweils einen Bereich von ungefähr √N ganzen Zahlen enthalten. Diese Buckets werden dann intern in √ (√ N) Buckets unterteilt, von denen jedes ungefähr √ (√ N) Elemente enthält. Um den Baum zu durchlaufen, beginnen Sie am Stamm, bestimmen, zu welchem ​​Bucket Sie gehören, und fahren dann rekursiv mit dem entsprechenden Teilbaum fort. Aufgrund der Art und Weise, wie der vEB-Baum aufgebaut ist, können Sie in O(1) Zeit festlegen, in welchen Teilbaum Sie absteigen möchten. Nach O (log log N) Schritten gelangen Sie zum unteren Ende Entsprechend dauern Suchvorgänge in einem vEB-Baum nur O (log log N).

Ein weiteres Beispiel ist der Hopcroft-Fortune-Algorithmus für das nächste Punktepaar . Dieser Algorithmus versucht, die zwei nächsten Punkte in einer Sammlung von 2D-Punkten zu finden. Es funktioniert, indem ein Gitter von Eimern erstellt und die Punkte auf diese Eimer verteilt werden. Wenn zu irgendeinem Zeitpunkt im Algorithmus ein Bucket mit mehr als √N Punkten gefunden wird, verarbeitet der Algorithmus diesen Bucket rekursiv. Die maximale Tiefe der Rekursion ist daher O (log log n), und anhand einer Analyse des Rekursionsbaums kann gezeigt werden, dass jeder Layer im Baum O(n) funktioniert beträgt die Gesamtlaufzeit des Algorithmus O (n log log n).

O (log n) Algorithmen für kleine Eingaben

Es gibt einige andere Algorithmen, die O-Laufzeiten (log log n) mithilfe von Algorithmen wie der binären Suche nach Objekten der Größe O (log n) erzielen. Zum Beispiel führt die Datenstruktur x-fast trie eine binäre Suche über die Ebenen in einem Baum der Höhe O (log U) durch, sodass die Laufzeit für einige ihrer Operationen O (log log U) ist. . Das zugehörige y-fast trie ruft einige seiner O-Laufzeiten (log log U) ab, indem es ausgeglichene BSTs von O-Knoten (log U) verwaltet, sodass Suchen in diesen Bäumen in der Zeit O (log log) ausgeführt werden können U). Die Tangobaum und verwandten Multisplay-Baum Datenstrukturen erhalten in ihren Analysen einen O-Term (log log n), da sie Bäume verwalten, die jeweils O-Items (log n) enthalten .

Andere Beispiele

Andere Algorithmen erreichen die Laufzeit O (log log n) auf andere Weise. Interpolation search hat erwartet, dass die Laufzeit O (log log n) eine Zahl in einem sortierten Array findet, aber die Analyse ist ziemlich aufwändig. Letztendlich zeigt die Analyse, dass die Anzahl der Iterationen gleich der Anzahl k ist, so dass n ist2-k ≤ 2, für welche log log n die richtige Lösung ist. Einige Algorithmen, wie der Cheriton-Tarjan MST-Algorithmus , erreichen eine Laufzeit mit O (log log n), indem sie ein komplexes eingeschränktes Optimierungsproblem lösen.

Hoffe das hilft!

192
templatetypedef

Ein Weg, den Faktor O (log log n) in der Zeitkomplexität zu sehen, ist die Aufteilung, wie in der anderen Antwort erläutert, aber es gibt einen anderen Weg, diesen Faktor zu sehen, wenn wir einen Handel zwischen Zeit und Raum/Zeit machen wollen und Näherung/Zeit und Härte/... von Algorithmen und wir haben einige künstliche Iteration auf unserem Algorithmus.

Zum Beispiel hat SSSP (Single Source Shortest Path) einen O(n) Algorithmus für planare Graphen, aber vor diesem komplizierten Algorithmus gab es einen viel einfacheren Algorithmus (aber immer noch ziemlich schwierig) für die Laufzeit O (n log log n), die Grundlage des Algorithmus ist wie folgt (nur eine sehr grobe Beschreibung, und ich würde anbieten, das Verständnis dieses Teils zu überspringen und den anderen Teil der Antwort zu lesen):

  1. teilen Sie das Diagramm mit einer gewissen Einschränkung in die Teile der Größe O (log n/(log log n)).
  2. Angenommen, jeder der erwähnten Teile ist Knoten in dem neuen Graphen G ', dann berechne SSSP für G' in der Zeit O (| G '| * log | G' |) ==> hier, weil | G '| = O (| G | * log log n/log n) wir können den Faktor (log log n) sehen.
  3. Berechne SSSP für jeden Teil: wieder, weil wir O (| G '|) Teil haben und wir können SSSP für alle Teile in der Zeit | n/logn | berechnen * | log n/log logn * log (logn/log log n).
  4. gewichte aktualisieren, dieser Teil kann in O (n) durchgeführt werden. Für weitere Details diese Vorlesungsunterlagen sind gut.

Aber mein Punkt ist, hier wählen wir die Division der Größe O (log n/(log log n)). Wenn wir andere Divisionen wie O (log n/(log log n) ^ 2) wählen, läuft das möglicherweise schneller und bringt ein anderes Ergebnis. Ich meine, in vielen Fällen (wie in Näherungsalgorithmen oder randomisierten Algorithmen oder Algorithmen wie SSSP wie oben), wenn wir über etwas iterieren (Teilprobleme, mögliche Lösungen, ...), wählen wir die Iterationszahl, die dem Handel damit entspricht wir haben (Zeit/Raum/Komplexität des Algorithmus/konstanter Faktor des Algorithmus, ...). Vielleicht sehen wir in echten Algorithmen kompliziertere Dinge als "log log n".

3
Saeed Amiri