目錄

一、引入

二、具體細節

1、BFS（Breadth First Search）

2、Dijkstra（Uniform Cost Search）

3、啟發式（Heuristic search）

4、A*算法

4.1 算法細節

4.2 A與A*算法

4.3 A*算法證明

4.4 算法過程

三、具體實現

1、實驗要求

2、代碼實現

四、源代碼

---

一、引入

? ? ? ?當我開始學習該算法時，網上已經有了很多優秀的介紹性文章了。如果你看到了文章中出現了以下有著紅色星星★和紫色×的路徑圖：

? ? ? ? 那么該文章很大概率參考了Red Blob Games（點擊跳轉）的A*算法教程。該教程是一個很不錯的引入教程，有著很生動的交互式圖表和簡單易懂的描述過程。

????????以下通過BFS、貪婪BFS、Dijkstra算法作為引入逐步引入A*算法，使得對于A*算法有一個初步的整體了解。

????????Red Blob Games里面有三張圖來說明BFS、Dijkstra、A*算法的的區別，如果有點基礎的其實看完就知道個大概了：

? ? ? ? BFS（Breadth First Search?）：每一個方向都平等的擴展，因此它的探索軌跡是一圈又一圈的同心圓，像漣漪一樣一圈一圈均勻地往外擴展。

BFS算法

????????我們知道BFS擴展的時候是對一個節點的所有鄰接節點依次擴展，每個節點被擴展的機會是公平的，即各個鄰接節點的擴展機會一樣，順序任意。在迷宮問題中表現為，選一個節點的右、上、左、下（不一定要右上左下，你想上下左右都可以）節點加入到隊列里面，然后按放進去的順序從隊列取出來節點繼續擴展，同樣是將這個節點的右、上、左、下節點加入隊列。那么在迷宮上展現的過程就是對這個節點距離為1的一圈搜索一遍，然后又搜索距離為2的一圈、距離為3的一圈……

????????具體動畫效果如下：

????????從上面可以看到，對于迷宮問題以及其他路徑權重相等的圖搜索中，BFS是一種非常有用的算法。BFS一定可以搜索到所有可以到達的節點，它是一種暴力的窮盡查找算法，并且能找到最短路徑（前提所有邊權相等）。

? ? ? ? Dijkstra算法（Dijkstra’s Algorithm?）：某些節點（方向、路徑）會優先被探索，一般是那些具有更小代價的節點和路徑會被優先探索。因為該算法是用來求最短路的，算法正確性要求每次都要選擇當前已知的最短路進行探索，因此它的探索軌跡是隨機的、不均勻的，就像山脊的等高線圖一樣。

Dijkstra算法

????????Dijkstra相比BFS的區別就是此時圖的各條邊的邊權不同了，此時BFS不再適用。

? ? ? ? 還是迷宮問題，方塊里面的值表示起點★到該方塊的代價（cost）(可以理解為距離、花費的成本)，左圖中移動到相鄰方塊的代價都是1，右圖中移動到相鄰方塊的權值視方塊顏色而定：移動到棕色■的代價是1，移動到綠色■的代價是5，灰色■表示不可穿越的障礙。

左圖是BFS，右圖是Dijkstra

????????左圖中因為各個方塊代價一致，使用BFS算法，算法會直接穿過綠色區域到達終點×；右圖中因為方塊代價不同，使用Dijkstra算法，算法則會繞過綠色區域到達終點×。

????????它倆算法的執行動畫如下：? ? ? ?

左圖為BFS，右圖為Dijkstra

????????具體BFS和Dijkstra算法過程下面會詳細介紹，這里只需要知道他們應用的區別。

? ? ? ? A*算法：它優先考慮“似乎”更接近目標的路徑。該算法也是不斷尋找估計的“當前最有潛力”的節點，和Dijkstra算法一樣都是不均勻的山脊圖。但相比Dijkstra算法的雜亂無章的山脊軌跡，它是有目的性、方向性的，軌跡擴展方向總是選擇更靠近目標的那一側，下面的圖可以看到一直往尖端的一側伸展，因為在A*算法眼中那里更接近終點。

A*算法

? ? ? ? 它是對 Dijkstra 算法的修改，針對單個目標進行了優化。Dijkstra的算法可以發現到達所有位置的路徑。但是在我們尋路算法中，我們可能只需要尋找到達一個位置的路徑，這意味著Dijkstra算法中的一些額外開銷是不必要的。A*算法是一種單點對單點的路徑尋找算法，就像在LOL中點擊小地圖的某個位置，系統會自動尋路，得到通往目的位置的一條“白線”，來表示它是最短的路徑。

????????它會利用自己一些已知的啟發信息，來合理規劃自己的探索方向，避免了Dijkstra的一些盲目性。

二、具體細節

????????在這里需要提一點的是，下面討論的A*算法僅僅作為一種尋路算法，討論的也是僅限于圖中路徑的搜索。但其實A*算法不止適用于路徑搜索，它是一種啟發式的思想，它還可以用于其他問題如八數碼問題的求解，只是大多數問題最后化簡之后可以歸結為圖論（或者樹）的路徑求解，因此我們只需理解路徑搜索就能理解整個算法思想。

這是一個使用了A*算法的八數碼問題的求解過程，如果我們把每個正方形都看作圖的節點，指針看作權重為1的邊，那就是一棵樹（圖的特例）最短路徑的求解過程

????????這一點正如BFS算法，BFS也不僅僅適用于路徑搜索，例如算法題目中常用的暴力窮舉，但我們學習該算法的時候也只關心路徑的搜索，因為暴力窮舉最后實質上也是一棵根節點開始的搜索樹。

? ? ? ? ?同時為了方便理解，采用的都是網格圖，但是其實應用在所有類型的圖結構中都是一樣的、正確的。這不難理解，因為網格圖最終也可以化成節點+邊權為1的一般圖。

