Пример реализации алгоритма поиска пути А.

#!/usr/bin/python
# -*- coding: UTF - 8 -*-
#Поиск пути по алгоритму Дейкстры, как я его понимаю №3
#denis8424



#Навигационная сетка
#[cost, visit, parent, [relatedPoint]] индекс - имя
nav = [[1000000, 0, 0, [1, 10, 11]],    #0
[1000000, 0, 0, [0, 2]],                #1
[1000000, 0, 0, [1, 3, 11]],            #2
[1000000, 0, 0, [2, 4, 13]],            #3
[1000000, 0, 0, [3, 5, 14, 15]],        #4
[1000000, 0, 0, [4, 15]],               #5
[1000000, 0, 0, [7, 15, 16]],           #6
[1000000, 0, 0, [6, 8, 18]],            #7
[1000000, 0, 0, [7, 9, 18]],            #8
[1000000, 0, 0, [8, 19]],               #9
[1000000, 0, 0, [0, 11, 20]],           #10
[1000000, 0, 0, [0, 2, 10, 12]],        #11
[1000000, 0, 0, [11, 13, 22]],          #12
[1000000, 0, 0, [3, 12, 23]],           #13
[1000000, 0, 0, [4, 15, 24]],           #14
[1000000, 0, 0, [4, 5, 6, 14]],         #15
[1000000, 0, 0, [6, 17, 25, 26, 27]],   #16
[1000000, 0, 0, [16, 18]],              #17
[1000000, 0, 0, [7, 8, 17, 19]],        #18
[1000000, 0, 0, [9, 18]],               #19
[1000000, 0, 0, [10, 31]],              #20
[1000000, 0, 0, [22]],                  #21
[1000000, 0, 0, [12, 21]],              #22
[1000000, 0, 0, [13, 24]],              #23
[1000000, 0, 0, [14, 23]],              #24
[1000000, 0, 0, [16, 35]],              #25
[1000000, 0, 0, [16, 36]],              #26
[1000000, 0, 0, [16, 38]],              #27
[1000000, 0, 0, [27, 29]],              #28
[1000000, 0, 0, [28, 39]],              #29
[1000000, 0, 0, [31]],                  #30
[1000000, 0, 0, [20, 30]],              #31
[1000000, 0, 0, [33, 42]],              #32
[1000000, 0, 0, [32, 34]],              #33
[1000000, 0, 0, [33, 35]],              #34
[1000000, 0, 0, [25, 34, 36]],          #35
[1000000, 0, 0, [26, 35, 37]],          #36
[1000000, 0, 0, [36, 38]],              #37
[1000000, 0, 0, [27, 37]],              #38
[1000000, 0, 0, [29, 49]],              #39
[1000000, 0, 0, [41, 50]],              #40
[1000000, 0, 0, [40, 52]],              #41
[1000000, 0, 0, [32, 43]],              #42
[1000000, 0, 0, [42, 44, 52]],          #43
[1000000, 0, 0, [43, 45, 54]],          #44
[1000000, 0, 0, [44, 46]],              #45
[1000000, 0, 0, [45, 47, 55, 57]],      #46
[1000000, 0, 0, [46, 48]],              #47
[1000000, 0, 0, [47, 49, 58]],          #48
[1000000, 0, 0, [39, 48, 58, 59]],      #49
[1000000, 0, 0, [40]],                  #50
[1000000, 0, 0, [52, 60]],              #51
[1000000, 0, 0, [41, 43, 51, 53]],      #52
[1000000, 0, 0, [52, 54]],              #53
[1000000, 0, 0, [44, 53, 55]],          #54
[1000000, 0, 0, [54, 46]],              #55
[1000000, 0, 0, [66]],                  #56
[1000000, 0, 0, [46, 58]],              #57
[1000000, 0, 0, [48, 49, 57]],          #58
[1000000, 0, 0, [49]],                  #59
[1000000, 0, 0, [51, 61, 70, 71]],      #60
[1000000, 0, 0, [60, 62]],              #61
[1000000, 0, 0, [61, 63, 72]],          #62
[1000000, 0, 0, [62, 64, 73]],          #63
[1000000, 0, 0, [63, 65, 74]],          #64
[1000000, 0, 0, [64, 66, 75, 76]],      #65
[1000000, 0, 0, [56, 65]],              #66
[1000000, 0, 0, [68, 76]],              #67
[1000000, 0, 0, [67, 69]],              #68
[1000000, 0, 0, [68, 78, 79]],          #69
[1000000, 0, 0, [60, 80]],              #70
[1000000, 0, 0, [60]],                  #71
[1000000, 0, 0, [62, 73]],              #72
[1000000, 0, 0, [63, 72, 74, 82]],      #73
[1000000, 0, 0, [64, 73, 75]],          #74
[1000000, 0, 0, [65, 74, 76]],          #75
[1000000, 0, 0, [65, 67, 75, 77]],      #76
[1000000, 0, 0, [76, 78]],              #77
[1000000, 0, 0, [69, 77]],              #78
[1000000, 0, 0, [69, 89]],              #79
[1000000, 0, 0, [70, 90]],              #80
[1000000, 0, 0, [82]],                  #81
[1000000, 0, 0, [73, 81]],              #82
[1000000, 0, 0, [84, 92]],              #83
[1000000, 0, 0, [83, 85]],              #84
[1000000, 0, 0, [84, 86, 95]],          #85
[1000000, 0, 0, [85, 87, 96]],          #86
[1000000, 0, 0, [86, 88, 97, 98]],      #87
[1000000, 0, 0, [87, 89]],              #88
[1000000, 0, 0, [79, 88, 99]],          #89
[1000000, 0, 0, [80, 91]],              #90
[1000000, 0, 0, [90, 92]],              #91
[1000000, 0, 0, [85, 91]],              #92
[1000000, 0, 0, [94]],                  #93
[1000000, 0, 0, [93, 95]],              #94
[1000000, 0, 0, [85, 94]],              #95
[1000000, 0, 0, [86]],                  #96
[1000000, 0, 0, [87]],                  #97
[1000000, 0, 0, [87]],                  #98
[1000000, 0, 0, [89]]]                  #99

