a演算法教程

Ⅰ 關於A*演算法和3D演算法

A*演算法是一種啟發式搜索的演算法，公式表示為： f(n)=g(n)+h(n)g(n) 是在狀態空間中從初始節點到n節點的實際代價，
h(n)是從n到目標節點最佳路徑的估計代價。3D演算法，沒看懂你說什麼意思

Ⅱ A*演算法應用，大家給點介紹，做課程設計

維基網路有很多的，大陸訪問不了，可以設置個香港代理。

SHA 家族
[編輯首段]維基網路，自由的網路全書
跳轉到: 導航, 搜尋
安全散列演演演算法能計算出一個數位訊息所對應到的，長度固定的字串（又稱訊息摘要）。且若輸入的訊息不同，它們對應到不同字串的機率很高；而 SHA 是FIPS所認證的五種安全雜湊演演演算法。這些演演演算法之所以稱作「安全」是基於以下兩點（根據官方標準的描述）：「1)由訊息摘要反推原輸入訊息，從計算理論上來說是很困難的。2)想要找到兩組不同的訊息對應到相同的訊息摘要，從計算理論上來說也是很困難的。任何對輸入訊息的變動，都有很高的機率導致其產生的訊息摘要迥異。」

SHA 家族的五個演演演算法，分別是SHA-1, SHA-224, SHA-256, SHA-384, 和 SHA-512，由美國國家安全局 (NSA) 所設計，並由美國國家標准與技術研究院（NIST） 發布；是美國的政府標准。後四者有時並稱為SHA-2。SHA-1 在許多安全協定中廣為使用，包括 TLS 和 SSL、 PGP、SSH、S/MIME 和 IPsec，曾被視為是 MD5（更早之前被廣為使用的雜湊函數）的後繼者。但 SHA-1 的安全性如今被密碼學家嚴重質疑；雖然至今尚未出現對 SHA-2 有效的攻擊，它的演演演算法跟 SHA-1 基本上仍然相似；因此有些人開始發展其他替代的雜湊演演演算法。緣於最近對 SHA-1 的種種攻擊發表，「美國國家標准與技術研究院（NIST）開始設法經由公開競爭管道（類似高級加密標准AES的發展經過），發展一個或多個新的雜湊演演演算法。」

目錄 [隱藏]
1 SHA-0 和 SHA-1
1.1 SHA-0 的破解
1.2 SHA-1 的破解
2 SHA-2
3 SHA 所定義的長度
4 SHAd
5 應用
6 SHA-1 演演演算法
7 SHA-2 演演演算法
8 參見
9 參考資料
10 外部鏈結

[編輯] SHA-0 和 SHA-1

SHA-1 壓縮演演演算法中的一個迴圈。A, B, C, D 和 E 是這個state中的 32 位元文字；F 是會變化的非線性函數；<<<n 代表bit向左循環移動n個位置。n因操作而異。田代表molo 232之下的加法，Kt 是一個常數。最初載明的演演演算法於 1993年發布，稱做安全雜湊標准 (Secure Hash Standard)，FIPS PUB 180。這個版本現在常被稱為 SHA-0。它在發布之後很快就被 NSA 撤回，並且由 1995年發布的修訂版本 FIPS PUB 180-1 (通常稱為 SHA-1) 取代。SHA-1 和 SHA-0 的演演演算法只在壓縮函數的訊息轉換部份差了一個位元的循環位移。根據 NSA 的說法，它修正了一個在原始演演演算法中會降低密碼安全性的錯誤。然而 NSA 並沒有提供任何進一步的解釋或證明該錯誤已被修正。而後 SHA-0 和 SHA-1 的弱點相繼被攻破，SHA-1 似乎是顯得比 SHA-0 有抵抗性，這多少證實了 NSA 當初修正演演演算法以增進安全性的聲明。

SHA-0 和 SHA-1 可將一個最大 264 位元的訊息，轉換成一串 160 位元的訊息摘要；其設計原理相似於 MIT 教授 Ronald L. Rivest 所設計的密碼學雜湊演演演算法 MD4 和 MD5。

[編輯] SHA-0 的破解
在 CRYPTO 98 上，兩位法國研究者提出一種對 SHA-0 的攻擊方式 (Chabaud and Joux, 1998): 在 261的計算復雜度之內，就可以發現一次碰撞（即兩個不同的訊息對應到相同的訊息摘要）；這個數字小於 280 ，也就是說，其安全性不到一個理想的雜湊函數抵抗攻擊所應具備的計算復雜度。

2004年時，Biham 和 Chen 也發現了 SHA-0 的近似碰撞 — 兩個訊息可以雜湊出幾乎相同的數值；其中 162 位元中有 142 位元相同。他們也發現了 SHA-0 的完整碰撞（相對於近似碰撞），將本來需要 80 次方的復雜度降低到 62 次方。

2004年8月12日，Joux, Carribault, Lemuet 和 Jalby 宣布找到 SHA-0 演演演算法的完整碰撞的方法，這是歸納 Chabaud 和 Joux 的攻擊所完成的結果。發現一個完整碰撞只需要 251的計算復雜度。他們使用的是一台有 256 顆 Itanium2 處理器的超級電腦，約耗 80,000 CPU 工時 [1]。

