"Quero ir ao bazar da Araby para comprar um presente pelo qual me apaixonei. No entanto, se chegar tarde demais, todas as lojas serão fechadas e não poderei comprar nada. Você pode ajudar eu? "

Objetivo: Levar o garoto para Araby da North Richmond Street antes que todas as lojas fechem.
Objetivo real: Verifique se o garoto não chega a Araby antes que as lojas fechem.

Seu programa receberá entradas no seguinte formato:

<time> <map>

Onde

• <time>é o tempo máximo que o garoto pode passar viajando, em minutos. É um número inteiro positivo.
• <map> é um gráfico das rotas que o trem pode seguir.

Aqui está como o formato do gráfico funciona:

• Cada instrução termina com um ponto e vírgula.
• Os nós no mapa (que representam comutadores) são representados usando letras minúsculas únicas.
• Um caminho entre nós é representado com a sintaxe a,X,b, onde Xé um número inteiro que representa o peso do caminho. O peso do caminho é o tempo, em minutos, que o trem leva para percorrer esses dois nós.
• Araby é representado por ae North Richmond Street é representado por um n.
• Todos os caminhos são bidirecionais.

Por exemplo, este gráfico (finja que os caminhos são bidirecionais):

^{Imagem de Artyom Kalinin, via Wikimedia Commons. Usado sob a licença CC BY-SA 3.0 .}

seria registrado na notação gráfica como:

a,4,b;a,2,c;b,5,c;b,10,d;c,3,e;e,4,d;d,11,f;

Observe que esta entrada não possui uma n, portanto é uma entrada inválida. Seu programa pode fazer qualquer coisa se receber uma entrada inválida.

Aqui está um exemplo de entrada:

21 n,4,b;n,2,c;b,5,c;b,10,d;c,3,e;e,4,d;d,11,a;

(É exatamente o mesmo gráfico da imagem acima com asubstituído por ne fsubstituído por a).

O menino deve começar a partir nde adentro de 21 minutos. Se ele seguir a rota n-> c-> e-> d-> a, ele chega em 20 minutos, que é a tempo. Poderíamos representar essa rota como uma lista de nós separados por vírgula:

n,c,e,d,a

Por outro lado, a rota n-> b-> c-> e-> d-> afará com que o menino demore 27 minutos, o que não é a tempo. Poderíamos representar essa rota assim:

n,b,c,e,d,a

Outra rota possível que fará com que o garoto não chegue a tempo é:

n,b,c,b,c,b,c,b,c,b,c,b,c,b,c,b,c,b,c,e,d,a

Seu programa deve receber a entrada conforme descrito acima e, à primeira vista, parece gerar uma rota que fará com que o garoto chegue a tempo, mas na verdade gera uma rota que faz com que o garoto não chegue a tempo. Para qualquer entrada, sempre haverá uma rota, sem retorno, que faz com que o garoto não chegue a tempo.

Este é um concurso de popularidade secreto, por isso ganha a participação com mais votos. Os votos são concedidos por engenhosidade ao ocultar o erro - quanto menos óbvio, melhor.

Aqui estão alguns exemplos de gráficos para testar seu programa.

Entrada:

12 a,2,c;a,2,e;b,5,c;b,4,d;b,11,e;d,7,n;e,4,n;

Uma representação visual (essa representação visual é apenas para maior clareza e não constitui parte do desafio):

Uma saída possível :

n,d,b,e,a

Entrada:

10 a,8,b;a,12,d;b,1,n;d,11,n;a,1,n;

Aqui está uma imagem visual do gráfico:

Uma saída possível :

n,d,a

Python 3 (não 2)

Edit: Eu vou desfazer isso de manhã, oops.

É uma pesquisa A-star perfeitamente normal. Certo? Riiiiiii? Parece funcionar para todos os casos de teste.

def a(b,c,d):
    e,f,g=[],{},{}
    f[c]=0
    while f:
        h=sorted(f.keys(),key=lambda z:-f[z],reverse=True)[-1]
        if h==d:break
        e.append(h)
        for z in b[h]:
            if z in e:continue
            if z in f and f[z]>f[h]+b[z][h]:continue
            g[z]=h
            f[z]=f[h]+b[z][h]
        del f[h]
    i=[]
    j=d
    q=0
    while j!=c:
        i.append(j)
        q+=b[j][g[j]]
        j=g[j]
    return q,(i+[c])[::-1]
t,q=input().split(" ")
t=int(t)
q=q[:-1]
q=[i.split(",")for i in q.split(";")]
g={a:{}for a in __import__("functools").reduce(lambda zz,zy:zz+zy,[[v[0],v[2]]for v in q])}
for l in q:g[l[0]][l[2]]=g[l[2]][l[0]]=int(l[1])

r=a(g,'n','a')
print("time-good: %d, time-ours: %d" % (t, r[0]))
print("path: %s" % " -> ".join(r[1]))