? ? ? ? BFS和Dijkstra算法我們再熟悉不過了，事實上不必多講。我們的重點是A*算法，這里具體展開BFS和Dijkstra的算法過程原因是，一方面是希望大家清楚地知道A*算法是如何得來的；另一方面，是我個人太喜歡這個網站的代碼圖和交互動畫了，真的是百看不厭。

1、BFS（Breadth First Search）

? ? ? ?BFS思想的關鍵就是不斷地擴展邊界（frontier）。

???????BFS的python代碼如下：

BFS最基礎的代碼

? ? ? ? 思路是：

????????先創建一個隊列(Queue，先進先出：先放進的節點先擴展)frontier，frontier用來存儲待擴展的節點，因此初始時需要將起點start★放進frontier；

? ? ? ? 再創建一個集合(Set，集合的元素無序且不會重復)reached，reached用來存儲已經到過的節點，就是我們常命名的visit。

? ? ? ? 只要frontier不為空，就從frontier中取出一個元素current進行擴展。對于的所有current鄰居 next，只要next不在reached里面（即沒有到達過），就把next放進frontier里面，然后放到reached標記為已經到達。

? ? ? ? 上面的BFS代碼沒有構建出一條路徑，僅僅告訴了我們如何遍歷圖上的所有點。因此需要進行修改，記錄我們是怎么到達每一個點的路徑。

? ? ? ? 黃色部分是修改的部分：

改進后的BFS代碼，能記錄路徑信息

? ? ? ? 這里用came_from替換了reached。

? ? ? ? came_from是字典(Dictionary，鍵值對，一個key對應value)，came_from不僅可以表示和reached一樣的功能（判斷一個節點是否到達過），方法是判斷came_from里面是不是存在key為這個節點的鍵值對；還能記錄每個點的前序節點，用came_from[節點i]來記錄，這樣當找到終點時就能順著前序節點一直尋找到起點。

? ? ? ? 還有一處修改部分是：之前是判斷是否在reached里面，不在的話直接放到reached集合里面；現在是判斷是否在came_from里面，不在的話存儲came_from[該節點的鄰居next]為當前擴展的current。

? ? ? ? ?當每個節點都存儲了從哪里來的信息后，整張圖的情況就是下面這樣：

? ? ? ? ?上面的指示箭頭就告訴了前序節點是誰，這樣當我們BFS找到終點時，我們就有了足夠的信息知道我們是怎么到達終點的，也就能重建這一條路徑。方法如下：

根據前序節點信息尋找路徑的方法

? ? ? ? ?從goal開始，順著came_from存儲的前序節點，一個一個地回溯到起點，期間不斷將路徑放到數組path里面，因為越靠近終點的節點越早放進去，所以存儲的path最后存儲的是一條從終點到起點的反向路徑，最后要將整個path反過來。

? ? ? ? 上面的BFS最后會遍歷完圖里的所有節點，也就是會知道起點到所有節點的最短路徑（前提是圖上邊權都相等，否則不是最短）。但實際上我們一般只需要求到某一個目標節點的路徑，因此很多過程是不必要的。原有的BFS一定是所有節點遍歷完才終止，而我們現在只需要遍歷到目標節點后就可以停下了，故我們可以及時終止。

? ? ? ? 過程如下，一旦找到目標節點，BFS就停止繼續擴展：

BFS找到終點后，不管此時frontier里面還有哪些節點沒擴展，都應該立刻停下來

? ? ? ? ?修改后的代碼如下，只需要加入一條及時終止的條件：

完全版的BFS代碼，尋找某個目標節點的最短路徑且能及時結束

????????當發現當前正要擴展的節點就是終點goal×時，代碼就結束了。

2、Dijkstra（Uniform Cost Search）

? ? ? ? 上面討論的BFS只能用于圖上每一條路徑的權重都相等的情況，如果圖中各條路徑權重不完全相同，那么再次采用BFS也能遍歷所有節點，但得不到最短路徑，因為最先遍歷到的不一定就是最短的。

? ? ? ? Dijkstra算法也很簡單，就是從起點開始，不斷擴展到當前耗費總代價最短的節點，直到到達終點（前提是邊權非負）。簡單證明思路就是，目前選擇的耗費最短的節點，之后再通過其他節點到達該節點的代價一定大于目前的代價。

? ? ? ? 因為需要尋找當前耗費總代價最短的節點，所以需要將原本的隊列（queue，先進先出）修改為優先隊列（priority queue，元素存在優先級，可以返回最大優先級的元素）。

? ? ? ? 同時除了記錄這個節點的前序節點came_from，還需要記錄當前到達這個節點的代價cost_so_far。

? ? ? ? 在BFS代碼基礎上進行修改：

? ? ? ? ?首先創建優先隊列frontier，將起點放進去，并且代價設置為0（python中的PriorityQueue的優先級的值越小，則表明優先級越高，越先被取出。但我印象中PriortyQueue的put([priority, value])的第一個參數是優先級第二個參數才是值）。

? ? ? ? 接著創建came_from用來記錄從哪來的，創建cost_so_far用來記錄目前到達的各個節點所花費的路徑總代價。

? ? ? ? 然后不斷地從frontier取出目前最小的代價的節點current進行擴展，直到最后到達goal結束。

? ? ? ? 擴展的方法變為：查找current的所有鄰接節點next，計算next的new_cost，計算方法是將current的當前代價cost_so_far[current]加上這一條鄰邊的代價graph.cost(current,next)。如果next是沒有到達過的節點或者new_cost小于已知的最短路節點，那么添加或者修改當前next的代價cost_so_far[next]，優先級設置為新的代價new_cost，并且將這一鍵值對加入到擴展的優先隊列frontier里面，最后記錄next的前序節點是current。

? ? ? ? 值得一提的是，Dijkstra算法的執行一般要求沒有負邊，但上面的Dijkstra實現代碼是可以處理含有正負邊的圖的，只是不能處理含有負環的圖。