2004年8月17日，在 CRYPTO 2004 的 Rump 會議上，王小雲, 馮登國 (Feng), 來學嘉 (Lai), 和於紅波 (Yu) 宣布了攻擊 MD5、SHA-0 和其他雜湊函數的初步結果。他們攻擊 SHA-0 的計算復雜度是 240，這意謂的他們的攻擊成果比 Joux 還有其他人所做的更好。請參見 MD5 安全性。2005 年二月，王小雲和殷益群、於紅波再度發表了對 SHA-0 破密的演演演算法，可在 239 的計算復雜度內就找到碰撞。

[編輯] SHA-1 的破解
鑒於 SHA-0 的破密成果，專家們建議那些計畫利用 SHA-1 實作密碼系統的人們也應重新考慮。2004 年 CRYPTO 會議結果公布之後，NIST 即宣布他們將逐漸減少使用 SHA-1，改以 SHA-2 取而代之。

2005年，Rijmen 和 Oswald 發表了對 SHA-1 較弱版本（53次的加密迴圈而非80次）的攻擊：在 280 的計算復雜度之內找到碰撞。

2005年二月，王小雲、殷益群及於紅波發表了對完整版 SHA-1 的攻擊，只需少於 269 的計算復雜度，就能找到一組碰撞。（利用暴力搜尋法找到碰撞需要 280 的計算復雜度。）

這篇論文的作者們寫道；「我們的破密分析是以對付 SHA-0 的差分攻擊、近似碰撞、多區塊碰撞技術、以及從 MD5 演演演算法中尋找碰撞的訊息更改技術為基礎。沒有這些強力的分析工具，SHA-1 就無法破解。」此外，作者還展示了一次對 58 次加密迴圈 SHA-1 的破密，在 233 個單位操作內就找到一組碰撞。完整攻擊方法的論文發表在 2005 年八月的 CRYPTO 會議中。

殷益群在一次面談中如此陳述：「大致上來說，我們找到了兩個弱點：其一是前置處理不夠復雜；其二是前 20 個迴圈中的某些數學運算會造成不可預期的安全性問題。」

2005 年八月 17 的 CRYPTO 會議尾聲中王小雲、姚期智、姚儲楓再度發表更有效率的 SHA-1 攻擊法，能在 263 個計算復雜度內找到碰撞。

在密碼學的學術理論中，任何攻擊方式，其計算復雜度若少於暴力搜尋法所需要的計算復雜度，就能被視為針對該密碼系統的一種破密法；這並不表示該破密法已經可以進入實際應用的階段。

就應用層面的考量而言，一種新的破密法出現，暗示著將來可能會出現更有效率、足以實用的改良版本。雖然這些實用的破密法版本根本還沒誕生，但確有必要發展更強的雜湊演演演算法來取代舊的演演演算法。在「碰撞」攻擊法之外，另有一種反譯攻擊法，就是由雜湊出的字串反推原本的訊息；反譯攻擊的嚴重性更在碰撞攻擊之上。 在許多會應用到密碼雜湊的情境（如用戶密碼的存放、文件的數位簽章等）中，碰撞攻擊的影響並不是很大。舉例來說，一個攻擊者可能不會只想要偽造一份一模一樣的文件，而會想改造原來的文件，再附上合法的簽章，來愚弄持有私密金鑰的驗證者。另一方面，如果可以從密文中反推未加密前的使用者密碼，攻擊者就能利用得到的密碼登入其他使用者的帳戶，而這種事在密碼系統中是不能被允許的。但若存在反譯攻擊，只要能得到指定使用者密碼雜湊過後的字串（通常存在影檔中，而且可能不會透露原密碼資訊），就有可能得到該使用者的密碼。

2006 年的 CRYPTO 會議上，Christian Rechberger 和 Christophe De Cannière 宣布他們能在容許攻擊者決定部分原訊息的條件之下，找到 SHA-1 的一個碰撞。

[編輯] SHA-2

SHA-2 的第t個加密迴圈。圖中的深藍色方塊是事先定義好的非線性函數。ABCDEFGH一開始分別是八個初始值，Kt是第t個金鑰，Wt是本區塊產生第t個word。原訊息被切成固定長度的區塊，對每一個區塊，產生n個word（n視演演演算法而定），透過重復運作迴圈n次對ABCDEFGH這八個工作區段循環加密。最後一次迴圈所產生的八段字串合起來即是此區塊對應到的雜湊字串。若原訊息包含數個區塊，則最後還要將這些區塊產生的雜湊字串加以混合才能產生最後的雜湊字串。NIST 發布了三個額外的 SHA 變體，這三個函數都將訊息對應到更長的訊息摘要。以它們的摘要長度 (以位元計算) 加在原名後面來命名：SHA-256，SHA-384 和 SHA-512。它們發布於 2001年的 FIPS PUB 180-2 草稿中，隨即通過審查和評論。包含 SHA-1 的 FIPS PUB 180-2，於 2002年以官方標准發布。2004年2月，發布了一次 FIPS PUB 180-2 的變更通知，加入了一個額外的變種 "SHA-224"，這是為了符合雙金鑰 3DES 所需的金鑰長度而定義。