startPoint = 0  # стартовая точка
finishPoint = 99 # конечная точка, не должна быть равна стартовой 

pointList = [finishPoint] # промежуточный список точек пути.
pathPointList =[startPoint] # конечный список точек пути

nav[finishPoint][0] = 0 # Устанавливаем стоимость конечной точки в 0

# Цикл работает от финишной точки к стартовой.
# Перебираем точки в промежуточном списке. В самом начале точка только одна -
# финишная.

for point in pointList:
    # Устанавливаем метку, что мы посетили эту точку.
    # В дальнейшем она будет игнорироваться, если снова попадется в списке
    # связанных точек.
    nav[point][1] = 1
   
    # Перебираем список связанных точек.   
    for relatedPoint in nav[point][3]:п
        # Если точка не была посещена, имеет большую стоимость и я сам не поиму,
        # что за условие я добавил, закоментирую пока, то:
        if nav[relatedPoint][1] == 0 and nav[point][0] + 1 < nav[relatedPoint][0]:# and nav[relatedPoint]:
            # Устанавливаем стоимость равной всему пути плюс один.
            nav[relatedPoint][0] = nav[point][0] + 1
            # Устанавливаем метку родителя, просто индекс
            nav[relatedPoint][2] = point
            # Добавляем связанную точку в промежуточный список
            pointList.append(relatedPoint)
            #print(pointList)
           
# А теперь соберем конечный путь
# Циклом переберем точки в конечном списке пути. Сначала в нем только одна
# точка - стартовая.
for navPoint in pathPointList:
    # Если точка-родитель не является конечной, то:
    if nav[navPoint][2] != finishPoint:
        # Добавляем её в окончательный список
        pathPointList.append(nav[navPoint][2])
    # Если точка - родитель конечная, то:
    elif nav[navPoint][2] == finishPoint:
        # Добавляем её в список и выходим из цикла
        pathPointList.append(nav[navPoint][2])
        break
# Изучаем полученный список(не обязательно:)
print(pathPointList)