Résoudre un labyrinthe de nombres

Mon fils de 8 ans s'est ennuyé à créer des labyrinthes conventionnels et a commencé à créer des variantes qui ressemblent à ceci:

Échantillon de trémie

L'idée est de partir de x et d'atteindre o via les règles normales. De plus, vous pouvez "sauter" de tout entier à tout autre entier , mais vous devez payerdollars pour le privilège. Le but est de résoudre le labyrinthe au moindre coût. Dans l'exemple ci-dessus, nous pourrions passer de x à o via x-14-18-27-28-o au coût 5, mais il est moins cher de passer x-13-11-9-8-29-28-o pour seulement 4. $a$ $b$ $|a-b|$

Voici donc ma question: quelle est la meilleure solution (en termes de temps de fonctionnement asymptotique) à laquelle vous pouvez penser pour résoudre ce problème? Vous pouvez faire des hypothèses raisonnables sur le format d'entrée.

Remarque: J'utilise la balise "puzzles" ici parce que j'ai une réponse en tête, mais je ne suis pas sûr qu'elle soit optimale et j'aimerais voir si quelqu'un d'autre peut améliorer ma solution. (Ici est le nombre d'entiers dans le labyrinthe.) $O(n^2)$ $n$

ds.algorithms optimization puzzles Fixee
la source

Accessoires à votre enfant pour créer de tels puzzles créatifs et mathématiques!

bbejot

@bbejot Vous devriez voir certaines des choses qu'il me demande ... parfois je ne peux pas répondre à ses questions. Par exemple, math.stackexchange.com/questions/33094/...~~V~~singular~~3rd

Fixee

Je ne suis pas sûr que vos calculs de coûts soient corrects. x-14-18-27-28-o devrait coûter et x-13-11-9-8-29-28-o devrait coûter .

4 + 9 + 1 = 14

$4 + 9 + 1 = 14$

2 + 2 + 1 + 21 + 1 = 27

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

Dave Clarke

@Dave toutes les transitions ne sont pas des sauts. Nous pourrions écrire 'ab' pour les sauts (qui ont un coût de ) et 'a-> b' pour marcher dans le graphique de a à b (qui a un coût de ), ce qui n'est autorisé que si ils sont accessibles sans casser un mur dans le labyrinthe. Dans cette notation, nous avons x-> 14-18-> 27-28-> o et un coût de 5 et x-> 13-11-> 9-8-> 29-28-> o. Je mince Fixee n'a pas introduit cette notation car elle est redondante: il n'y a aucune raison de sauter deux fois et donc les sauts et les promenades dans le labyrinthe alterneront.

| a - b |

$|a - b|$

0

$0$

Artem Kaznatcheev

C'est un excellent problème de devoirs!

Jeffε

Réponses:

Vous pouvez résoudre ce problème en utilisant une variante de l'algorithme de Dijkstra. Nous pouvons éviter de ne pas effectuer toutes les mises à jour de distance lorsque nous visitons un nouveau nœud. Si nous visitons un nœud , nous devons seulement mettre à jour les distances de tout ce qui peut être parcouru de à 0, et mettre à jour les distances aux deux nœuds et avec les valeurs les plus proches de inférieures et supérieures à qui ne l'ont pas été encore choisi. $O(n\log n)$ $y$ $y$ $y_-$ $y_+$ $y$ $y$

Ces mises à jour sont suffisantes pour garder le tas renvoyant l'élément minimum car tout nœud le plus proche vers lequel vous sautez doit avoir été numériquement juste au-dessus ou juste en dessous d'un nœud déjà visité.

Chaque nœud est mis à jour à 0 au plus une fois (si nous sortons tous les nœuds à distance nulle de la file d'attente pour éviter un comportement quadratique), et chaque fois que nous ajoutons un nœud, nous ne faisons O (1) que d'autres mises à jour. Trouver les valeurs et peut être fait en temps linéaire si nous gardons également une liste ordonnée à double liaison de tous les nœuds, triée par leurs valeurs entières. La création de cette liste à double liaison prend du temps , et enfin les mises à jour et les sauts du tas prennent du temps , pour un temps d'exécution total de $y_-$ $y_+$ $O(n \log n)$ $O(n)$ $O(n \log n)$ $O(n \log n)$

Dave
la source

Cela peut probablement être un peu amélioré en utilisant le tri et les files d'attente prioritaires qui sont spécialisés pour les entiers, mais vous ne pouvez pas faire mieux que le tri des entiers, comme le montre la réduction suivante: si nous avons une liste de valeurs entières

, définissez

pour être deux fois le minimum de ces derniers et

pour être deux fois le maximum. Créez une région avec des valeurs

pour l'autre

. La meilleure solution passe par chaque région dans l'ordre trié par

, et produit ainsi un tri des

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$

valeurs.

x_{i}

$x_i$

Dave

Dave a raison, cela peut être réduit à

en ne mettant à jour que

. De plus, au lieu de connecter chaque nœud d'une région à tous les autres nœuds de la région, ils doivent uniquement être connectés à 1 ou 2 autres nœuds de la région (en créant un chemin). Ainsi, chaque nœud n'a que jusqu'à 4 bords. Ensuite, l'algorithme de Dijkstra (avec une file d'attente prioritaire min) peut être appliqué en accordant le temps

O (n l g n)

$O(n lg n)$

y_{+}

$y_+$

y_{-}

$y_-$

O (n l g n)

$O(n lg n)$

bbejot

@bbejot: Mais si c'est le cas, la file d'attente prioritaire intégrale de Thorup n'améliore-t-elle pas le temps d'exécution à

, ou même à

avec une technique de bucketing supplémentaire dans la situation non dirigée?

O (n \log \log n)

$O(n \log\log n)$

O (n)

$O(n)$

Hsien-Chih Chang 張顯之

Je pense que pourrait être le meilleur que vous puissiez obtenir. $O(n^2)$

Il semble naturel de convertir cela en un problème de chemin le plus court avec un nœud de départ spécial (x) et un nœud de fin (0). Il y aurait également un autre nœud pour chacun des nombres. Les deux x et 0 ont des bords de poids 0 à tous les nœuds numériques qui sont accessibles dans le labyrinthe. Tous les nœuds numériques sont connectés soit avec un poids 0 (si les nombres sont accessibles en labyrinthe), soit avec la différence entre les nombres (si ce n'est pas le cas avec le labyrinthe).

Le chemin le plus court dans ce graphique ne peut pas être résolu en moins de car le graphique a à peu près arêtes et, dans le pire des cas, il faudrait voir chaque cas une fois. En tant que tel, l'algorithme de Dijkstra'a pour le chemin le plus court prend du temps et est optimal dans le pire des cas. $O(n^2)$ $n^2$ $O(n^2)$

bbejot
la source

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)$