????????原因在于，當擴展時發現一條更短的路時，會將其加入到優先隊列。一般的Dijkstra算法所有節點只會進入到優先隊列一次，但上述代碼一旦發現通過其他節點到達的某個節點x路徑更短，就會將節點x放入到優先隊列，而不管這個節點是否被擴展過，也就是給了這個節點再次修改最短路的機會。所以如果圖有負邊沒負環（意味著所有節點都存在一條最短路），使用上面代碼也能找到最短路。

? ? ? ? 效果圖如下：

????????

? ? ? ? 上圖中走綠色■方格耗費的代價大于棕色■，可以看到會先去探索一些棕色的格子然后再探索一些綠色的格子，即每次選擇當前耗費總路程最短的格子在擴展。

3、啟發式（Heuristic search）

? ? ? ? 上面兩種方法都是往各個方向擴展，當我們的目標是尋找到所有位置或者多個位置的路徑時這是合理的，但是如果我們僅僅是需要到一個位置的路徑，這樣的時間代價是不必要的。

? ? ? ? 我們的目的是讓邊界的擴展方向朝著目標位置擴展，而不是朝其他方向盲目擴展。為了實現上述目的，需要定義一個啟發式函數（heuristic?function），它將用來衡量我們目前的狀態離終點還有多遠。

? ? ? ? 在網格圖中常用的是曼哈頓距離，定義方式如下：

? ? ? ? ?如果我們只用啟發式函數計算出的距離作為優先級，即總是優先擴展離終點近的點，那么會得到如下結果：????????

? ? ? ? 可以看到在啟發式函數的幫助下，更快地尋找到了終點，而這正是它的優勢：速度快。

????????這種搜索方法是貪婪最優先搜索算法（Greedy Best First Search）

????????但是如果存在有障礙物的情況下，僅僅用啟發式函數的計算結果作為優先級可能不能得到正確結果。如下所示：? ? ? ?

? ? ? ? ?可以看到，僅靠啟發式函數計算的優先級并不能得出最短路徑，它舍棄了Dijstra算法每次擴展最短路徑節點這一保證正確性的優勢，也就不能保證得到一條最短路徑。

? ? ? ? 有沒有能同時兼顧速度和正確性的方法？那就是要下面要介紹的A*算法。

4、A*算法

4.1 算法細節

? ? ? ? Dijkstra算法可以很好的找到最短路徑，但是浪費了不必要的時間去探索沒有希望的方向；僅僅使用啟發式的貪婪最優先搜索算法（Greedy Best First Search）總是選擇最有希望的方向進行探索，但它可能找不到最優路徑。

? ? ? ? A*算法同時使用同時使用了上述兩種方法的信息：從起點到目前位置的實際距離和目前位置到終點的估計距離。

? ? ? ? A*算法通過如下公式來綜合考慮每個待擴展節點的優先級：

? ? ? ?

? ? ? ? 其中：

????????即待擴展節點的綜合優先級，他由和計算而來，我們仍然選擇待擴展節點中最小的進行擴展。

????????是節點距離起點的代價。

????????是節點距離終點的估計代價。

? ? ? ? 從上面公式來看，整體上繼承了Dijkstra算法的思想，總是拓展最短的節點，這樣能保證一旦搜索到終點時必然是最短路徑；同時的計算上又考慮了離終點的預估距離，減少或避免擴展個別沒有希望的節點，使得整體搜索過程趨向于有希望的方向。

? ? ? ? 應注意的是，上述的選取不是任意的，它是保證最終結果正確與否、搜索速度快慢的關鍵。越大，那么搜索速度越快，但也不是無限大，它有自己的限制條件。如果設距離終點的真正代價為，那么必須滿足如下要求才能保證尋找到最優解，即永遠不能大于真正的距離。

?????????

? ? ? ? 可以直觀地認為，是一種保守估計。

4.2 A與A*算法

????????要注意的一點是A算法和A*算法的區別。目前查找的資料沒有明確說明，對于兩者的定義也有些模糊，以下是兩種A*算法的說法：

? ? ? ? 第一種是認為A*算法即上面的思想。即上述就是，對于所有都滿足如下公式的A算法就是A*算法。

????????

? ? ? ? 第二種是認為在算法中對于往往存在了很多種估價函數，例如我們既可以采用曼哈頓距離，也可以采用對角距離，還可以采用歐幾里得距離，那么必然有多種估價函數、、等等。我們如果對A算法進一步限制，即如果且（即大于等于任意的估價函數），那么該算法就是A*算法。可以看到，這種定義下A*是最優的A算法。但實際應用中，我們往往難以判斷或者尋找到最優的估價函數，因此A*算法和A算法的區別并不是很重要，常常用A*算法表示這一種思想。

4.3 A*算法證明

? ? ? ? 對于上面A*算法的思想，我給出如下一種簡單的反證思路，可能有所紕漏，但是希望可以幫助理解：

? ? ? ? 假設A*算法找出的路徑不是最短路徑，那么A*算法結束時說明找到了一條更長的從起點到終點的路徑。我們要證明矛盾，只需要證明A*算法在這一條更長的路徑上不會順利地執行下去即可。

? ? ? ? 設起點為，終點為。設最短路徑為，A*算法找的路徑為。這條路徑上與路徑上第1個不同的節點為,接下來依次是,,,…（這些節點中可能有些與路徑上的相同，但無所謂，此時已經是一條不同的路徑）。設路徑上，節點的前一個節點為。同時令表示節點到終點的實際距離。如下所示：

????????假設當A*算法運行至時，不出意外的話就要擴展，即此時節點的是所有待擴展節點中最小的，所以會選擇。而我們要證明的恰恰就是這個“意外”，使得A*算法不會在之后選擇，也就不會在算法結束時選擇一條比最短路還長的路。

? ? ? ? 我們知道（到本身的實際距離為0），而是t到t的估計距離，必然小于，即，所以此時也是0。因此:

? ? ? ? 而表示的是目前到的實際距離，也就是路徑的長度。已知的路徑長度大于路徑的長度，而路徑的長度可以表示為，所以：

????????

? ? ? ? 而是到的估計距離，一定小于等于到的實際距離，所以：

? ? ? ? 所以：

? ? ? ?

? ? ? ? 即：

????????

? ? ? ? 也就是：

????????

? ? ? ? 所以我們知道，此時待擴展節點中，并不是最小值，我們有更小的節點來進行擴展。

? ? ? ? 當擴展之后，因為，同理可推出，所以接下來拓展的就是節點。我們可以類推最短路徑路徑上的余下的所有節點,,…，不妨設為，它們都滿足：?，可以同理推出。

? ? ? ? 也就是節點的永遠不會是待擴展節點中最小的，直到最短路徑上的余下節點被擴展完，節點都不會被擴展。當最短路徑?最后一個非節點被擴展后，自然擴展的就是t節點，此時算法結束。我們可以知道，結束時我們所找到的到的路徑正是而非，與我們假設的矛盾。

? ? ? ? 所以如果始終小于等于節點到終點的代價，則A*算法保證一定能夠找到最短路徑。當的值越小，算法將遍歷越多的節點，也就導致算法越慢。 如果很大，以至于完全等于節點到終點的真實代價，則A*算法將找到最佳路徑，并且速度很快。可惜的是，并非所有場景下都能做到這一點。因為在沒有達到終點之前，我們很難確切算出距離終點還有多遠。

? ? ? ? 對于評價函數，我們可以發現以下有趣的事情：

? ? ? ? ①當時，，說明此時完全依據所到達節點中的最短距離，就是Dijkstra算法。

? ? ? ? ②當時，就是貪婪最優先搜索算法（Greedy Best First Search）

4.4 算法過程

? ? ? ? 以下是算法的偽代碼，相比前面所說的Dijkstra算法過程只是加入了啟發式信息：

? ? ? ? 上面過程和Dijkstra過程較為相似，這里不再描述。

????????對于目前網上搜索的資料，與上述的過程基本相似，但是具體細節和叫法有所差別。一般說的open_set就是上述代碼的frontier。close_set類似于放入到cost_so_far后的節點，但是區別在于上面偽代碼是可以處理負邊無負環的圖，而一般的代碼不能處理。以下是另一種版本的算法過程：

1.初始化open_set和close_set； 2.將起點加入open_set中，并設置優先級為0（優先級越小表示優先級越高）； 3.如果open_set不為空，則從open_set中選取優先級最高的節點x：①如果節點x為終點，則：從終點開始逐步追蹤parent節點，一直到達起點，返回找到的結果路徑，算法結束；②如果節點x不是終點，則：1.將節點x從open_set中刪除，并加入close_set中；2.遍歷節點x所有的鄰近節點：①如果鄰近節點y在close_set中，則：跳過，選取下一個鄰近節點②如果鄰近節點y不在open_set中，則：設置節點m的parent為節點x，計算節點m的優先級，將節點m加入open_set中

? ? ? ? 在代碼實現時，我主要依據第一個偽代碼來實現。

三、具體實現

1、實驗要求

????????迷宮問題是實驗心理學中一個古典問題。迷宮從入口到出口可能有若干條通路，本實驗要求求出從入口到出口的最短路徑。

????????下圖是一個4×4的迷宮問題的示意圖，每個位置用平面坐標系中的點表示，如圖所示，入口位置點的坐標，出口位置點的坐標為。兩個點之間有線相連則代表兩個位置相通。若沒有線相連，則表示不通。

2、代碼實現

? ? ? ? 為了解決上述迷宮問題，我的思路是對上述矩形的迷宮的每個節點編號，從開始依次從左到右是0，1，2，3……這樣編號還有一個好處是可以很方便的直到該節點位于第幾行第幾列。

? ? ? ? 每個節點的鄰接表記錄相鄰的節點，因為是無向邊，所以一條邊會被記錄兩次。

? ? ? ? 具體算法過程根據上述偽代碼來編寫。

? ? ? ? 以下是實現代碼：

import numpy as np from queue import PriorityQueueclass Map: # 地圖def __init__(self, width, height) -> None:# 迷宮的尺寸self.width = widthself.height = height# 創建size x size 的點的鄰接表self.neighbor = [[] for i in range(width*height)]# 添加邊def addEdge(self, from_: int, to_: int):if (from_ not in range(self.width*self.height)) or (to_ not in range(self.width*self.height)):return 0self.neighbor[from_].append(to_)self.neighbor[to_].append(from_)return 1# 由序號獲得該點在迷宮的x、y坐標def get_x_y(self, num: int):if num not in range(self.width*self.height):return -1, -1x = num % self.widthy = num // self.widthreturn x, yclass Astar: # A*尋路算法def __init__(self, _map: Map, start: int, end: int) -> None:# 地圖self.run_map = _map# 起點和終點self.start = startself.end = end# open集self.open_set = PriorityQueue()# cost_so_far表示到達某個節點的代價，也可相當于close集使用self.cost_so_far = dict()# 每個節點的前序節點self.came_from = dict()# 將起點放入,優先級設為0，無所謂設置多少，因為總是第一個被取出self.open_set.put((0, start))self.came_from[start] = -1self.cost_so_far[start] = 0# h函數計算,即啟發式信息def heuristic(self, a, b):x1, y1 = self.run_map.get_x_y(a)x2, y2 = self.run_map.get_x_y(b)return abs(x1-x2) + abs(y1-y2)# 運行A*尋路算法，如果沒找到路徑返回0，找到返回1def find_way(self):# open表不為空while not self.open_set.empty():# 從優先隊列中取出代價最短的節點作為當前遍歷的節點，類型為(priority,node)current = self.open_set.get()# 找到終點if current[1] == self.end:break# 遍歷鄰接節點for next in self.run_map.neighbor[current[1]]:# 新的代價new_cost = self.cost_so_far[current[1]]+1# 沒有到達過的點 或 比原本已經到達過的點的代價更小if (next not in self.cost_so_far) or (new_cost < self.cost_so_far[next]):self.cost_so_far[next] = new_costpriority = new_cost+self.heuristic(next, self.end)self.open_set.put((priority, next))self.came_from[next] = current[1]if self.end not in self.cost_so_far:return 0return 1def show_way(self):# 記錄路徑經過的節點result = []current = self.end# 不斷尋找前序節點while self.came_from[current] != -1:result.append(current)current = self.came_from[current]# 加上起點result.append(current)# 翻轉路徑result.reverse()print(result)# 初始化迷宮 theMap = Map(4, 4) # 添加邊 theMap.addEdge(0, 1) theMap.addEdge(1, 2) theMap.addEdge(2, 6) theMap.addEdge(3, 7) theMap.addEdge(4, 5) theMap.addEdge(5, 6) theMap.addEdge(6, 7) theMap.addEdge(4, 8) theMap.addEdge(5, 9) theMap.addEdge(7, 11) theMap.addEdge(8, 9) theMap.addEdge(9, 10) theMap.addEdge(10, 11) theMap.addEdge(8, 12) theMap.addEdge(10, 14) theMap.addEdge(12, 13) theMap.addEdge(13, 14) theMap.addEdge(14, 15) # A* 算法尋路 theAstar = Astar(theMap, 0, 15) theAstar.find_way() theAstar.show_way()