SHA-256 和 SHA-512 是很新的雜湊函數，前者以定義一個word為32位元，後者則定義一個word為64位元。它們分別使用了不同的偏移量，或用不同的常數，然而，實際上二者結構是相同的，只在迴圈執行的次數上有所差異。 SHA-224 以及 SHA-384 則是前述二種雜湊函數的截短版，利用不同的初始值做計算。

這些新的雜湊函數並沒有接受像 SHA-1 一樣的公眾密碼社群做詳細的檢驗，所以它們的密碼安全性還不被大家廣泛的信任。Gilbert 和 Handschuh (2003) 曾對這些新變種作過一些研究，聲稱他們沒有弱點。

[編輯] SHA 所定義的長度
下表中的中繼雜湊值（internal state）表示對每個資料區塊壓縮雜湊過後的中繼值（internal hash sum）。詳情請參見Merkle-Damgård construction。

演演演算法 輸出雜湊值長度 (bits) 中繼雜湊值長度 (bits) 資料區塊長度 (bits) 最大輸入訊息長度 (bits) 一個Word長度 (bits) 迴圈次數 使用到的運運算元 碰撞攻擊
SHA-0 160 160 512 264 − 1 32 80 +,and,or,xor,rotl 是
SHA-1 160 160 512 264 − 1 32 80 +,and,or,xor,rotl 存在263 的攻擊
SHA-256/224 256/224 256 512 264 − 1 32 64 +,and,or,xor,shr,rotr 尚未出現
SHA-512/384 512/384 512 1024 2128 − 1 64 80 +,and,or,xor,shr,rotr 尚未出現

[編輯] SHAd
SHAd 函數是一個簡單的相同 SHA 函數的重述：

SHAd-256(m)=SHA-256(SHA-256(m))。它會克服有關延伸長度攻擊的問題。

[編輯] 應用
SHA-1, SHA-224, SHA-256, SHA-384 和 SHA-512 都被需要安全雜湊演演演算法的美國聯邦政府所應用，他們也使用其他的密碼演演演算法和協定來保護敏感的未保密資料。FIPS PUB 180-1 也鼓勵私人或商業組織使用 SHA-1 加密。Fritz-chip 將很可能使用 SHA-1 雜湊函數來實現個人電腦上的數位版權管理。

首先推動安全雜湊演演演算法出版的是已合並的數位簽章標准。

SHA 雜湊函數已被做為 SHACAL 分組密碼演演演算法的基礎。

[編輯] SHA-1 演演演算法
以下是 SHA-1 演演演算法的虛擬碼：

Note: All variables are unsigned 32 bits and wrap molo 232 when calculating

Initialize variables:
h0 := 0x67452301
h1 := 0xEFCDAB89
h2 := 0x98BADCFE
h3 := 0x10325476
h4 := 0xC3D2E1F0

Pre-processing:
append the bit '1' to the message
append k bits '0', where k is the minimum number >= 0 such that the resulting message
length (in bits) is congruent to 448 (mod 512)
append length of message (before pre-processing), in bits, as 64-bit big-endian integer

Process the message in successive 512-bit chunks:
break message into 512-bit chunks
for each chunk
break chunk into sixteen 32-bit big-endian words w[i], 0 ≤ i ≤ 15

Extend the sixteen 32-bit words into eighty 32-bit words:
for i from 16 to 79
w[i] := (w[i-3] xor w[i-8] xor w[i-14] xor w[i-16]) leftrotate 1

Initialize hash value for this chunk:
a := h0
b := h1
c := h2
d := h3
e := h4

Main loop:
for i from 0 to 79
if 0 ≤ i ≤ 19 then
f := (b and c) or ((not b) and d)
k := 0x5A827999
else if 20 ≤ i ≤ 39
f := b xor c xor d
k := 0x6ED9EBA1
else if 40 ≤ i ≤ 59
f := (b and c) or (b and d) or (c and d)
k := 0x8F1BBCDC
else if 60 ≤ i ≤ 79
f := b xor c xor d
k := 0xCA62C1D6

temp := (a leftrotate 5) + f + e + k + w[i]
e := d
d := c
c := b leftrotate 30
b := a
a := temp

Add this chunk's hash to result so far:
h0 := h0 + a
h1 := h1 + b
h2 := h2 + c
h3 := h3 + d
h4 := h4 + e

Proce the final hash value (big-endian):
digest = hash = h0 append h1 append h2 append h3 append h4
上述關於 f 運算式列於 FIPS PUB 180-1 中 , 以下替代運算式也許也能在主要迴圈裡計算 f ：

(0 ≤ i ≤ 19): f := d xor (b and (c xor d)) (alternative)

(40 ≤ i ≤ 59): f := (b and c) or (d and (b or c)) (alternative 1)
(40 ≤ i ≤ 59): f := (b and c) or (d and (b xor c)) (alternative 2)
(40 ≤ i ≤ 59): f := (b and c) + (d and (b xor c)) (alternative 3)

[編輯] SHA-2 演演演算法
以下是SHA-256 演演演算法的虛擬碼。注意，64個word w[16..63]中的位元比起 SHA-1 演演演算法，混合的程度大幅提升。

Note: All variables are unsigned 32 bits and wrap molo 232 when calculating

