Swing através de árvores com seu gancho

Você encontrou o caminho através da floresta e agora planeja viajar por ela. No entanto, pouco antes de você começar sua jornada, o chão se transforma em lava.

Você consegue correr pela árvore mais próxima (as árvores inexplicavelmente não se queimaram), mas agora você se depara com um problema: como você pode sair da floresta quando o chão é lava? A resposta lhe dá uma boa idéia para um desafio de programação - você pode usar seu gancho mágico (feito de um pedaço da canoa mais cedo) para balançar entre as árvores e os galhos!

No entanto, você não tem certeza de quais árvores e galhos precisa balançar para chegar lá. Felizmente, você tem suas habilidades de programação e decide desenhar um programa em seu braço para dizer em quais árvores balançar. No entanto, como não há muita área de superfície em seu braço, você deve tornar o programa o menor possível.

Podemos representar uma floresta usando um npor mmatriz. Os seguintes caracteres formarão a matriz:

T: Uma árvore. Você pode pousar aqui. Você não pode usar seu gancho para isso. Você pode passar por isso.
P: Funciona da mesma forma que T. Você começa aqui.
Q: Funciona da mesma forma que T. Esse é o objetivo.
+: Um ramo. Você não pode pousar aqui. Você pode usar seu gancho para isso. Você pode passar por isso.
*: Uma aranha devoradora de homens. Se você pousar aqui, você morre. Se você usar seu gancho para isso, você morre. Se você passar por isso, você morre.
-: Terreno regular, em outras palavras, lava. Você não pode pousar aqui. Você não pode usar seu gancho para isso. Você pode passar por isso. Toda a área fora da matriz especificada é desse tipo.

Aqui está um exemplo de como uma floresta pode ser:

               y
----T---+------12
---------------11
----T---+---T--10
---------------9
T-+-T-+-T------8
---------------7
------------+--6
----+----------5
+-------+------4
---------------3
----P---+-*-Q--2
---------------1
T-+-T-+-T------0
012345678911111
x         01234

Vou me referir às coordenadas com a notação (x,y), como mostrado nos eixos.

Você começa Pe precisa fazer o seu caminho Q. Para fazer isso, você alterna de árvore Tpara árvore Tusando galhos +. Você pode anexar seu gancho em qualquer ramo ortogonal a você, ou seja, um ramo que esteja na mesma posição x ou y em que você está. Por exemplo, se você estivesse na posição (4,8)na floresta de exemplo, você pode anexar seu gancho para as posições (2,8), (6,8)ou (4,5). Você pode anexar isso mesmo se houver árvores ou outros galhos entre você e o galho.

Depois de conectar o gancho em um galho, você percorrerá uma distância na direção do galho igual ao dobro da distância entre sua posição inicial e o galho. Em outras palavras, sua posição final será a mesma distância do ramo que sua posição inicial, exatamente do lado oposto. Uma definição mais formal de como o movimento funciona está abaixo. Um subscrito de vé a posição final, ué a posição inicial e bé a posição do ramo.

(x_{v}, y_{v}) = (2 x_{b} - x_{u}, 2 y_{b} - y_{u})

$(x_v, y_v) = (2x_b-x_u, 2y_b-y_u)$

Observe que, se houver uma aranha entre sua posição inicial e sua posição final, você não poderá ir para lá. Por exemplo, na floresta de exemplo, o balanço de (4,2)para (12,2)não é possível porque você encontraria a aranha em (10,2).

O objetivo é, usando esse método de oscilação através dos ramos, viajar do ponto Pao ponto Qcom o menor número possível de oscilações. Por exemplo, na floresta de exemplo, o caminho mais curto é:

De (4,2)para (4,8)usar(4,5)
De (4,8)para (0,8)usar(2,8)
De (0,8)para (0,0)usar(0,4)
De (0,0)para (4,0)usar(2,0)
De (4,0)para (4,10)usar(4,5)
De (4,10)para (12,10)usar(8,10)
De (12,10)para (12,2)usar(12,6)

Entrada

A entrada é do método que for conveniente (STDIN, argumentos de linha de comando raw_input(), etc.), exceto que ela não pode ser pré-inicializada como uma variável. A entrada começa com dois números inteiros separados por vírgula ne mrepresenta o tamanho do quadro, depois um espaço e, em seguida, a floresta como uma única sequência longa. Por exemplo, a floresta de exemplo como uma entrada ficaria assim:

15,13 ----T---+-------------------------T---+---T-----------------T-+-T-+-T---------------------------------+------+----------+-------+-------------------------P---+-*-Q-----------------T-+-T-+-T------

Resultado

Crie uma lista separada por espaços de tuplas separadas por vírgula, indicando as coordenadas dos ramos para os quais você deve balançar. Por exemplo, para a entrada acima, a saída seria:

4,5 2,8 0,4 2,0 4,5 8,10 12,6

Você deve ter notado que esse não é o único caminho mais curto pela floresta - de fato, ir (8,8), descer (8,0), sair (4,0)e continuar normalmente a partir daí exige exatamente o mesmo número de oscilações. Nesses casos, seu programa pode gerar um dos caminhos mais curtos. Então a saída:

4,5 6,8 8,4 6,0 4,5 8,10 12,6

também é permitido. Isso é código-golfe , então a entrada com o menor número de bytes vence. Se você tiver dúvidas ou minha explicação não estiver clara, pergunte nos comentários.

code-golf graph-theory

— absinto
fonte

Sua entrada de exemplo deve começar 15,13porque a matriz tem 13 por 15 de tamanho.

— Howard Howard

@Howard Fixed. Obrigado.

— o absinto

GolfScript, 196 caracteres

' '/(~):H;,):W(\~/-1%'*':S*:^{:I,,{I=79>},:A{{[\1$1$+2/]}+A/}%{)I=43=\$.~I<>S&!\~+1&!&&},}:C~S^W/zip*C{{.H/\H%W*+}%}%+:B;^'P'?]]{{(B{0=1$=},\;\`{\1>\+}+/}%.{0=^=81=},:|!}do;|0=1>-1%{.W%','@W/' '}/

Uma parte horrível do código GolfScript - no entanto, funciona como desejado. O algoritmo não é ideal, mas bastante rápido, o exemplo está sendo executado bem abaixo de um segundo no meu computador.

> 15,13 ----T---+-------------------------T---+---T-----------------T-+-T-+-T---------------------------------+------+----------+-------+-------------------------P---+-*-Q-----------------T-+-T-+-T------
4,5 2,8 0,4 2,0 4,5 8,10 12,6

— Howard
fonte