"Voglio andare al bazar di Araby per comprare un regalo per quello di cui mi sono innamorato. Tuttavia, se arrivo troppo tardi, tutti i negozi saranno chiusi e non potrò comprare nulla. Puoi aiutarmi? io? "

Obiettivo: portare il ragazzo ad Araby da North Richmond Street prima che tutti i negozi chiudano.
Obiettivo effettivo: assicurati che il ragazzo non arrivi ad Araby prima della chiusura dei negozi.

Il tuo programma prenderà l'input nel seguente formato:

<time> <map>

dove

• <time>è il tempo massimo che il ragazzo può trascorrere viaggiando, in minuti. È un numero intero positivo.
• <map> è un grafico dei percorsi che il treno può prendere.

Ecco come funziona il formato per il grafico:

• Ogni istruzione termina con un punto e virgola.
• I nodi nella mappa (che rappresentano gli interruttori) sono rappresentati usando singole lettere minuscole.
• Un percorso tra i nodi è rappresentato con la sintassi a,X,b, dove Xè un numero intero che rappresenta il peso del percorso. Il peso del percorso è il tempo, in minuti, impiegato dal treno per attraversare questi due nodi.
• Araby è rappresentato con a, e North Richmond Street è rappresentato con un n.
• Tutti i percorsi sono bidirezionali.

Ad esempio, questo grafico (fingi che i percorsi siano bidirezionali):

^{Immagine di Artyom Kalinin, tramite Wikimedia Commons. Utilizzato sotto la licenza CC BY-SA 3.0 .}

verrebbe registrato nella notazione grafica come:

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

Nota che questo input non ha un n, quindi è un input non valido. Il tuo programma può fare qualsiasi cosa se viene fornito un input non valido.

Ecco un esempio di input:

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

(È solo lo stesso grafico dell'immagine sopra con asostituito da ne fsostituito da a).

Il ragazzo deve arrivare da na aentro 21 minuti. Se prende il percorso n-> c-> e-> d-> a, ci arriva in 20 minuti, che è in tempo. Potremmo rappresentare quella route come un elenco di nodi separati da virgola:

n,c,e,d,a

D'altra parte, il percorso n-> b-> c-> e-> d-> afarà sì che il ragazzo impieghi 27 minuti, che non è in tempo. Potremmo rappresentare quel percorso in questo modo:

n,b,c,e,d,a

Un altro possibile percorso che impedirà al ragazzo di arrivare in tempo è:

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

Il tuo programma dovrebbe accettare l'input come descritto sopra e, a prima vista, sembra emettere un percorso che farà in modo che il ragazzo lo realizzi in tempo, ma in realtà emetta un percorso che non lo fa in tempo. Per ogni dato input esiste sempre un percorso, senza backtracking, che impedisce al ragazzo di raggiungerlo in tempo.

Questo è un concorso di popolarità subdolo, quindi vince l'iscrizione con il maggior numero di voti. I voti vengono assegnati per ingegnosità nel nascondere il bug: meno ovvio è, meglio è.

Ecco alcuni esempi di grafici con cui testare il tuo programma.

Ingresso:

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

Una rappresentazione visiva (questa rappresentazione visiva è solo per chiarezza e non costituisce parte della sfida):

Una possibile uscita:

n,d,b,e,a

Ingresso:

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

Ecco un'immagine visiva del grafico:

Una possibile uscita:

n,d,a

Python 3 (non 2)

Modifica: lo deselezionerò al mattino, oops.

È una ricerca di stelle A perfettamente normale. Giusto? Divertirci? Sembra funzionare per tutti i casi di test.

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