Quebra-cabeça da entrevista sobre como viajar em um segmento de linha

Em uma linha numérica de comprimento M, em que 0 < M <= 1,000,000,000você forneceu N( 1 < N <= 100,000) pares inteiros de pontos. Em cada par, o primeiro ponto representa onde um objeto está localizado atualmente e o segundo ponto representa para onde um objeto deve ser movido. (Lembre-se de que o secondponto pode ser menor que o first).

Agora, suponha que você comece no ponto 0e tenha um carrinho que possa conter 1objetos. Você deseja mover todos os objetos de suas posições iniciais para suas respectivas posições finais enquanto percorre a menor distância ao longo da linha numérica ( não deslocamento). Você tem que acabar no ponto M.

Agora, estou tentando reduzir esse problema para um problema mais simples. Para ser sincero, nem consigo pensar em uma solução de força bruta ( possivelmente gananciosa). No entanto, meu primeiro pensamento foi degenerar um movimento para trás em dois movimentos para frente, mas isso não parece funcionar em todos os casos.

Eu desenhei esses 3casos de teste de amostra aqui:

A resposta para o primeiro caso de teste é 12. Primeiro, você escolhe o reditem no ponto 0. Então você vai para o ponto 6(distância = 6), solta o reditem temporariamente e, em seguida, pega o greenitem. Então você vai para o ponto 5(distância = 1) e solta o greenitem. Então você volta ao ponto 6(distância = 1) e pega o reditem que caiu, passa ao ponto 9 (distância = 3) e depois ao ponto 10(distância = 1) para finalizar a sequência.

A distância total percorrida foi 6 + 1 + 1 + 3 + 1 = 12, que é a distância mínima possível.

Os outros dois casos têm respostas 12, acredito. No entanto, não consigo encontrar uma regra geral para resolvê-lo.

Alguém tem alguma idéia?

1. Se você estiver vazio, comece a se mover para a direita.

2. Sempre que você alcançar um objeto e estiver vazio, pegue-o (duh) e vá em direção ao seu destino.

3. Sempre que você alcançar um objeto ae já estiver carregando b, sempre escolha um dos objetos com o destino numericamente menor (mais à esquerda).

4. Se você ainda não está na M, volte para a etapa 1.

Isso é ideal: o único lugar onde você tem uma escolha real é na etapa 3. O primeiro destino do lado esquerdo garante que, quando você despachar os dois objetos, você estará o mais à direita possível.

Por que essa pergunta está no programmers.sx? Sim, "pergunta da entrevista", mas é apenas um bom enigma.

PS. Em termos de implementação, tudo que você precisa é a lista de tarefas (os pares inteiros de pontos) classificadas pela posição original.

Suponha que você receba esses movimentos, (a, b), (c, d), (e, f), ...então a distância mínima a ser percorrida é abs(b - a) + abs(d - c) + abs(f - e) + ...a distância real percorrida abs(b - a) + abs(c - b) + abs(d - c) + abs(e - d) + ....
Basicamente, dado um conjunto de movimentos, o objetivo é minimizar a função "distância da viagem" trocando elementos. Se você considerar uma combinação específica como um nó e todas as combinações que podem ser alcançadas como arestas, poderá usar um dos muitos algoritmos de pesquisa de gráficos em torno dos quais utiliza uma heurística. Um exemplo é a busca por vigas .

Pode ser que eu esteja entendendo mal o problema, mas e o seguinte:

1. Classifique os pares pelo primeiro número do par que é o local atual
2. Mova os elementos de troca de linha para o local apropriado (você tem uma variável temporária)

O fato de ser classificado garante que você não avance e avance os elementos para colocá-los no local apropriado (independentemente se a linha estiver representada como uma matriz ou lista)

Atualizar após o comentário @templatetypedef:
use a HashTablepara armazenar todos os pares. Use a localização atual de cada par como chave de índice.
Use um segundo índice sobre os pares.

 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  

Minha inclinação para um algoritmo que é basicamente ganancioso:

Crie uma lista de pontos que precisam ser movidos. Como otimizar isso não faz parte do problema necessário, não vou me preocupar em organizá-lo.

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

Eu acho que isso cobre todos os casos. Em certo sentido, é recursivo, mas através da atualização da lista, em vez de se chamar.

Esse é o problema do vendedor ambulante assimétrico . Você pode pensar nisso como um gráfico. As arestas serão cada par (início, término), um para cada (0, início) e todos os outros pares de (término, início).

Supondo que NP! = P, ele terá um tempo de execução esperado exponencial.