Intervista puzzle su come viaggiare su un segmento di linea

Su una linea numerica di lunghezza M, dove 0 < M <= 1,000,000,000, hai dato N( 1 < N <= 100,000) coppie intere di punti. In ciascuna coppia, il primo punto rappresenta dove si trova attualmente un oggetto e il secondo punto rappresenta dove dovrebbe essere spostato un oggetto. (Tieni presente che il secondpunto potrebbe essere più piccolo del first).

Ora, supponi di iniziare dal punto 0e di avere un carrello che può contenere 1oggetti. Volete spostare tutti gli oggetti dalle loro posizioni iniziali alle rispettive posizioni finali mentre percorrete la minima distanza lungo la linea numerica ( non spostamento). Devi finire sul punto M.

Ora, ho cercato di ridurre questo problema a un problema più semplice. Ad essere sincero, non riesco nemmeno a pensare a una soluzione di forza bruta ( forse avida). Tuttavia, il mio primo pensiero è stato di degenerare un movimento all'indietro in due movimenti in avanti, ma ciò non sembra funzionare in tutti i casi.

Ho disegnato questi 3esempi di casi di prova qui:

La risposta al primo testcase è 12. Innanzitutto, raccogli l' redoggetto al punto 0. Quindi vai al punto 6(distanza = 6), rilascia l' redoggetto temporaneamente, quindi raccogli l' greenoggetto. Quindi si passa al punto 5(distanza = 1) e si rilascia l' greenoggetto. Quindi torni al punto 6(distanza = 1) e raccogli l' redoggetto che hai lasciato cadere, passa al punto 9 (distanza = 3), quindi passa al punto 10(distanza = 1) per completare la sequenza.

La distanza totale percorsa era 6 + 1 + 1 + 3 + 1 = 12, che è la distanza minima possibile.

Gli altri due casi hanno risposte 12, credo. Tuttavia, non riesco a trovare una regola generale per risolverlo.

Qualcuno ha qualche idea?

1. Se sei vuoto, inizia a spostarti verso destra.

2. Ogni volta che raggiungi un oggetto e sei vuoto, raccoglilo (duh) e spostati verso la sua destinazione.

3. Ogni volta che raggiungi un oggetto ae lo stai già trasportando b, scegli sempre quale degli oggetti ha la destinazione numericamente più piccola (più a sinistra).

4. Se non sei ancora in M, torna al passaggio 1.

Questo è ottimale: l'unico posto in cui hai una vera scelta è al punto 3. La gestione della destinazione più a sinistra prima ti assicura che quando avrai spedito entrambi gli oggetti, sarai il più a destra possibile.

Perché questa domanda è su programmers.sx? Sì, "domanda per l'intervista", ma è solo un bel indovinello.

PS. In termini di implementazione, tutto ciò che serve è l'elenco delle attività (le coppie di punti interi) ordinate per posizione originale.

Supponiamo che ti vengano fornite queste mosse, (a, b), (c, d), (e, f), ...quindi la distanza minima che devi percorrere è abs(b - a) + abs(d - c) + abs(f - e) + ...e la distanza effettiva che percorri è abs(b - a) + abs(c - b) + abs(d - c) + abs(e - d) + ....
Fondamentalmente, data una serie di mosse, il punto è minimizzare la funzione di "distanza di spostamento" scambiando elementi intorno. Se consideri una particolare combinazione come un nodo e tutte le combinazioni che puoi raggiungere da esso come spigoli, puoi usare uno dei tanti algoritmi di ricerca di grafici attorno ai quali utilizzare un euristico. Un esempio è la ricerca del raggio .

Forse non ho capito bene il problema, ma per quanto riguarda:

1. Ordina le coppie in base al primo numero della coppia che è la posizione corrente
2. Spostati lungo la linea scambiando gli elementi nella loro posizione corretta (hai una variabile temporanea)

Il fatto che sia ordinato garantisce di non andare avanti e indietro per gli elementi per posizionarli nella posizione corretta (indipendentemente dal fatto che la linea sia rappresentata come un array o un elenco)

Aggiorna dopo il commento di @templatetypedef:
usa a HashTableper memorizzare tutte le coppie. Utilizzare la posizione corrente di ciascuna coppia come chiave indice.
Usa un secondo indice sopra le coppie.

 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  

La mia inclinazione verso un algoritmo che è sostanzialmente avido:

Crea un elenco di punti che devono essere spostati. Poiché l'ottimizzazione di questo non fa parte del problema richiesto, non mi preoccuperò di organizzarlo.

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

Penso che questo copra tutti i casi. In un certo senso è ricorsivo, ma aggiornando la sua lista piuttosto che chiamarsi.

Questo è il problema del commesso viaggiatore asimmetrico . Puoi pensarlo come un grafico. I bordi saranno ciascuna coppia (inizio, fine), una per ogni (0, inizio) e tutte le altre coppie di (fine, inizio).

Supponendo NP! = P, avrà un tempo di esecuzione previsto esponenziale.