Initialize variables
(first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):
h0 := 0x6a09e667
h1 := 0xbb67ae85
h2 := 0x3c6ef372
h3 := 0xa54ff53a
h4 := 0x510e527f
h5 := 0x9b05688c
h6 := 0x1f83d9ab
h7 := 0x5be0cd19

Initialize table of round constants
(first 32 bits of the fractional parts of the cube roots of the first 64 primes 2..311):
k[0..63] :=
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2

Pre-processing:
append the bit '1' to the message
append k bits '0', where k is the minimum number >= 0 such that the resulting message
length (in bits) is congruent to 448 (mod 512)
append length of message (before pre-processing), in bits, as 64-bit big-endian integer

Process the message in successive 512-bit chunks:
break message into 512-bit chunks
for each chunk
break chunk into sixteen 32-bit big-endian words w[0..15]

Extend the sixteen 32-bit words into sixty-four 32-bit words:
for i from 16 to 63
s0 := (w[i-15] rightrotate 7) xor (w[i-15] rightrotate 18) xor (w[i-15] rightshift 3)
s1 := (w[i-2] rightrotate 17) xor (w[i-2] rightrotate 19) xor (w[i-2] rightshift 10)
w[i] := w[i-16] + s0 + w[i-7] + s1

Initialize hash value for this chunk:
a := h0
b := h1
c := h2
d := h3
e := h4
f := h5
g := h6
h := h7

Main loop:
for i from 0 to 63
s0 := (a rightrotate 2) xor (a rightrotate 13) xor (a rightrotate 22)
maj := (a and b) xor (a and c) xor (b and c)
t2 := s0 + maj
s1 := (e rightrotate 6) xor (e rightrotate 11) xor (e rightrotate 25)
ch := (e and f) xor ((not e) and g)
t1 := h + s1 + ch + k[i] + w[i]

h := g
g := f
f := e
e := d + t1
d := c
c := b
b := a
a := t1 + t2

Add this chunk's hash to result so far:
h0 := h0 + a
h1 := h1 + b
h2 := h2 + c
h3 := h3 + d
h4 := h4 + e
h5 := h5 + f
h6 := h6 + g
h7 := h7 + h

Proce the final hash value (big-endian):
digest = hash = h0 append h1 append h2 append h3 append h4 append h5 append h6 append h7
其中 ch 函數及 maj 函數可利用前述 SHA-1 的優化方式改寫。

SHA-224 和 SHA-256 基本上是相同的, 除了:

h0 到 h7 的初始值不同，以及
SHA-224 輸出時截掉 h7 的函數值。
SHA-512 和 SHA-256 的結構相同，但:

SHA-512 所有的數字都是64位元，
SHA-512 執行80次加密迴圈而非64次，
SHA-512 初始值和常數拉長成64位元，以及
二者位元的偏移量和循環位移量不同。
SHA-384 和 SHA-512 基本上是相同的，除了：

h0 到 h7 的初始值不同，以及
SHA-384 輸出時截掉 h6 和 h7 的函數值。

Ⅲ A*演算法的其它演算法

啟發式搜索其實有很多的演算法
比如：局部擇優搜索法、最好優先搜索法等等。當然A*也是。這些演算法都使用了啟發函數，但在具體的選取最佳搜索節點時的策略不同。像局部擇優搜索法，就是在搜索的過程中選取「最佳節點」後舍棄其他的兄弟節點，父親節點，而一直得搜索下去。這種搜索的結果很明顯，由於舍棄了其他的節點，可能也把最好的節點都舍棄了，因為求解的最佳節點只是在該階段的最佳並不一定是全局的最佳。最好優先就聰明多了，他在搜索時，並沒有舍棄節點（除非該節點是死節點），在每一步的估價中都把當前的節點和以前的節點的估價值比較得到一個「最佳的節點」。這樣可以有效的防止「最佳節點」的丟失。那麼A*演算法又是一種什麼樣的演算法呢？

Ⅳ 矩陣a*演算法是什麼

矩陣A*表示A矩陣的伴隨矩陣。

伴隨矩陣的定義：某矩陣A各元素的代數餘子式，組成一個新的矩陣後再進行一下轉置，叫做A的伴隨矩陣。

某元素代數餘子式就是去掉矩陣中某元素所在行和列元素後的形成矩陣的行列式，再乘上-1的（行數+列數）次方。

伴隨矩陣的求發：當矩陣是大於等於二階時：

主對角元素是將原矩陣該元素所在行列去掉再求行列式。

非主對角元素是原矩陣該元素的共軛位置的元素去掉所在行列求行列式乘以(-1)^(x+y) x,y為該元素的共軛位置的元素的行和列的序號，序號從1開始的。

主對角元素實際上是非主對角元素的特殊情況，因為x=y,所以(-1)^(x+y)=(-1)^(2x)=1,一直是正數，沒必要考慮主對角元素的符號問題。

Ⅳ 用java怎麼實現A*演算法

