<< Anterior Siguiente >>

Desafío

Ahora que Santa finalmente ha descubierto cómo entrar en su bóveda actual, se da cuenta de que de alguna manera los elfos entraron allí antes que él y le robaron algunos de sus regalos. Sin embargo, todavía no han descubierto cómo salir de la bóveda, por lo que Santa tiene que intentar atraparlos a todos. Santa y los elfos tienen energía infinita para correr, pero desafortunadamente los elfos tienen una energía infinita más alta, por lo que si terminan corriendo en bucles en todas partes, los elfos se han liberado.

Dado un gráfico de nnodos y earistas con una caminata existente entre dos nodos, y las posiciones de los elfos y Santa, determine cuántos elfos puede atrapar Santa antes de que se canse.

La persecución es por turnos. Cada ciclo, los elfos primero se mueven simultáneamente (pueden moverse entre ellos y también en el mismo nodo), y luego Santa se moverá. Si Santa se mueve al mismo nodo que un elfo, entonces él ha atrapado a ese elfo. Cada elfo solo puede moverse de un nodo a su vecino en un solo paso. Lo mismo ocurre con Santa al principio, pero por cada elfo que ha atrapado, Santa puede dar un paso más. Entonces, si Santa ha atrapado a un elfo, entonces puede pasar de un nodo al vecino de su vecino. Esto significa que podría moverse a un nodo y luego regresar. Sin embargo, dado que Papá Noel corre demasiado rápido durante este período de tiempo, no atrapará a ningún elfo que pase en los pasos intermedios (por lo tanto, si está en A, A está conectado a B, B está conectado a C, hay un elfo en B, y Santa se mueve de A -> B -> C, el elfo aún no ha sido atrapado). Sin embargo, Santa no tiene que moverse tantos pasos a la vez; se mueve hasta 1 + (número de elfos atrapados) cada turno.

Tenga en cuenta que todos los elfos deben moverse cada turno, y si un elfo se mueve hacia el nodo de Santa, quedan atrapados.

Todas las entidades (elfos, Santa) estarán en nodos distintos al principio.

Especificaciones y Reglas

Su programa debería funcionar teóricamente para entradas de cualquier tamaño. La entrada se dará como un gráfico, las posiciones de los elfos y la posición de Santa. Puede tomar el gráfico en cualquier formato razonable (lista de nodos + lista de aristas, lista de aristas, matriz de adyacencia, notación de ciclo, etc.), y puede tomar las posiciones en cualquier formato razonable que funcione con su formato de entrada de gráfico (índice en la lista de nodos, etc.). La salida debe ser un solo entero positivo que indique el número máximo de elfos que Santa puede atrapar.

Casos de prueba

Estos se dan como listas de aristas y números de nodo para las posiciones.

Input -> Output
[(0, 1), (1, 2)], [0, 2], 1 -> 2 # Easy win for Santa, the elves get themselves caught :P
[(0, 1), (1, 2), (2, 3), (3, 0)], [0, 1], 2 -> 2 # The elf opposite of Santa cannot escape but the other one can always just run away each turn, until Santa catches the first elf. Then he can easily just catch the rest.
[(0, 1), (1, 2), (2, 3), (3, 0)], [1], 0 -> 0 # Santa will never catch up
[(0, 1), (1, 2), (2, 3), (3, 0), (1, 4), (4, 5), ..., (10, 11), (11, 3)], [2, 6], 0 -> 2 # The first elf moves to either 1 or 3 and then gets caught. Then, Santa can use his 2-step move to catch up to the second elf no matter what.

^{Creo que Santa no puede atrapar a ningún elfo o a todos los elfos, por lo que este desafío podría ser una pista de "¿puede atrapar a un elfo?"}

Reglas

• Se aplican lagunas estándar
• Este es un desafío de código de golf , por lo que gana la respuesta más corta en bytes
• No se aceptarán respuestas.

¡Feliz golf!

^{Nota: Me inspiré para esta serie de desafíos de Advent Of Code . No estoy afiliado a este sitio}

Puede ver una lista de todos los desafíos de la serie mirando la sección 'Vinculados' del primer desafío aquí .

Wolfram Language (Mathematica) , 129 bytes

Block[{a=#},Clear@f;s_~f~e_:=If[s==e,1,s~f~e=0;s~f~e=Min[(hMax[#~f~h&/@a@s,Boole[h==s]])/@a@e]];Tr[Max[(e#3~f~e)/@#2]^#2]]&

Pruébalo en línea!

Enfoque similar a mi respuesta a esta pregunta .

La función toma 3 argumentos como entrada: la lista de adyacencia representada como una asociación ( herramienta para generar la lista de adyacencia a partir de la lista de bordes ), la posición de los elfos y la posición de santa.

Tenga en cuenta que Clear[f]es necesario, porque los envíos de funciones deben ser reutilizables.

El siguiente código es un código sin golf con explicación parcial. Más explicaciones después.

reverseBoole = # != 0 &

(* Or@@{a, b} === reverseBoole[booleOr[Boole[{a, b}]]] *)
booleOr = Max

booleAnd = Min

(* Boole@f[s, e] = Santa can catch Elf ? *)

mainfunc = Block[{adjlist = #},
  Clear[f];
  f[s_, e_] := If[ s == e, f[s, e] = 1,
    f[s, e] = Boole[False];
    f[s, e] = booleAnd[
      (e1  booleOr[
        ( s1  f[s1, e1] ) /@ adjlist[s],
        Boole[e1 == s]
      ]) /@ adjlist[e]
    ]
  ];
  If [ 0 == booleOr[ ( e  f[#3, e] ) /@ #2 ] , 0, Length[#2] ]
]&