? ? ? ? 運行之后得到如下結果：

[0, 1, 2, 6, 7, 11, 10, 14, 15]

? ? ? ? 也就是在圖上的路徑為：

? ? ? ? ?上述是代碼的主體，為了更好地實現結果的可視化，我使用python的matploblib庫來可視化。

? ? ? ? ?matploblib庫一般用來可視化數據圖表，我的思路是采用其畫圓函數Circle來繪制節點，畫矩形函數Rectangle來繪制邊，然后使用plt（matplotlib.pyplot）的ion()函數打開交互，繪制動態圖，呈現查找中的每一個階段。具體細節如下：

import numpy as np from queue import PriorityQueue import matplotlib.pyplot as plt import matplotlib.patches as mpathes import random# 畫布 fig, ax = plt.subplots()class Map: # 地圖def __init__(self, width, height) -> None:# 迷宮的尺寸self.width = widthself.height = height# 創建size x size 的點的鄰接表self.neighbor = [[] for i in range(width*height)]def addEdge(self, from_: int, to_: int): # 添加邊if (from_ not in range(self.width*self.height)) or (to_ not in range(self.width*self.height)):return 0self.neighbor[from_].append(to_)self.neighbor[to_].append(from_)return 1def get_x_y(self, num: int): # 由序號獲得該點在迷宮的x、y坐標if num not in range(self.width*self.height):return -1, -1x = num % self.widthy = num // self.widthreturn x, ydef drawCircle(self, num, color): # 繪制圓形x, y = self.get_x_y(num)thePoint = mpathes.Circle(np.array([x+1, y+1]), 0.1, color=color)# 聲明全局變量global axax.add_patch(thePoint)def drawEdge(self, from_, to_, color): # 繪制邊# 轉化為(x,y)x1, y1 = self.get_x_y(from_)x2, y2 = self.get_x_y(to_)# 整體向右下方移動一個單位x1, y1 = x1+1, y1+1x2, y2 = x2+1, y2+1# 繪長方形代表邊offset = 0.05global axif from_-to_ == 1: # ← 方向的邊rect = mpathes.Rectangle(np.array([x2-offset, y2-offset]), 1+2*offset, 2*offset, color=color)ax.add_patch(rect)elif from_-to_ == -1: # → 方向的邊rect = mpathes.Rectangle(np.array([x1-offset, y1-offset]), 1+2*offset, 2*offset, color=color)ax.add_patch(rect)elif from_-to_ == self.width: # ↑ 方向的邊rect = mpathes.Rectangle(np.array([x2-offset, y2-offset]), 2*offset, 1+2*offset, color=color)ax.add_patch(rect)else: # ↓ 方向的邊rect = mpathes.Rectangle(np.array([x1-offset, y1-offset]), 2*offset, 1+2*offset, color=color)ax.add_patch(rect)def initMap(self): # 繪制初始的迷宮# 先繪制邊for i in range(self.width*self.height):for next in self.neighbor[i]:self.drawEdge(i, next, '#afeeee')# 再繪制點for i in range(self.width*self.height):self.drawCircle(i, '#87cefa')class Astar: # A*尋路算法def __init__(self, _map: Map, start: int, end: int) -> None:# 地圖self.run_map = _map# 起點和終點self.start = startself.end = end# open集self.open_set = PriorityQueue()# cost_so_far表示到達某個節點的代價，也可相當于close集使用self.cost_so_far = dict()# 每個節點的前序節點self.came_from = dict()# 將起點放入,優先級設為0，無所謂設置多少，因為總是第一個被取出self.open_set.put((0, start))self.came_from[start] = -1self.cost_so_far[start] = 0# 標識起點和終點self.run_map.drawCircle(start, '#ff8099')self.run_map.drawCircle(end, '#ff4d40')def heuristic(self, a, b): # h函數計算,即啟發式信息x1, y1 = self.run_map.get_x_y(a)x2, y2 = self.run_map.get_x_y(b)return abs(x1-x2) + abs(y1-y2)def find_way(self): # 運行A*尋路算法，如果沒找到路徑返回0，找到返回1while not self.open_set.empty(): # open表不為空# 從優先隊列中取出代價最短的節點作為當前遍歷的節點，類型為(priority,node)current = self.open_set.get()# 展示A*算法的執行過程if current[1] != self.start:# 當前節點的前序pre = self.came_from[current[1]]# 可視化self.run_map.drawEdge(pre, current[1], '#fffdd0')if pre != self.start:self.run_map.drawCircle(pre, '#99ff4d')else: # 起點不改色self.run_map.drawCircle(pre, '#ff8099')if current[1] != self.end:self.run_map.drawCircle(current[1], '#99ff4d')else:self.run_map.drawCircle(current[1], '#ff4d40')# 顯示當前狀態plt.show()plt.pause(0.5)# 找到終點if current[1] == self.end:break# 遍歷鄰接節點for next in self.run_map.neighbor[current[1]]:# 新的代價new_cost = self.cost_so_far[current[1]]+1# 沒有到達過的點 或 比原本已經到達過的點的代價更小if (next not in self.cost_so_far) or (new_cost < self.cost_so_far[next]):self.cost_so_far[next] = new_costpriority = new_cost+self.heuristic(next, self.end)self.open_set.put((priority, next))self.came_from[next] = current[1]def show_way(self): # 顯示最短路徑# 記錄路徑經過的節點result = []current = self.endif current not in self.cost_so_far:return# 不斷尋找前序節點while self.came_from[current] != -1:result.append(current)current = self.came_from[current]# 加上起點result.append(current)# 翻轉路徑result.reverse()# 生成路徑for point in result:if point != self.start: # 不是起點# 當前節點的前序pre = self.came_from[point]# 可視化self.run_map.drawEdge(pre, point, '#ff2f76')if pre == self.start: # 起點顏色self.run_map.drawCircle(pre, '#ff8099')elif point == self.end: # 終點顏色self.run_map.drawCircle(point, '#ff4d40')# 顯示當前狀態plt.show()plt.pause(0.1)def get_cost(self): # 返回最短路徑if self.end not in self.cost_so_far:return -1return self.cost_so_far[self.end]# 初始化迷宮 theMap = Map(4, 4)# 設置迷宮顯示的一些參數 plt.xlim(0, theMap.width+1) plt.ylim(0, theMap.height+1) # 將x軸的位置設置在頂部 ax.xaxis.set_ticks_position('top') # y軸反向 ax.invert_yaxis() # 等距 plt.axis('equal') # 不顯示背景的網格線 plt.grid(False) # 允許動態 plt.ion() # 添加邊 theMap.addEdge(0, 1) theMap.addEdge(1, 2) theMap.addEdge(2, 6) theMap.addEdge(3, 7) theMap.addEdge(4, 5) theMap.addEdge(5, 6) theMap.addEdge(6, 7) theMap.addEdge(4, 8) theMap.addEdge(5, 9) theMap.addEdge(7, 11) theMap.addEdge(8, 9) theMap.addEdge(9, 10) theMap.addEdge(10, 11) theMap.addEdge(8, 12) theMap.addEdge(10, 14) theMap.addEdge(12, 13) theMap.addEdge(13, 14) theMap.addEdge(14, 15)# 初始化迷宮 theMap.initMap()# A* 算法尋路 theAstar = Astar(theMap, 0, 15) theAstar.find_way() theAstar.show_way()# 輸出最短路徑長度 theCost = theAstar.get_cost() if theCost == -1:print("不存在該路徑！") else:print("從起點到終點的最短路徑長度為: ", theCost)# 關閉交互，展示結果 plt.ioff() plt.show()