代碼實現(Java)
1.輸入
(1)代表地圖二值二維數組(0表示可通路，1表示路障)
int[][]maps={
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,1,1,0,0,0,0,0,0,1,1,1,0,0},
{0,0,0,1,0,0,0,0,0,1,1,0,0,0,0},
{0,0,0,1,0,0,0,0,1,1,0,0,0,0,0},
{0,0,0,1,0,0,0,0,1,0,0,0,0,0,0},
{0,0,0,1,0,0,0,0,1,0,0,0,0,0,0}
};123456789123456789
(2)按照二維數組的特點，坐標原點在左上角，所以y是高，x是寬，y向下遞增，x向右遞增，我們將x和y封裝成一個類，好傳參，重寫equals方法比較坐標(x,y)是不是同一個。
publicclassCoord
{
publicintx;
publicinty;

publicCoord(intx,inty)
{
this.x=x;
this.y=y;
}

@Override
publicbooleanequals(Objectobj)
{
if(obj==null)returnfalse;
if(objinstanceofCoord)
{
Coordc=(Coord)obj;
returnx==c.x&&y==c.y;
}
returnfalse;
}
}2223
(3)封裝路徑結點類，欄位包括：坐標、G值、F值、父結點，實現Comparable介面，方便優先隊列排序。
<Node>
{

publicCoordcoord;//坐標
publicNodeparent;//父結點
publicintG;//G：是個准確的值，是起點到當前結點的代價
publicintH;//H：是個估值，當前結點到目的結點的估計代價

publicNode(intx,inty)
{
this.coord=newCoord(x,y);
}

publicNode(Coordcoord,Nodeparent,intg,inth)
{
this.coord=coord;
this.parent=parent;
G=g;
H=h;
}

@Override
publicintcompareTo(Nodeo)
{
if(o==null)return-1;
if(G+H>o.G+o.H)
return1;
elseif(G+H<o.G+o.H)return-1;
return0;
}
}
(4)最後一個數據結構是A星演算法輸入的所有數據，封裝在一起，傳參方便。:grin:
publicclassMapInfo
{
publicint[][]maps;//二維數組的地圖
publicintwidth;//地圖的寬
publicinthight;//地圖的高
publicNodestart;//起始結點
publicNodeend;//最終結點

publicMapInfo(int[][]maps,intwidth,inthight,Nodestart,Nodeend)
{
this.maps=maps;
this.width=width;
this.hight=hight;
this.start=start;
this.end=end;
}
}
2.處理
(1)在演算法里需要定義幾個常量來確定：二維數組中哪個值表示障礙物、二維數組中繪制路徑的代表值、計算G值需要的橫縱移動代價和斜移動代價。
publicfinalstaticintBAR=1;//障礙值
publicfinalstaticintPATH=2;//路徑
publicfinalstaticintDIRECT_VALUE=10;//橫豎移動代價
publicfinalstaticintOBLIQUE_VALUE=14;//斜移動代價12341234
(2)定義兩個輔助表：Open表和Close表。Open表的使用是需要取最小值，在這里我們使用Java工具包中的優先隊列PriorityQueue，Close只是用來保存結點，沒其他特殊用途，就用ArrayList。
Queue<Node>openList=newPriorityQueue<Node>();//優先隊列(升序)
List<Node>closeList=newArrayList<Node>();1212
(3)定義幾個布爾判斷方法：最終結點的判斷、結點能否加入open表的判斷、結點是否在Close表中的判斷。
/**
*判斷結點是否是最終結點
*/
privatebooleanisEndNode(Coordend,Coordcoord)
{
returncoord!=null&&end.equals(coord);
}

/**
*判斷結點能否放入Open列表
*/
(MapInfomapInfo,intx,inty)
{
//是否在地圖中
if(x<0||x>=mapInfo.width||y<0||y>=mapInfo.hight)returnfalse;
//判斷是否是不可通過的結點
if(mapInfo.maps[y][x]==BAR)returnfalse;
//判斷結點是否存在close表
if(isCoordInClose(x,y))returnfalse;

returntrue;
}

/**
*判斷坐標是否在close表中
*/
privatebooleanisCoordInClose(Coordcoord)
{
returncoord!=null&&isCoordInClose(coord.x,coord.y);
}

/**
*判斷坐標是否在close表中
*/
privatebooleanisCoordInClose(intx,inty)
{
if(closeList.isEmpty())returnfalse;
for(Nodenode:closeList)
{
if(node.coord.x==x&&node.coord.y==y)
{
returntrue;
}
}
returnfalse;
}353637383940414243444546
(4)計算H值，「曼哈頓」法，坐標分別取差值相加
privateintcalcH(Coordend,Coordcoord)
{
returnMath.abs(end.x-coord.x)+Math.abs(end.y-coord.y);
}12341234
(5)從Open列表中查找結點
privateNodefindNodeInOpen(Coordcoord)
{
if(coord==null||openList.isEmpty())returnnull;
for(Nodenode:openList)
{
if(node.coord.equals(coord))
{
returnnode;
}
}
returnnull;
}
(6)添加鄰結點到Open表
/**
*添加所有鄰結點到open表
*/
(MapInfomapInfo,Nodecurrent)
{
intx=current.coord.x;
inty=current.coord.y;
//左
addNeighborNodeInOpen(mapInfo,current,x-1,y,DIRECT_VALUE);
//上
addNeighborNodeInOpen(mapInfo,current,x,y-1,DIRECT_VALUE);
//右
addNeighborNodeInOpen(mapInfo,current,x+1,y,DIRECT_VALUE);
//下
addNeighborNodeInOpen(mapInfo,current,x,y+1,DIRECT_VALUE);
//左上
addNeighborNodeInOpen(mapInfo,current,x-1,y-1,OBLIQUE_VALUE);
//右上
addNeighborNodeInOpen(mapInfo,current,x+1,y-1,OBLIQUE_VALUE);
//右下
addNeighborNodeInOpen(mapInfo,current,x+1,y+1,OBLIQUE_VALUE);
//左下
addNeighborNodeInOpen(mapInfo,current,x-1,y+1,OBLIQUE_VALUE);
}

