Kann die Eindeutigkeit von Elementen in deterministischer linearer Zeit gelöst werden?

9

Betrachten Sie das folgende Problem:

Eingabe : Listet von ganzen Zahlen auf $X,Y$

Ziel : Bestimmen Sie, ob in beiden Listen eine Ganzzahl ist. $x$

Angenommen, beide Listen die Größe . Gibt es für dieses Problem einen deterministischen linearen Zeitalgorithmus? Mit anderen Worten, können Sie dieses Problem in -Zeit deterministisch lösen , ohne Zufälligkeit zu verwenden? $X,Y$ $n$ $O(n)$

Leider können Sie nicht davon ausgehen, dass die Listenelemente alle klein sind.

Ich kann sehen, wie man es in erwarteter Zeit mit einem zufälligen Algorithmus löst : Wähle zufällig eine 2-universelle Hash-Funktion , speichere die Elemente von in einer Hashtabelle (mit als Hash-Funktion) und schaue dann nach jedes Element von zu sehen, ob es in der Hashtabelle ist. Die erwartete Laufzeit beträgt . Ich kann jedoch nicht sehen, wie man einen deterministischen Algorithmus mit Laufzeit findet. Wenn Sie versuchen, dies zu derandomisieren und eine bestimmte Hash-Funktion zu korrigieren, gibt es eine Worst-Case-Eingabe, die dazu führt, dass diese Prozedur ausgeführt wird $O(n)$ $h$ $X$ $h$ $Y$ $O(n)$ $O(n)$ Zeit. Der beste deterministische Algorithmus, den ich finden kann, besteht darin, die Werte zu sortieren, aber das ist keine lineare Zeit. Können wir eine lineare Laufzeit erreichen? $\Theta(n^2)$

Ich kann auch sehen, wie man es in linearer Zeit löst, wenn man annimmt, dass alle Listenelemente Ganzzahlen im Bereich (im Grunde genommen zählen Sortieren) - aber ich bin daran interessiert, was im Allgemeinen passiert Fall, wenn wir das nicht annehmen können. $[1,n]$

Wenn die Antwort vom Berechnungsmodell abhängt, fällt mir das RAM-Modell ein, aber ich würde mich für Ergebnisse für jedes vernünftige Berechnungsmodell interessieren. Mir sind die unteren Grenzen von für Entscheidungsbaumalgorithmen für die Eindeutigkeit von Elementen bekannt , aber dies ist nicht endgültig, da wir manchmal lineare Zeitalgorithmen finden können, selbst wenn ein gebunden ist das Entscheidungsbaummodell. $\Omega(n \log n)$ $\Omega(n \log n)$

algorithms complexity-theory lower-bounds

— DW
quelle

Hashtabellen sind O (n log n), da Sie Kollisionen behandeln müssen.

— Thorbjørn Ravn Andersen

1

@ ThorbjørnRavnAndersen, ich sehe nicht, woher du das bekommst. Die Verwendung von 2-universellen Hash-Funktionen und einer Hash-Tabelle mit geeigneter Größe stellt sicher, dass die Anzahl der Hash-Kollisionen minimal ist (mit hoher Wahrscheinlichkeit), sodass ich glaube, dass eine Laufzeit von

erreichbar ist. Ich bin mir nicht sicher, woher du

hast . Wenn Sie nichts Besonderes tun (z. B. 2-Universal-Hashing verwenden), ist der schlimmste Fall aufgrund von Kollisionen

.

O (n)

$O(n)$

O (n \lg n)

$O(n \lg n)$

O (n^{2})

$O(n^2)$

— DW

Der Teufel steckt im Detail, hier ein "entsprechend großer Hash-Tisch". Dies kann sich als ziemlich groß herausstellen, wenn Sie keine Kollisionen möchten. Das typische n-log-n ist (wenn ich mich richtig erinnere) für die Behandlung der Hash-Funktionskollisionen mit einer Liste.

— Thorbjørn Ravn Andersen

1

@ ThorbjørnRavnAndersen Die erwartete Anzahl von Schlüsseln, die derselben Adresse zugeordnet sind, ist konstant (für Tabellen, die nicht überladen sind), sodass die Art der Kollisionsauflösung keine Rolle spielt. Siehe auch hier .