? ? ? ? 運行效果如下：

? ? ? ? ?輸出結果如下：

從起點到終點的最短路徑長度為: 8

? ? ? ? ?對于稍微大一點的圖(6x6)進行測試：

# 初始化迷宮 theMap = Map(6, 6)# 設置迷宮顯示的一些參數 plt.xlim(0, theMap.width+1) plt.ylim(0, theMap.height+1) # 將x軸的位置設置在頂部 ax.xaxis.set_ticks_position('top') # y軸反向 ax.invert_yaxis() # 等距 plt.axis('equal') # 不顯示背景的網格線 plt.grid(False) # 允許動態 plt.ion()# 添加邊 theMap.addEdge(0, 1) theMap.addEdge(1, 2) theMap.addEdge(2, 3) theMap.addEdge(3, 4) theMap.addEdge(4, 5) theMap.addEdge(1, 7) theMap.addEdge(3, 9) theMap.addEdge(4, 10) theMap.addEdge(5, 11) theMap.addEdge(6, 7) theMap.addEdge(8, 9) theMap.addEdge(6, 12) theMap.addEdge(7, 13) theMap.addEdge(8, 14) theMap.addEdge(10, 16) theMap.addEdge(11, 17) theMap.addEdge(12, 13) theMap.addEdge(13, 14) theMap.addEdge(15, 16) theMap.addEdge(16, 17) theMap.addEdge(14, 20) theMap.addEdge(15, 21) theMap.addEdge(16, 22) theMap.addEdge(17, 23) theMap.addEdge(18, 19) theMap.addEdge(19, 20) theMap.addEdge(20, 21) theMap.addEdge(22, 23) theMap.addEdge(18, 24) theMap.addEdge(19, 25) theMap.addEdge(20, 26) theMap.addEdge(22, 28) theMap.addEdge(26, 27) theMap.addEdge(27, 28) theMap.addEdge(24, 30) theMap.addEdge(27, 33) theMap.addEdge(29, 35) theMap.addEdge(30, 31) theMap.addEdge(31, 32) theMap.addEdge(33, 34) theMap.addEdge(34, 35)# 初始化迷宮 theMap.initMap()# A* 算法尋路 theAstar = Astar(theMap, 0, 35) theAstar.find_way() theAstar.show_way()# 輸出最短路徑長度 theCost = theAstar.get_cost() if theCost == -1:print("不存在該路徑！") else:print("從起點到終點的最短路徑長度為: ", theCost)# 關閉交互，展示結果 plt.ioff() plt.show()

? ? ? ? 運行結果：

????????

? ? ? ? ?輸出結果：

從起點到終點的最短路徑長度為: 10

????????可以知道，運行結果正確。

? ? ? ? 但我們發現，每一次輸入一個新的圖都得輸入一大堆邊，對于復雜一點的圖很不方便調試。有沒有一種方法，能在我們設置迷宮的大小后讓程序自己隨機生成迷宮？