/**
*添加一個鄰結點到open表
*/
(MapInfomapInfo,Nodecurrent,intx,inty,intvalue)
{
if(canAddNodeToOpen(mapInfo,x,y))
{
Nodeend=mapInfo.end;
Coordcoord=newCoord(x,y);
intG=current.G+value;//計算鄰結點的G值
Nodechild=findNodeInOpen(coord);
if(child==null)
{
intH=calcH(end.coord,coord);//計算H值
if(isEndNode(end.coord,coord))
{
child=end;
child.parent=current;
child.G=G;
child.H=H;
}
else
{
child=newNode(coord,current,G,H);
}
openList.add(child);
}
elseif(child.G>G)
{
child.G=G;
child.parent=current;
//重新調整堆
openList.add(child);
}
}
}85960618596061
(7)回溯法繪制路徑
privatevoiddrawPath(int[][]maps,Nodeend)
{
if(end==null||maps==null)return;
System.out.println("總代價："+end.G);
while(end!=null)
{
Coordc=end.coord;
maps[c.y][c.x]=PATH;
end=end.parent;
}
}12345678910111234567891011
(8)開始演算法，循環移動結點尋找路徑，設定循環結束條件，Open表為空或者最終結點在Close表

publicvoidstart(MapInfomapInfo)
{
if(mapInfo==null)return;
//clean
openList.clear();
closeList.clear();
//開始搜索
openList.add(mapInfo.start);
moveNodes(mapInfo);
}

/**
*移動當前結點
*/
privatevoidmoveNodes(MapInfomapInfo)
{
while(!openList.isEmpty())
{
if(isCoordInClose(mapInfo.end.coord))
{
drawPath(mapInfo.maps,mapInfo.end);
break;
}
Nodecurrent=openList.poll();
closeList.add(current);
addNeighborNodeInOpen(mapInfo,current);
}
}

Ⅵ A*演算法的簡單案例

參見參考資料中的「A*演算法入門」
另外，A*同樣可以用於其他搜索問題。

Ⅶ 我想了解一下五子棋AI A*演算法，可是怎麼都看不明白啊~誰能詳細講講啊

