Construire le graphique des nœuds connectés avec le dictionnaire

Question

J'écris un programme pour calculer le temps le plus rapide pour un voilier. J'ai une matrice 4x4, c'est-à-dire 16 nœuds. De chaque nœud je peux aller 8 directions différentes. Je connais l'heure du voyage dans chaque direction de chaque nœud dans une grande liste, donc c'est maintenant 8 * 16 caractères longs. Le début de la liste ressemble à ceci:

TravelTime = [0.7, 0.5, 10000, 0.5, 0.7, 1.6, 1.3, 1.6, 0.6, 0.5, 0.6, 0.9, 0.6, 0.5, 10000, 10000]... 

où les 8 premiers chiffres indique le temps de Voyage pour toutes les directions de Node11, et les 8 prochains numéros indique l'heure pour toutes les directions de Node12. Et ainsi de suite jusqu'à la dernière information pour Node44. Par exemple TravelTime[0] me dit l'heure de voyager directement de Node11 à Node12. Maintenant, je dois sauver à un dictionnaire si je le présente comme:

Graph = { 
'Node11': ['Node12', 0.7], ['Node22', 0.5], ['Node21', 10000], ['Node20', 0.5], ['Node10', 0.7], ['Node00', 1.6], ['Node01', 1.3], ['Node02', 1.6], and then it continues for the next Node: 
'Node12': ['Node13', 0.6], ['Node23', 0.5], ['Node22', 0.6], ['Node21', 0.9], ['Node11', 0.6], ['Node01', 0.5], ['Node02', 10000], ['Node03', 10000] 
} 

Les chiffres après « nœud » est égal aux coordonnées du nœud. Il commence par voyager vers le nord et il va dans le sens des aiguilles d'une montre, au total 8 directions différentes. SO: Comment écrire une fonction qui construit un dictionnaire comme celui ci-dessus?

Answer 1

Vous n'avez fourni aucun code, donc je ne vais pas écrire toute votre solution pour vous. Vos données d'entrée est très structuré, à savoir que tout a une longueur fixe, de sorte que vous pouvez utiliser des boucles de longueur fixe:

Graph = {} 
for nodeIdx in range(16): 
    Node = {} 
    for directionIdx in range(8): 
     # construct your node list from TravelTime 
    nodeNumber = # Figure out nodeNumber 
    Graph[nodeNumber] = Node 

Vous devriez être en mesure de comprendre comment choisir les index de TravelTime basé sur nodeIdx et directionIdx. J'espère que c'est un bon début.

Answer 2

permet de dire que nous voulons produire un dictionnaire dans ce format:

Graph = { 'Node11': [[ 'Node12': 0,7], [], ..., []] # pour attribuer une seule valeur de liste à chaque clé dans le dictionnaire

}

et que Traveltime est une liste de 8 * 16 valeurs.

Nous pouvons travailler à peu près avec la construction de chaînes de ce dictionnaire. Cela peut être une solution:

t = TravelTime 
movements = [(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1),(-1,0),(-1,1)] # the order of movements described by you 

output = '{' 
for i in range(1,5): 
     for j in range(1,5): 
       output+="\n'Node"+str(i)+str(j)+"': [" #the key in the dictionary 
       for k in range(8): 
         output+="["+"'Node"+str(i+movements[k][0])+str(j+movements[k][1])+"', "+str(t[((i+j)-2)*8+k])+"]," #the value of dictonary 
       output=output[:-1]+'],' # remove last comma and close the list bracket 
output=output[:-1]+'\n}' #remove last comma and insert last dictionary bracket 

Graph = eval(output) # last step to use Graph as a dictionary 

il sort quelque chose comme (avec 8 fois d'entrée répétée):

{'Node11': [['Node12', 0.7], ['Node22', 0.5], ['Node21', 10000], ['Node20', 0.5], ['Node10', 0.7], ['Node00', 1.6], ['Node01', 1.3], ['Node02', 1.6]], 'Node13': [['Node14', 0.7], ['Node24', 0.5], ['Node23', 10000], ['Node22', 0.5], ['Node12', 0.7], ['Node02', 1.6], ['Node03', 1.3], ['Node04', 1.6]], 'Node12': [['Node13', 0.6], ['Node23', 0.5], ['Node22', 0.6], ['Node21', 0.9], ['Node11', 0.6], ['Node01', 0.5], ['Node02', 10000], ['Node03', 10000]], 'Node14': [['Node15', 0.6], ['Node25', 0.5], ['Node24', 0.6], ['Node23', 0.9], ['Node13', 0.6], ['Node03', 0.5], ['Node04', 10000], ['Node05', 10000]], 'Node24': [['Node25', 0.7], ['Node35', 0.5], ['Node34', 10000], ['Node33', 0.5], ['Node23', 0.7], ['Node13', 1.6], ['Node14', 1.3], ['Node15', 1.6]], 'Node32': [['Node33', 0.6], ['Node43', 0.5], ['Node42', 0.6], ['Node41', 0.9], ['Node31', 0.6], ['Node21', 0.5], ['Node22', 10000], ['Node23', 10000]], 'Node31': [['Node32', 0.7], ['Node42', 0.5], ['Node41', 10000], ['Node40', 0.5], ['Node30', 0.7], ['Node20', 1.6], ['Node21', 1.3], ['Node22', 1.6]], 'Node21': [['Node22', 0.6], ['Node32', 0.5], ['Node31', 0.6], ['Node30', 0.9], ['Node20', 0.6], ['Node10', 0.5], ['Node11', 10000], ['Node12', 10000]], 'Node22': [['Node23', 0.7], ['Node33', 0.5], ['Node32', 10000], ['Node31', 0.5], ['Node21', 0.7], ['Node11', 1.6], ['Node12', 1.3], ['Node13', 1.6]], 'Node23': [['Node24', 0.6], ['Node34', 0.5], ['Node33', 0.6], ['Node32', 0.9], ['Node22', 0.6], ['Node12', 0.5], ['Node13', 10000], ['Node14', 10000]], 'Node33': [['Node34', 0.7], ['Node44', 0.5], ['Node43', 10000], ['Node42', 0.5], ['Node32', 0.7], ['Node22', 1.6], ['Node23', 1.3], ['Node24', 1.6]], 'Node44': [['Node45', 0.7], ['Node55', 0.5], ['Node54', 10000], ['Node53', 0.5], ['Node43', 0.7], ['Node33', 1.6], ['Node34', 1.3], ['Node35', 1.6]], 'Node34': [['Node35', 0.6], ['Node45', 0.5], ['Node44', 0.6], ['Node43', 0.9], ['Node33', 0.6], ['Node23', 0.5], ['Node24', 10000], ['Node25', 10000]], 'Node42': [['Node43', 0.7], ['Node53', 0.5], ['Node52', 10000], ['Node51', 0.5], ['Node41', 0.7], ['Node31', 1.6], ['Node32', 1.3], ['Node33', 1.6]], 'Node43': [['Node44', 0.6], ['Node54', 0.5], ['Node53', 0.6], ['Node52', 0.9], ['Node42', 0.6], ['Node32', 0.5], ['Node33', 10000], ['Node34', 10000]], 'Node41': [['Node42', 0.6], ['Node52', 0.5], ['Node51', 0.6], ['Node50', 0.9], ['Node40', 0.6], ['Node30', 0.5], ['Node31', 10000], ['Node32', 10000]]} 

bien sûr ici il y a 5 et 0 nœuds qui pourrait être atteint au bord.