Puzzle d'entrevue sur les déplacements sur un segment de ligne

Sur une ligne numérique de longueur M, où 0 < M <= 1,000,000,000vous avez donné N( 1 < N <= 100,000) des paires entières de points. Dans chaque paire, le premier point représente l'endroit où se trouve actuellement un objet et le deuxième point représente l'endroit où un objet doit être déplacé. (Gardez à l'esprit que le secondpoint peut être plus petit que le first).

Supposons maintenant que vous commencez au point 0et que vous disposez d'un chariot pouvant contenir un 1objet. Vous souhaitez déplacer tous les objets de leurs positions initiales à leurs positions finales respectives tout en parcourant la moindre distance le long de la ligne numérique ( pas de déplacement). Vous devez vous retrouver sur le point M.

Maintenant, j'ai essayé de réduire ce problème à un problème plus simple. Pour être honnête, je ne peux même pas penser à une solution de force brute ( éventuellement gourmande). Cependant, ma première pensée a été de dégénérer un mouvement vers l'arrière en deux mouvements vers l'avant, mais cela ne semble pas fonctionner dans tous les cas.

J'ai dessiné ces 3exemples de cas de test ici:

La réponse au premier test est 12. Tout d'abord, vous prenez l' redarticle au point 0. Ensuite, vous vous déplacez au point 6(distance = 6), déposez l' redélément temporairement, puis ramassez l' greenélément. Ensuite, vous vous déplacez au point 5(distance = 1) et déposez l' greenélément. Ensuite, vous revenez au point 6(distance = 1) et ramassez l' redélément que vous avez déposé, vous déplacez au point 9 (distance = 3), puis vous déplacez au point 10(distance = 1) pour terminer la séquence.

La distance totale parcourue était 6 + 1 + 1 + 3 + 1 = 12, qui est la distance minimale possible.

Les deux autres cas ont des réponses 12, je crois. Cependant, je ne trouve pas de règle générale pour le résoudre.

Quelqu'un a une idée?

1. Si vous êtes vide, commencez à vous déplacer vers la droite.

2. Chaque fois que vous atteignez un objet et que vous êtes vide, ramassez-le (duh) et avancez vers sa destination.

3. Chaque fois que vous atteignez un objet aet que vous le portez déjà b, choisissez toujours celui des objets qui a la destination numériquement la plus petite (la plus à gauche).

4. Si vous n'êtes pas encore à M, revenez à l'étape 1.

Ceci est optimal: le seul endroit où vous avez un vrai choix est à l'étape 3. La gestion de la destination la plus à gauche vous garantit qu'au moment où vous aurez envoyé les deux objets, vous serez le plus à droite possible.

Pourquoi cette question se trouve-t-elle sur programmers.sx? Oui, "question d'entrevue", mais c'est juste une belle énigme.

PS. En termes d'implémentation, tout ce dont vous avez besoin est la liste des tâches (les paires entières de points) triées par position d'origine.

Supposons que ces mouvements vous soient donnés, (a, b), (c, d), (e, f), ...la distance minimale à parcourir est abs(b - a) + abs(d - c) + abs(f - e) + ...la distance réelle que vous parcourez abs(b - a) + abs(c - b) + abs(d - c) + abs(e - d) + ....
Fondamentalement, étant donné un tableau de mouvements, le point est de minimiser la fonction de «distance de déplacement» en échangeant des éléments autour. Si vous considérez une combinaison particulière comme un nœud et toutes les combinaisons que vous pouvez en atteindre comme des arêtes, vous pouvez utiliser l'un des nombreux algorithmes de recherche de graphiques autour desquels une heuristique est utilisée. Un exemple est la recherche de faisceau .

Peut-être que je comprends mal le problème, mais qu'en est-il des éléments suivants:

1. Trier les paires par le premier numéro de la paire qui est l'emplacement actuel
2. Déplacez-vous le long des éléments de permutation de ligne à leur emplacement approprié (vous avez une variable temporaire)

Le fait qu'il soit trié garantit que vous n'allez pas dans les deux sens pour les placer au bon endroit (que la ligne soit représentée sous forme de tableau ou de liste)

Mettre à jour après le commentaire @templatetypedef:
Utilisez un HashTablepour stocker toutes les paires. Utilisez l'emplacement actuel de chaque paire comme clé d'index.
Utilisez un deuxième index sur les paires.

 1. Get next pair according to index from the line.
 2. If current pair exists in hashtable then place element to its target location.  
    2.a Remove pair from hashtable.  
    2.b Make current pair the target location. Then go to step 1  
 ELSE 
        Increment current index until you get a pair present in the hashtable. Go to step 2  

Mon penchant pour un algorithme essentiellement gourmand:

Construisez une liste de points à déplacer. Étant donné que l'optimisation ne fait pas partie du problème requis, je ne vais pas m'inquiéter de l'organiser.

while !Done
    if CartIsEmpty()
        FindClosestObjectToMove()
        MoveToObject()
       LoadCart()
    else
        Destination = Cart.Contains.Target
        CurrentMove = [Location, Destination]
        SubList = List.Where(Move.Within(CurrentMove))
        if !SubList.Empty
            Destination = SubList.FindSmallest(Location, Move.Origin)
        MoveTo(Destination)
        if !Destination.Empty
            SwapCart()
            UpdateTaskList()
        else
            EmptyCart()
            DeleteTask()

Je pense que cela couvre tous les cas. Dans un sens, c'est récursif mais en mettant à jour sa liste plutôt qu'en s'appelant.

C'est le problème du vendeur ambulant asymétrique . Vous pouvez voir cela comme un graphique. Les bords seront chaque paire (départ, arrivée), une pour chaque (0, départ) et toutes les autres paires de (arrivée, départ).

En supposant que NP! = P, il aura un temps d'exécution attendu exponentiel.