? ? ? ? 為此，我們可以編寫一個隨機生成迷宮的函數。

? ? ? ? 我采用的隨機生成方法是簡單的深度搜索法。初始狀態下的迷宮沒有邊，只有指定大小的節點陣列。從起點開始，依次探索四個方向（四個方向的探索順序隨機），如果該方向的鄰接點沒有被探索過，那么生成一條邊，同時前進到該點。對于該點繼續重復上面過程，直到所有點被探索完，算法終止。

# 尋找def search(self, current: int):# 四個方向的順序sequence = [i for i in range(4)]# 打亂順序random.shuffle(sequence)# 依次選擇四個方向for i in sequence:# 要探索的位置x = self.direction[i]+current# 跨了一行if (current % self.width == self.width-1 and self.direction[i] == 1) or (current % self.width == 0 and self.direction[i] == -1):continue# 要探索的位置沒有超出范圍 且 該位置沒有被探索過if 0 <= x < self.width*self.height and self.visited[x] == 0:self.addEdge(current, x)self.visited[x] = 1self.search(x)def randomCreateMap(self, start, k): # 隨機生成迷宮# 標識每個節點是否被探索過self.visited = np.zeros(self.width*self.height)self.visited[start] = 1# 四個方向,分別代表上、下、左、右self.direction = {0: -self.width,1: self.width,2: -1,3: 1}# 從起點開始self.search(start)

? ? ? ? 以下是隨機生成的10x10、20x20、30x25迷宮：

10x10，起點在0，終點在99 20x20，起點在0，終點在399

?????????

30x25，起點在0，終點在500

? ? ? ? ?可以看到生成的迷宮效果不錯，可以滿足基本需要。但因為生成迷宮的算法使用的是深度搜索，所以導致起點到終點的路徑有且僅有一條。這對于我們尋找最短路徑而言，似乎無法說明，因為一旦找到了終點那必定是最短路。因此我們對迷宮增加復雜度，也就是隨機在迷宮里面添加k條邊，使得圖存在多條路徑。

# 隨機添加k條邊def randomAddEdges(self, k):# 循環k次(可能不止k次)for i in range(k):node = random.randint(0, self.width*self.height)# 隨機添加一個方向sequence = [i for i in range(4)]random.shuffle(sequence)isPick = 0for d in sequence:# 跨了一行,不存在該方向的邊if (node % self.width == self.width-1 and self.direction[d] == 1) or (node % self.width == 0 and self.direction[d] == -1):continuex = self.direction[d]+node# 該邊存在if x in self.neighbor[node]:continue# 該邊不存在self.addEdge(node, x)isPick = 1# 重新添加一條邊,即重新循環一次if isPick == 0:if i == 0: # 第一次i = 0else:i -= 1

? ? ? ? 生成后的迷宮如下：

? ? ? ? 可以看到多了很多冗余路徑，使得起點到終點的路徑不止一條。

? ? ? ? 將A*算法應用于隨機生成的迷宮：

????????

? ? ? ? ?輸出結果如下：

從起點到終點的最短路徑長度為: 18

????????

????????輸出結果如下：

從起點到終點的最短路徑長度為: 28

????????

? ? ? ? ?輸出結果如下：

從起點到終點的最短路徑長度為: 50

四、源代碼