/*源程序太多了，要的話給油箱*/
#DEFINE NROW 15
tmpzth="" && 行狀態
tmpztl="" && 列狀態
for i=1 to NROW
for j=1 to NROW
tmpzth=tmpzth+Azt(i,j)
tmpztl=tmpztl+Azt(j,i)
endfor
&& 行判斷
do case
********** y 連 5 ***********
case "nyyyy" $ tmpzth
thisform.plc_h(i,j,at("nyyyy",tmpzth),0 ,1) && 1 的得出方法 ：at("n","nyyyy")
case "ynyyy" $ tmpzth
thisform.plc_h(i,j,at("ynyyy",tmpzth),1 ,1)
case "yynyy" $ tmpzth
thisform.plc_h(i,j,at("yynyy",tmpzth),2 ,1)
case "yyyny" $ tmpzth
thisform.plc_h(i,j,at("yyyny",tmpzth),3 ,1)
case "yyyyn" $ tmpzth
thisform.plc_h(i,j,at("yyyyn",tmpzth),4 ,1)
********** b 連 5 **********
case "nbbbb" $ tmpzth
thisform.plc_h(i,j,at("nbbbb",tmpzth),0 ,2)
case "bnbbb" $ tmpzth
thisform.plc_h(i,j,at("bnbbb",tmpzth),1 ,2)
case "bbnbb" $ tmpzth
thisform.plc_h(i,j,at("bbnbb",tmpzth),2 ,2)
case "bbbnb" $ tmpzth
thisform.plc_h(i,j,at("bbbnb",tmpzth),3 ,2)
case "bbbbn" $ tmpzth
thisform.plc_h(i,j,at("bbbbn",tmpzth),4 ,2)
********** y 沖 4 ***********
case "nynyyn" $ tmpzth
thisform.plc_h(i,j,at("nynyyn",tmpzth),2 ,3)
case "nyynyn" $ tmpzth
thisform.plc_h(i,j,at("nyynyn",tmpzth),3 ,3)
case "nyyynn" $ tmpzth
thisform.plc_h(i,j,at("nyyynn",tmpzth),4 ,3)
case "nnyyyn" $ tmpzth
thisform.plc_h(i,j,at("nnyyyn",tmpzth),1 ,3)
********* b 沖 4 ************
case "nbnbbn" $ tmpzth
thisform.plc_h(i,j,at("nbnbbn",tmpzth),2 ,5)
case "nbbnbn" $ tmpzth
thisform.plc_h(i,j,at("nbbnbn",tmpzth),3 ,5)
case "nbbbnn" $ tmpzth
thisform.plc_h(i,j,at("nbbbnn",tmpzth),4 ,5)
case "nnbbbn" $ tmpzth
thisform.plc_h(i,j,at("nnbbbn",tmpzth),1 ,5)
********** y 連 4 ***********
case "nnyyyb" $ tmpzth
thisform.plc_h(i,j,at("nnyyyb",tmpzth),1 ,4)
case "nynyyb" $ tmpzth
thisform.plc_h(i,j,at("nynyyb",tmpzth),2 ,4)
case "nyynyb" $ tmpzth
thisform.plc_h(i,j,at("nyynyb",tmpzth),3 ,4)
case "nyyynb" $ tmpzth
thisform.plc_h(i,j,at("nyyynb",tmpzth),1 ,4)
case "byyynn" $ tmpzth
thisform.plc_h(i,j,at("byyynn",tmpzth),4 ,4)
case "byynyn" $ tmpzth
thisform.plc_h(i,j,at("byynyn",tmpzth),3 ,4)
case "bynyyn" $ tmpzth
thisform.plc_h(i,j,at("bynyyn",tmpzth),2 ,4)
case "bnyyyn" $ tmpzth
thisform.plc_h(i,j,at("bnyyyn",tmpzth),1 ,4)
********** b 連 4 ***********
case "nnbbby" $ tmpzth
thisform.plc_h(i,j,at("nnbbby",tmpzth),1 ,9)
case "nbnbby" $ tmpzth
thisform.plc_h(i,j,at("nbnbby",tmpzth),2 ,9)
case "nbbnby" $ tmpzth
thisform.plc_h(i,j,at("nbbnby",tmpzth),3 ,9)
case "nbbbny" $ tmpzth
thisform.plc_h(i,j,at("nbbbny",tmpzth),1 ,9)
case "ybbbnn" $ tmpzth
thisform.plc_h(i,j,at("ybbbnn",tmpzth),4 ,9)
case "ybbnbn" $ tmpzth
thisform.plc_h(i,j,at("ybbnbn",tmpzth),3 ,9)
case "ybnbbn" $ tmpzth
thisform.plc_h(i,j,at("ybnbbn",tmpzth),2 ,9)
case "ynbbbn" $ tmpzth
thisform.plc_h(i,j,at("ynbbbn",tmpzth),1 ,9)
********** y 沖 3 ***********
case "nynynn" $ tmpzth
thisform.plc_h(i,j,at("nynynn",tmpzth),2 ,6)
case "nnyynn" $ tmpzth
thisform.plc_h(i,j,at("nnyynn",tmpzth),4 ,6)
********* b 沖 3 ************
case "nbnbnn" $ tmpzth
thisform.plc_h(i,j,at("nbnbnn",tmpzth),2 ,8)
case "nnbbnn" $ tmpzth
thisform.plc_h(i,j,at("nnbbnn",tmpzth),4 ,8)
********** 1個 ***********
case "nnynnn" $ tmpzth
thisform.plc_h(i,j,at("nnynnn",tmpzth),3, 7)
case "nnnynn" $ tmpzth
thisform.plc_h(i,j,at("nnnynn",tmpzth),2 ,7)
case "nnbnnn" $ tmpzth
thisform.plc_h(i,j,at("nnbnnn",tmpzth),3 ,10)
case "nnnbnn" $ tmpzth
thisform.plc_h(i,j,at("nnnbnn",tmpzth),2 ,10)
endcase

