Lösen eines Number-Hopper-Labyrinths

Mein 8-Jähriger hat sich gelangweilt, konventionelle Labyrinthe zu erstellen, und hat Varianten entwickelt, die so aussehen:

Number Hopper Sample

Die Idee ist, mit x zu beginnen und über die normalen Regeln nach o zu gelangen. Außerdem können Sie von einer beliebigen Ganzzahl zu einer beliebigen anderen Ganzzahl "springen" , müssen jedoch bezahlen Dollar für das Privileg. Das Ziel ist es, das Labyrinth mit den geringsten Kosten zu lösen. Im obigen Beispiel könnten wir von x nach o über x-14-18-27-28-o zu Kosten von 5 gehen, aber es ist billiger, nur für x-13-11-9-8-29-28-o zu gehen 4. $a$ $b$ $|a-b|$

Hier ist meine Frage: Was ist die beste Lösung (in Bezug auf die asymptotische Laufzeit), die Sie zur Lösung dieses Problems finden können? Sie können vernünftige Annahmen über das Eingabeformat treffen.

Hinweis: Ich verwende hier das "Puzzles" -Tag, weil ich eine -Antwort im Auge habe, aber ich bin mir nicht sicher, ob es optimal ist, und möchte sehen, ob jemand anderes meine Lösung verbessern kann. (Hier ist die Anzahl der ganzen Zahlen im Labyrinth.) $O(n^2)$ $n$

ds.algorithms optimization puzzles

— Fixee
quelle

Wir bitten Ihr Kind, solche kreativen und mathematischen Rätsel zu schaffen!

— Bejot

@bbejot Du solltest einige der Sachen sehen, die er mich fragt ... manchmal kann ich seine Fragen nicht beantworten. ZB math.stackexchange.com/questions/33094/…

— Fixee

Ich bin mir nicht sicher, ob Ihre Kostenkalkulation korrekt ist. x-14-18-27-28-o sollte

kosten und x-13-11-9-8-29-28-o sollte

kosten .

4 + 9 + 1 = 14

$4 + 9 + 1 = 14$

2 + 2 + 1 + 21 + 1 = 27

$2 + 2 + 1 + 21 + 1 = 27$

— Dave Clarke

@ Dave nicht alle Übergänge sind Sprünge. Wir könnten 'ab' für Sprünge schreiben (die Kosten von

) und 'a-> b' für das Gehen in der Grafik von a nach b (was Kosten von

), was nur erlaubt ist, wenn Sie sind erreichbar, ohne eine Mauer im Labyrinth zu durchbrechen. In dieser Notation haben wir x-> 14-18-> 27-28-> o und Kosten von 5 und x-> 13-11-> 9-8-> 29-28-> o. Ich denke, Fixee hat diese Notation nicht eingeführt, weil sie überflüssig ist: Es gibt keinen Grund, zweimal zu hüpfen, und so wechseln sich Hüpfen und Gehen im Labyrinth ab.

| a - b |

$|a - b|$

0

$0$

— Artem Kaznatcheev

Dies ist ein ausgezeichnetes Hausaufgabenproblem!

— Jeffs

Antworten:

Sie können dies mit einer Variation des Dijkstra-Algorithmus in lösen . Es kann passieren, dass wir nicht alle Entfernungsaktualisierungen durchführen, wenn wir einen neuen Knoten besuchen. Wenn wir einen Knoten besuchen , müssen wir nur die Entfernungen von allem, was von nach 0 gehen kann, aktualisieren und die Entfernungen zu den beiden Knoten und mit den nächstgelegenen Werten für kleiner und größer als sind , aktualisieren wurde noch abgeholt. $O(n\log n)$ $y$ $y$ $y_-$ $y_+$ $y$ $y$

Diese Aktualisierungen reichen aus, um zu gewährleisten, dass der Heap das minimale Element zurückgibt, da jeder nächste Knoten, zu dem Sie springen, numerisch direkt über oder direkt unter einem bereits besuchten Knoten liegen muss.

Jeder Knoten wird höchstens einmal auf 0 aktualisiert (wenn alle Knoten ohne Abstand aus der Warteschlange entfernt werden, um ein quadratisches Verhalten zu vermeiden), und jedes Mal, wenn wir einen Knoten hinzufügen, werden nur O (1) andere Aktualisierungen durchgeführt. Das Ermitteln der Werte und kann in linearer Zeit erfolgen, wenn wir auch eine geordnete doppelt verknüpfte Liste aller Knoten führen, sortiert nach ihren ganzzahligen Werten. Das Erstellen dieser doppelt verknüpften Liste dauert , und schließlich dauert das Aktualisieren von und das Abrufen vom Heap für eine Gesamtlaufzeit von $y_-$ $y_+$ $O(n \log n)$ $O(n)$ $O(n \log n)$ $O(n \log n)$

— Dave
quelle

Dies kann wahrscheinlich ein wenig durch Sortier- und Prioritätswarteschlangen verbessert werden, die auf Ganzzahlen spezialisiert sind, aber Sie können nichts Besseres tun als die Ganzzahlensortierung, wie die folgende Reduzierung zeigt: Wenn wir eine Liste von Ganzzahlwerten

, setze

auf das doppelte Minimum und

auf das doppelte Maximum. Erstellen Sie eine Region mit den Werten

und

für einander

. Die beste Lösung durchläuft jede Region in sortierter Reihenfolge nach

und erzeugt so eine Sortierung der

x_{1}, \dots, x_{n}

$x_1,\ldots,x_n$

x

$x$

o

$o$

2 x_{i}

$2x_i$

2 x_{i} + 1

$2x_i+1$

x_{i}

$x_i$

x_{i}

$x_i$

Werte.

x_{i}

$x_i$

— Dave

Dave hat recht, dies kann auf

reduziert werden, indem nur

und

aktualisiert werden . Anstatt jeden Knoten in einer Region mit jedem anderen Knoten in der Region zu verbinden, müssen sie nur mit 1 oder 2 anderen Knoten in der Region verbunden werden (um einen Pfad zu erstellen). Somit hat jeder Knoten nur bis zu 4 Kanten. Dann kann der Dijkstra-Algorithmus (mit einer Warteschlange mit minimaler Priorität) angewendet werden, wobei

Zeit gewährt wird.

O (n l g n)

$O(n lg n)$

y_{+}

$y_+$

y_{-}

$y_-$

O (n l g n)

$O(n lg n)$

— Bejot

O (n \log \log n)

$O(n \log\log n)$

O (n)

$O(n)$

$O(n^2)$

Es erscheint natürlich, dies mit einem speziellen Startknoten (x) und Endknoten (0) in das Problem des kürzesten Pfades umzuwandeln. Es würde auch einen anderen Knoten für jede der Nummern geben. Sowohl x als auch 0 haben Kanten der Gewichtung 0 für alle im Labyrinth erreichbaren Nummernknoten. Alle Nummernknoten sind entweder mit dem Gewicht 0 (wenn die Nummern im Labyrinth erreichbar sind) oder mit der Differenz zwischen den Nummern (wenn nicht im Labyrinth erreichbar) verbunden.

$O(n^2)$ $n^2$ $O(n^2)$

— bbejot
quelle

O (n^{2})

$O(n^2)$

O (n^{2} \lg n)

$O(n^2 \lg n)$

r

$r$

O (r^{2})

$O(r^2)$

O (n \log n)

$O(n\log n)$

O (r^{2} + n \log n)

$O(r^2 + n\log n)$

Ω (n \log n)

$\Omega(n\log n)$

Ω (n^{2})

$\Omega(n^2)$