Esta es una variante de Jugar la cadena de palabras y Construir una larga cadena de palabras .

La entrada es una lista no vacía de palabras únicas de al menos 2 caracteres de caracteres en [az]. Debe generar la longitud de la cadena más larga posible, donde cada palabra subsiguiente comienza con la última letra de la palabra anterior. Puede comenzar con cualquier palabra en la lista.

Otro giro es que se le permite repetir cualquier palabra en la lista. Sin embargo, no puede repetir ningún bloque de dos palabras. Por ejemplo, cat->tac->catestá permitido, pero cat->tac->cat->tacno lo está, porque repitió un bloque de dos palabras ( cat->tac). Además, no puede usar la misma palabra dos veces seguidas (por ejemplo eye->eye).

Ejemplos:

• cat dog tree egg => 3 (gato-> árbol-> huevo)
• new men ten whim => 5 (diez-> nuevo-> capricho-> hombres-> nuevo)
• truth fret heart his => 5 (traste-> verdad-> corazón-> verdad-> suyo)
• we were stew early yew easy => 9 (estofado-> eran-> temprano-> tejo-> eran-> fácil-> tejo-> nosotros-> fácil)
• tac cat tac cot tac can => 6 (tac-> cat-> tac-> cot-> tac-> can)

(Avíseme si cometí un error en alguno de estos ejemplos o si tiene más).

Python 3 , 150 149 145 bytes

def f(d):
 a=[[w]for w in d]
 while a:b=a[0];a=[f+[l,y]for*f,l in a for y in{*d}-{b for a,b in zip(f,f[1:])if a==l}if l[-1]==y[0]]
 return len(b)

Pruébalo en línea!

La idea para la construcción de caminos, sucesivamente más largos (o en este caso) hasta que ninguno senderos ya podría crearse fue inspirada directamente por la respuesta de GRC en el Juego de la cadena de palabras que se trate.

Haskell , 131 141 bytes

Básicamente, el enfoque de la fuerza bruta. La idea es generar todas las piezas de dominó posibles , permutarlas, verificar si es un combo válido y maximizar todo. La complejidad del tiempo es ridícula, el cuarto caso de prueba ya lleva ~ 4s en mi PC y en el TIO ¡no parece funcionar!

import Data.List
p w=2+maximum[length$takeWhile(\(x,y)->x!!1==y!!0)$zip p$tail p|p<-permutations[[a,b]|(a,b)<-(,)<$>w<*>w,a/=b,last a==b!!0]]

Pruébalo en línea!

Sin golf

p w = maximum
  [ 2 + length c | p <- permutations [ [a,b] | (a,b) <- (,)<$>w<*>w
                                             , a /= b
                                             , last a == head b
                                     ]
                 , c <- [ takeWhile (\(x,y) -> x!!1 == y!!0) $ zip p (tail p) ]
  ]

Editar : Cambié de Lambdabot a Haskell desnudo, pero guardé algunos bytes jugando al golf, de modo que todavía es menor que 145bytes :)