passt zum ungünstigsten Fall, wenn Sie (externe) ausgeglichene BSTs anstelle von Listen verwenden.

O (n \log n)

$O(n \log n)$

— Raphael

1

Sie können das Problem in linearer Zeit lösen, wenn Sie über genügend Speicher verfügen, um für jeden möglichen Wert in X und Y ein Bit zu haben. Dies führt zu keinen Einschränkungen bei der Reihenfolge von X und Y.

Anfangs sind alle Bits nicht gesetzt.
Durch X iterieren und das entsprechende Bit setzen.
Iterieren Sie über Y und prüfen Sie, ob das entsprechende Bit oben gesetzt wurde.

— Thorbjørn Ravn Andersen
quelle

2

Leider können Sie nicht davon ausgehen, dass alle Ganzzahlen klein sind (Sie können nicht davon ausgehen, dass sie klein genug sind, damit dieser Algorithmus funktioniert). Im allgemeinen Fall ist die Laufzeit dieses Algorithmus in der Bitlänge der Listenelemente exponentiell. Trotzdem danke!

— DW

Nennen wir es dann ein "Bit-Array geeigneter Größe". Auch linear in der Bitlänge entspricht log-n. Ist es Ihnen ernst damit, die Log-n-Leistung ohne Einschränkungen oder Voraussetzungen für die Eingabedaten zu erreichen?

— Thorbjørn Ravn Andersen

2

@ ThorbjørnRavnAndersen Der Raum ist exponentiell in der Bitlänge (Sie müssen alle möglichen Werte abbilden) und die Zeit ist linear in der Gesamtlistengröße (Sie müssen alle Werte in beiden Listen betrachten). In der Bitlänge ist nichts linear.

— Charchargin

0

Da Sie sagen, dass die beiden Listen Ganzzahlen enthalten, können wir wahrscheinlich eine Radix-Sortierung für die beiden Listen ausführen und dann eine lineare Suche durchführen, bei der die beiden Listen nach äquivalenten Elementen verglichen werden.

— anirudh
quelle

4

Dies funktioniert nur, wenn die Größe der Zahlen begrenzt ist.

— Luke Mathieson

aber ich dachte, dass eine hohe Größe nur für das Zählen der Sortierung ein Problem sein wird, und für die Radix-Sortierung können wir einen Radix auswählen, der hoch genug ist, um dieses Problem zu lösen ... bitte lassen Sie mich wissen, was ich hier vermisse

— anirudh

Was ist, wenn eine der Zahlen 2 ^ (2 ^ 128) ist?

— MiniBill

@anirudh, aber dann haben Sie einen anderen Algorithmus für verschiedene Eingabegrößen - Sie benötigen jedes Mal ein größeres Alphabet, wenn Sie den Radix erhöhen. Sie exportieren nur die Komplexität der zunehmenden Größe, um die Alphabetgröße zu erhöhen. Natürlich ist dies auch nur theoretisch möglich. Ich glaube nicht, dass Sie mit viel Hardware ändern können, in welcher Basis Zahlen dargestellt werden (wir können an den Ein- und Ausgabeenden so tun, als ob es sich um (meistens) Binärdaten handelt ).

— Luke Mathieson

0

$\mathcal O\left(n\cdot \overline m\right)$ $\overline m$

— Realz Slaw
quelle

O (n)

$O(n)$

O (n \cdot \overbar m)

$O(n \cdot \overbar{m})$

w

$w$

m

$m$

\bar{m}

$\overline{m}$

O (n)

$\mathcal O\left(n\right)$

w

$w$

w

$w$

n

$n$

m

$m$

n

$n$

n^{m}

$n^m$

-1

$O(n\log n)$

— Omer Gold
quelle

1

Die Frage ist ziemlich explizit nach linearer deterministischer Zeit, nicht nach logarithmisch linear. Um festzustellen, ob (nicht auf welchem Wert) set nur eindeutige Elemente enthält, können Sie schneller als loglinear arbeiten.

— Böse

1

Ω (n \log n)

$\Omega(n\log n)$

1

Ω (n \log n)

$\Omega(n \log n)$

Ω (n \log n)

$\Omega(n \log n)$

O (n \log \log n)

$O(n \log \log n)$

O (n \log n)

$O(n \log n)$

Ω (n \log n)

$\Omega(n \log n)$