import numpy as np from queue import PriorityQueue import matplotlib.pyplot as plt import matplotlib.patches as mpathes import random# 畫布 fig, ax = plt.subplots()class Map: # 地圖def __init__(self, width, height) -> None:# 迷宮的尺寸self.width = widthself.height = height# 創建size x size 的點的鄰接表self.neighbor = [[] for i in range(width*height)]def addEdge(self, from_: int, to_: int): # 添加邊if (from_ not in range(self.width*self.height)) or (to_ not in range(self.width*self.height)):return 0self.neighbor[from_].append(to_)self.neighbor[to_].append(from_)return 1def get_x_y(self, num: int): # 由序號獲得該點在迷宮的x、y坐標if num not in range(self.width*self.height):return -1, -1x = num % self.widthy = num // self.widthreturn x, ydef drawCircle(self, num, color): # 繪制圓形x, y = self.get_x_y(num)thePoint = mpathes.Circle(np.array([x+1, y+1]), 0.1, color=color)# 聲明全局變量global axax.add_patch(thePoint)def drawEdge(self, from_, to_, color): # 繪制邊# 轉化為(x,y)x1, y1 = self.get_x_y(from_)x2, y2 = self.get_x_y(to_)# 整體向右下方移動一個單位x1, y1 = x1+1, y1+1x2, y2 = x2+1, y2+1# 繪長方形代表邊offset = 0.05global axif from_-to_ == 1: # ← 方向的邊rect = mpathes.Rectangle(np.array([x2-offset, y2-offset]), 1+2*offset, 2*offset, color=color)ax.add_patch(rect)elif from_-to_ == -1: # → 方向的邊rect = mpathes.Rectangle(np.array([x1-offset, y1-offset]), 1+2*offset, 2*offset, color=color)ax.add_patch(rect)elif from_-to_ == self.width: # ↑ 方向的邊rect = mpathes.Rectangle(np.array([x2-offset, y2-offset]), 2*offset, 1+2*offset, color=color)ax.add_patch(rect)else: # ↓ 方向的邊rect = mpathes.Rectangle(np.array([x1-offset, y1-offset]), 2*offset, 1+2*offset, color=color)ax.add_patch(rect)def initMap(self): # 繪制初始的迷宮# 先繪制邊for i in range(self.width*self.height):for next in self.neighbor[i]:self.drawEdge(i, next, '#afeeee')# 再繪制點for i in range(self.width*self.height):self.drawCircle(i, '#87cefa')# 尋找def search(self, current: int):# 四個方向的順序sequence = [i for i in range(4)]# 打亂順序random.shuffle(sequence)# 依次選擇四個方向for i in sequence:# 要探索的位置x = self.direction[i]+current# 跨了一行if (current % self.width == self.width-1 and self.direction[i] == 1) or (current % self.width == 0 and self.direction[i] == -1):continue# 要探索的位置沒有超出范圍 且 該位置沒有被探索過if 0 <= x < self.width*self.height and self.visited[x] == 0:self.addEdge(current, x)self.visited[x] = 1self.search(x)# 隨機添加k條邊def randomAddEdges(self, k):# 循環k次(可能不止k次)for i in range(k):node = random.randint(0, self.width*self.height)# 隨機添加一個方向sequence = [i for i in range(4)]random.shuffle(sequence)isPick = 0for d in sequence:# 跨了一行,不存在該方向的邊if (node % self.width == self.width-1 and self.direction[d] == 1) or (node % self.width == 0 and self.direction[d] == -1):continuex = self.direction[d]+node# 該邊存在if x in self.neighbor[node]:continue# 該邊不存在self.addEdge(node, x)isPick = 1# 重新添加一條邊,即重新循環一次if isPick == 0:if i == 0: # 第一次i = 0else:i -= 1def randomCreateMap(self, start, k): # 隨機生成迷宮# 標識每個節點是否被探索過self.visited = np.zeros(self.width*self.height)self.visited[start] = 1# 四個方向,分別代表上、下、左、右self.direction = {0: -self.width,1: self.width,2: -1,3: 1}# 從起點開始self.search(start)# 隨機添加k條邊，使得迷宮盡可能出現多條到達終點的路徑self.randomAddEdges(k)class Astar: # A*尋路算法def __init__(self, _map: Map, start: int, end: int) -> None:# 地圖self.run_map = _map# 起點和終點self.start = startself.end = end# open集self.open_set = PriorityQueue()# cost_so_far表示到達某個節點的代價，也可相當于close集使用self.cost_so_far = dict()# 每個節點的前序節點self.came_from = dict()# 將起點放入,優先級設為0，無所謂設置多少，因為總是第一個被取出self.open_set.put((0, start))self.came_from[start] = -1self.cost_so_far[start] = 0# 標識起點和終點self.run_map.drawCircle(start, '#ff8099')self.run_map.drawCircle(end, '#ff4d40')def heuristic(self, a, b): # h函數計算,即啟發式信息x1, y1 = self.run_map.get_x_y(a)x2, y2 = self.run_map.get_x_y(b)return abs(x1-x2) + abs(y1-y2)def find_way(self): # 運行A*尋路算法，如果沒找到路徑返回0，找到返回1while not self.open_set.empty(): # open表不為空# 從優先隊列中取出代價最短的節點作為當前遍歷的節點，類型為(priority,node)current = self.open_set.get()# 展示A*算法的執行過程if current[1] != self.start:# 當前節點的前序pre = self.came_from[current[1]]# 可視化self.run_map.drawEdge(pre, current[1], '#fffdd0')if pre != self.start:self.run_map.drawCircle(pre, '#99ff4d')else: # 起點不改色self.run_map.drawCircle(pre, '#ff8099')if current[1] != self.end:self.run_map.drawCircle(current[1], '#99ff4d')else:self.run_map.drawCircle(current[1], '#ff4d40')# 顯示當前狀態plt.show()plt.pause(0.01)# 找到終點if current[1] == self.end:break# 遍歷鄰接節點for next in self.run_map.neighbor[current[1]]:# 新的代價new_cost = self.cost_so_far[current[1]]+1# 沒有到達過的點 或 比原本已經到達過的點的代價更小if (next not in self.cost_so_far) or (new_cost < self.cost_so_far[next]):self.cost_so_far[next] = new_costpriority = new_cost+self.heuristic(next, self.end)self.open_set.put((priority, next))self.came_from[next] = current[1]def show_way(self): # 顯示最短路徑# 記錄路徑經過的節點result = []current = self.endif current not in self.cost_so_far:return# 不斷尋找前序節點while self.came_from[current] != -1:result.append(current)current = self.came_from[current]# 加上起點result.append(current)# 翻轉路徑result.reverse()# 生成路徑for point in result:if point != self.start: # 不是起點# 當前節點的前序pre = self.came_from[point]# 可視化self.run_map.drawEdge(pre, point, '#ff2f76')if pre == self.start: # 起點顏色self.run_map.drawCircle(pre, '#ff8099')elif point == self.end: # 終點顏色self.run_map.drawCircle(point, '#ff4d40')# 顯示當前狀態plt.show()plt.pause(0.005)def get_cost(self): # 返回最短路徑if self.end not in self.cost_so_far:return -1return self.cost_so_far[self.end]# 初始化迷宮，設置寬度和高度 theMap = Map(20, 20)# 設置迷宮顯示的一些參數 plt.xlim(0, theMap.width+1) plt.ylim(0, theMap.height+1) # 將x軸的位置設置在頂部 ax.xaxis.set_ticks_position('top') # y軸反向 ax.invert_yaxis() # 等距 plt.axis('equal') # 不顯示背景的網格線 plt.grid(False) # 允許動態 plt.ion()# 隨機添加邊，生成迷宮，第一個參數為起點；第二個參數為額外隨機生成的邊，可以表示為圖的復雜程度 theMap.randomCreateMap(0, 20)# 初始化迷宮 theMap.initMap()# A* 算法尋路 theAstar = Astar(theMap, 0, 399) # 設置起點和終點 theAstar.find_way() # 尋路 theAstar.show_way() # 顯示最短路徑# 輸出最短路徑長度 theCost = theAstar.get_cost() if theCost == -1:print("不存在該路徑！") else:print("從起點到終點的最短路徑長度為: ", theCost)# 關閉交互，展示結果 plt.ioff() plt.show()

總結

以上是生活随笔為你收集整理的A*算法求解迷宫问题（算法讲解与证明、python实现与可视化）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。