Balancea los árboles con tu gancho

Has encontrado el camino a través del bosque y ahora planeas viajar por él. Sin embargo, justo antes de comenzar su viaje, el suelo se convierte en lava.

Te las arreglas para correr hacia el árbol más cercano (los árboles no se han quemado inexplicablemente), pero ahora te enfrentas a un problema: ¿cómo puedes salir del bosque cuando el piso es lava? La respuesta le parece una buena idea para un desafío de programación: ¡puede usar su gancho de agarre mágico (hecho de un trozo de la canoa antes) para balancearse entre los árboles y las ramas!

Sin embargo, no está seguro de qué árboles y ramas necesita columpiarse para llegar allí. Afortunadamente, tiene sus habilidades de programación, por lo que decide dibujar un programa en su brazo para decirle en qué árboles debe columpiarse. Sin embargo, no hay mucha superficie en su brazo, por lo que debe hacer que el programa sea lo más pequeño posible.

Podemos representar un bosque usando una matriz nby m. Los siguientes caracteres formarán la matriz:

T: Un árbol. Puedes aterrizar aquí. No puedes usar tu gancho de agarre en esto. Puedes pasar por esto.
P: Funciona igual que T. Empiezas aquí
Q: Funciona igual que T. Este es el objetivo.
+: Una rama. No puedes aterrizar aquí. Puedes usar tu gancho de agarre en esto. Puedes pasar por esto.
*: Una araña devoradora de hombres. Si aterrizas aquí, mueres. Si usas tu gancho de agarre en esto, mueres. Si pasas por esto, mueres.
-: Tierra regular, en otras palabras, lava. No puedes aterrizar aquí. No puedes usar tu gancho de agarre en esto. Puedes pasar por esto. Toda el área fuera de la matriz dada es de este tipo.

Aquí hay un ejemplo de cómo se vería un bosque:

               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

Me referiré a las coordenadas con la notación (x,y), como se muestra en los ejes.

Empiezas desde Py tienes que dirigirte hacia Q. Para hacer esto, te balanceas de árbol Ten árbol Tusando ramas +. Puede adjuntar su gancho de agarre en cualquier rama que sea ortogonal para usted, es decir, una rama que esté en la misma posición x o y en la que se encuentra. Por ejemplo, si estuviera en la posición (4,8)en el bosque de ejemplo, usted podría conectar el gancho para las posiciones (2,8), (6,8)o (4,5). Puede adjuntar esto incluso si hay árboles u otras ramas entre usted y la rama.

Una vez que conecte su gancho de agarre a una rama, recorrerá una distancia en la dirección de la rama igual al doble de la distancia entre su posición inicial y la rama. En otras palabras, su posición final estará a la misma distancia de la rama que su posición inicial, justo en el lado opuesto. A continuación se incluye una definición más formal de cómo funciona el movimiento. Un subíndice de ves la posición final, ues la posición inicial y bes la posición de la rama.

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

Tenga en cuenta que si hay una araña entre su posición inicial y su posición final, no puede ir allí. Por ejemplo, en el bosque de ejemplo, el balanceo de (4,2)a (12,2)no es posible porque te toparías con la araña en (10,2).

El objetivo es, utilizando este método de balanceo a través de ramas, viajar de un punto Pa otro Qen el menor número de oscilaciones posible. Por ejemplo, en el bosque de ejemplo, la ruta más corta es:

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

Entrada

La entrada es de cualquier método que sea conveniente (STDIN, argumentos de línea de comando raw_input(), etc.), excepto que no se puede inicializar previamente como una variable. La entrada comienza con dos enteros separados por comas ny que mrepresentan el tamaño del tablero, luego un espacio y luego el bosque como una sola cadena larga. Por ejemplo, el bosque de ejemplo como entrada se vería así:

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

Salida

Imprima una lista separada por espacios de tuplas separadas por comas que indican las coordenadas de las ramas a las que debe desplazarse. Por ejemplo, para la entrada anterior, la salida sería:

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

Es posible que haya notado que este no es el único camino más corto a través del bosque; de hecho, ir (8,8), bajar (8,0), dejarse (4,0)y continuar normalmente desde allí toma exactamente la misma cantidad de cambios. En estos casos, su programa puede generar cualquiera de las rutas más cortas. Entonces la salida:

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

También está permitido. Este es el código de golf , por lo que gana la entrada con el menor número de bytes. Si tiene preguntas o mi explicación no es clara, pregunte en los comentarios.

code-golf graph-theory

— Ajenjo
fuente

Su entrada de ejemplo debería comenzar 15,13porque la matriz tiene un tamaño de 13 por 15.

— Howard

@Howard Fixed. Gracias.

— absenta

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/' '}/

Una pieza horrible de código GolfScript, sin embargo, funciona como se desea. El algoritmo no es óptimo, pero es bastante rápido, el ejemplo se ejecuta muy por debajo de un segundo en mi computadora.

> 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
fuente