Esta é uma variante de Reproduzir a cadeia de palavras e Construir uma longa cadeia de palavras .

A entrada é uma lista não vazia de palavras únicas com pelo menos 2 caracteres de comprimento em caracteres de [az]. Você precisa gerar o comprimento da cadeia mais longa possível, onde cada palavra subsequente começa com a última letra da palavra anterior. Você pode começar com qualquer palavra da lista.

Outra mudança é que você pode repetir qualquer palavra da lista. No entanto, você não pode repetir nenhum bloco de duas palavras. Por exemplo, cat->tac->caté permitido, mas cat->tac->cat->tacnão é, porque você repetiu um bloco de duas palavras ( cat->tac). Além disso, você não pode usar a mesma palavra duas vezes seguidas (por exemplo eye->eye).

Exemplos:

• cat dog tree egg => 3 (gato-> árvore-> ovo)
• new men ten whim => 5 (dez-> novo-> capricho-> homem-> novo)
• truth fret heart his => 5 (fret-> verdade-> coração-> verdade-> his)
• we were stew early yew easy => 9 (ensopado-> eram-> cedo-> teixo-> eram-> fácil-> teixo-> nós-> fácil)
• tac cat tac cot tac can => 6 (tac-> gato-> tac-> cot-> tac-> lata)

(Deixe-me saber se eu cometi um erro em algum desses exemplos ou se você tiver mais.)

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)

Experimente online!

A idéia para a construção de caminhos sucessivamente mais longos (ou neste caso trilhas) até que não podia mais ser criada foi diretamente inspirado pela resposta de grc no jogo a cadeia palavra pergunta.

Haskell , 131 141 bytes

Basicamente, a abordagem da força bruta. A idéia é gerar todas as peças possíveis de dominó , permutá-las, verificar se é uma combinação válida e maximizar a coisa toda. A complexidade do tempo é ridícula, o quarto caso de teste já leva ~ 4s no meu PC e no TIO parece não 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]]

Experimente online!

Ungolfed

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

Edit : Alterado do Lambdabot para desvendar o Haskell, mas salvou alguns bytes jogando golfe, de modo que ainda é menor que 145bytes :)