&& 列判斷
do case
********** 5個 ***********
case "nyyyy" $ tmpztl
thisform.plc_l(i,j,at("nyyyy",tmpztl),0 ,1) && 1 的得出方法 ：at("n","nyyyy")
case "ynyyy" $ tmpztl
thisform.plc_l(i,j,at("ynyyy",tmpztl),1 ,1)
case "yynyy" $ tmpztl
thisform.plc_l(i,j,at("yynyy",tmpztl),2 ,1)
case "yyyny" $ tmpztl
thisform.plc_l(i,j,at("yyyny",tmpztl),3 ,1)
case "yyyyn" $ tmpztl
thisform.plc_l(i,j,at("yyyyn",tmpztl),4 ,1)
case "nbbbb" $ tmpztl
thisform.plc_l(i,j,at("nbbbb",tmpztl),0 ,2)
case "bnbbb" $ tmpztl
thisform.plc_l(i,j,at("bnbbb",tmpztl),1 ,2)
case "bbnbb" $ tmpztl
thisform.plc_l(i,j,at("bbnbb",tmpztl),2 ,2)
case "bbbnb" $ tmpztl
thisform.plc_l(i,j,at("bbbnb",tmpztl),3 ,2)
case "bbbbn" $ tmpztl
thisform.plc_l(i,j,at("bbbbn",tmpztl),4 ,2)
********** 4個 ***********
case "nynyyn" $ tmpztl
thisform.plc_l(i,j,at("nynyyn",tmpztl),2 ,3)
case "nyynyn" $ tmpztl
thisform.plc_l(i,j,at("nyynyn",tmpztl),3 ,3)
case "nyyynn" $ tmpztl
thisform.plc_l(i,j,at("nyyynn",tmpztl),4 ,3)
case "nnyyyn" $ tmpztl
thisform.plc_l(i,j,at("nnyyyn",tmpztl),1 ,3)
case "nbnbbn" $ tmpztl
thisform.plc_l(i,j,at("nbnbbn",tmpztl),2 ,5)
case "nbbnbn" $ tmpztl
thisform.plc_l(i,j,at("nbbnbn",tmpztl),3 ,5)
case "nbbbnn" $ tmpztl
thisform.plc_l(i,j,at("nbbbnn",tmpztl),4 ,5)
case "nnbbbn" $ tmpztl
thisform.plc_l(i,j,at("nnbbbn",tmpztl),1 ,5)
********** 3個 ***********
case "nnyyyb" $ tmpztl
thisform.plc_l(i,j,at("nnyyyb",tmpztl),1 ,4)
case "nynyyb" $ tmpztl
thisform.plc_l(i,j,at("nynyyb",tmpztl),2 ,4)
case "nyynyb" $ tmpztl
thisform.plc_l(i,j,at("nyynyb",tmpztl),3 ,4)
case "nyyynb" $ tmpztl
thisform.plc_l(i,j,at("nyyynb",tmpztl),1 ,4)
case "byyynn" $ tmpztl
thisform.plc_l(i,j,at("byyynn",tmpztl),4 ,4)
case "byynyn" $ tmpztl
thisform.plc_l(i,j,at("byynyn",tmpztl),3 ,4)
case "bynyyn" $ tmpztl
thisform.plc_l(i,j,at("bynyyn",tmpztl),2 ,4)
case "bnyyyn" $ tmpztl
thisform.plc_l(i,j,at("bnyyyn",tmpztl),1 ,4)
case "nnbbby" $ tmpztl
thisform.plc_l(i,j,at("nnbbby",tmpztl),1 ,9)
case "nbnbby" $ tmpztl
thisform.plc_l(i,j,at("nbnbby",tmpztl),2 ,9)
case "nbbnby" $ tmpztl
thisform.plc_l(i,j,at("nbbnby",tmpztl),3 ,9)
case "nbbbny" $ tmpztl
thisform.plc_l(i,j,at("nbbbny",tmpztl),1 ,9)
case "ybbbnn" $ tmpztl
thisform.plc_l(i,j,at("ybbbnn",tmpztl),4 ,9)
case "ybbnbn" $ tmpztl
thisform.plc_l(i,j,at("ybbnbn",tmpztl),3 ,9)
case "ybnbbn" $ tmpztl
thisform.plc_l(i,j,at("ybnbbn",tmpztl),2 ,9)
case "ynbbbn" $ tmpztl
thisform.plc_l(i,j,at("ynbbbn",tmpztl),1 ,9)
********** 2個 ***********
case "nynynn" $ tmpztl
thisform.plc_l(i,j,at("nynynn",tmpztl),2 ,6)
case "nnyynn" $ tmpztl
thisform.plc_l(i,j,at( "nnyynn",tmpztl),4 ,6)
case "nbnbnn" $ tmpztl
thisform.plc_l(i,j,at("nbnbnn",tmpztl),2 ,8)
case "nnbbnn" $ tmpztl
thisform.plc_l(i,j,at("nnbbnn",tmpztl),4 ,8)
********** 1個 ***********
case "nnynnn" $ tmpztl
thisform.plc_l(i,j,at("nnynnn",tmpztl),3, 7)
case "nnnynn" $ tmpztl
thisform.plc_l(i,j,at("nnnynn",tmpztl),2 ,7)
case "nnbnnn" $ tmpztl
thisform.plc_l(i,j,at("nnbnnn",tmpztl),3 ,10)
case "nnnbnn" $ tmpztl
thisform.plc_l(i,j,at("nnnbnn",tmpztl),2 ,10)
endcase
tmpzth=""
tmpztl=""
endfor

Ⅷ 什麼是 a演算法a* 演算法有什麼特點

A*演算法：A*（A-Star)演算法是一種靜態路網中求解最短路徑最有效的直接搜索方法。估價值與實際值越接近，估價函數取得就越好
A* （A-Star)演算法是一種靜態路網中求解最短路最有效的直接搜索方法。
注意是最有效的直接搜索演算法。之後涌現了很多預處理演算法（ALT，CH，HL等等），在線查詢效率是A*演算法的數千甚至上萬倍。
公式表示為： f(n)=g(n)+h(n),
其中 f(n) 是從初始點經由節點n到目標點的估價函數，
g(n) 是在狀態空間中從初始節點到n節點的實際代價，
h(n) 是從n到目標節點最佳路徑的估計代價。
保證找到最短路徑（最優解的）條件，關鍵在於估價函數f(n)的選取：
估價值h(n)<= n到目標節點的距離實際值，這種情況下，搜索的點數多，搜索范圍大，效率低。但能得到最優解。並且如果h(n)=d(n)，即距離估計h(n)等於最短距離，那麼搜索將嚴格沿著最短路徑進行， 此時的搜索效率是最高的。
如果 估價值>實際值,搜索的點數少，搜索范圍小，效率高，但不能保證得到最優解。