首先我們根據我隨意設定的一個路徑建立一個字典

path = {
    "A":{"B", "C"},
    "B":{"A", "D", "E"},
    "C":{"A", "D"},
    "D":{"C", "E", "B", "F"},
    "E":{"B", "D"},
    "F":{"D"}
}

BFS需要用到隊列我直接使用的Python的雙端隊列，廣度優先搜索就是一層一層的搜索每搜索一層就把下一層加到隊列裏面。

def BFS(path, s):
    parent = {s:None}
    seen = set()
    seen.add(s)
    q 
 
= deque()
    q.append(s)
    while q:
        node = q.popleft()
        for w in path[node]:
            if w not in seen:
                seen.add(w)
                parent[w] = node
                q.append(w)
        print(node)
    return parent

DFS就是把隊列改成棧就行了，深度優先搜索就是先一條路走到黑，發現走不了再退回來換條路走。代碼就是把隊列換成棧。

def DFS(path, s):
    parent = {s:None}
    seen = set()
    seen.add(s)
    q = deque()
    q.append(s)
    while q:
        node = q.pop()
        for w in path[node]:
            if w not in seen:
                seen.add(w)
                parent[w] = node
                q.append(w)
        
 
print(node)

現在我們給每條路徑加上一個權值。

這樣我們的路徑就要加上一個權值了。

path = {
    "A":{"B":3, "C":2},
    "B":{"A":3, "D":2, "E":1},
    "C":{"A":2, "D":4},
    "D":{"C":4, "E":3, "B":2, "F":3},
    "E":{"B":1, "D":4},
    "F":{"D":3}
}
def init_distance(path, s):
    distance = {}
    for w in path:
        if w == s:
            distance[w] = 0
        else:
            distance[w] = float(‘inf‘)
    return distance

def dijkstra(path, s):
    parent = {s:None}
    seen = set()
    pq = []
    heapq.heappush(pq, (0, s))
    distance = init_distance(path, s)
    while pq:
        dist, vertex = heapq.heappop(pq)
        seen.add(vertex)
        for w in path[vertex]:
            if w not in seen and dist + path[w][vertex] < distance[w]:
                distance[w] = dist + path[w][vertex]
                parent[w] = vertex
                heapq.heappush(pq, (distance[w], w))
    return parent, distance
parent, distance = dijkstra(path, "A")
print(distance)
print(parent)
v = "F"
while v:
    print(v)
    v = parent[v]

深度優先搜索（BFS）和廣度優先搜索（ DFS)還有 迪傑斯特拉算法（dijkstra)