a算法是什么时候提出的

A. A*算法是什么

A*
（A-Star)算法是一种静态路网中求解最短路最有效的方法。
公式表示为： f(n)=g(n)+h(n),
其中f(n) 是从初始点经由节点n到目标点的估价函数，
g(n) 是在状态空间中从初始节点到n节点的实际代价，
h(n)是从n到目标节点最佳路径的估计代价。
保证找到最短路径（最优解的）条件，关键在于估价函数h(n)的选取：
估价值h(n)<= n到目标节点的距离实际值，这种情况下，搜索的点数多，搜索范围大，效率低。但能得到最优解。
如果 估价值>实际值, 搜索的点数少，搜索范围小，效率高，但不能保证得到最优解

B. 关于A*算法和3D算法

A*算法是一种启发式搜索的算法，公式表示为： f(n)=g(n)+h(n)g(n) 是在状态空间中从初始节点到n节点的实际代价，
h(n)是从n到目标节点最佳路径的估计代价。3D算法，没看懂你说什么意思

C. apriori算法是什么

Apriori算法是第一个关联规则挖掘算法，也是最经典的算法。它利用逐层搜索的迭代方法找出数据库中项集的关系，以形成规则，其过程由连接（类矩阵运算）与剪枝（去掉那些没必要的中间结果）组成。该算法中项集的概念即为项的集合。包含K个项的集合为k项集。项集出现的频率是包含项集的事务数，称为项集的频率。如果某项集满足最小支持度，则称它为频繁项集。

算法应用

随着高校贫困生人数的不断增加，学校管理部门资助工作难度也越加增大。针对这一现象，提出一种基于数据挖掘算法的解决方法。将关联规则的Apriori算法应用到贫困助学体系中，并且针对经典Apriori挖掘算法存在的不足进行改进，先将事务数据库映射为一个布尔矩阵，用一种逐层递增的思想来动态的分配内存进行存储，再利用向量求＂与＂运算，寻找频繁项集。

D. A*算法怎么验算

验算步骤如下：
a初值为12时，a+=a-=a*=a结果为0
步骤：
这个表达式的运算是从右向左的：
1.
a*=a：a=a*a=12*12=144
2.
a-=144:
a=a-144=144-144=0
3.
a+=0:
a=a+0=0+0=0。算法（Algorithm）是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令，算法代表着用系统的方法描述解决问题的策略机制。也就是说，能够对一定规范的输入，在有限时间内获得所要求的输出。如果一个算法有缺陷，或不适合于某个问题，执行这个算法将不会解决这个问题。不同的算法可能用不同的时间、空间或效率来完成同样的任务。一个算法的优劣可以用空间复杂度与时间复杂度来衡量。
算法中的指令描述的是一个计算，当其运行时能从一个初始状态和（可能为空的）初始输入开始，经过一系列有限而清晰定义的状态，最终产生输出并停止于一个终态。一个状态到另一个状态的转移不一定是确定的。随机化算法在内的一些算法，包含了一些随机输入。
形式化算法的概念部分源自尝试解决希尔伯特提出的判定问题，并在其后尝试定义有效计算性或者有效方法中成形。这些尝试包括库尔特·哥德尔、JacquesHerbrand和斯蒂芬·科尔·克莱尼分别于1930年、1934年和1935年提出的递归函数，阿隆佐·邱奇于1936年提出的λ演算，1936年EmilLeonPost的Formulation1和艾伦·图灵1937年提出的图灵机。即使在当前，依然常有直觉想法难以定义为形式化算法的情况。

E. A*算法是怎么来的，历史背景是啥，谁提出的A*算法帮帮忙，谢谢！

1968年，的一篇论文，“P. E. Hart, N. J. Nilsson, and B. Raphael. A formal basis for the heuristic determination of minimum cost paths in graphs. IEEE Trans. Syst. Sci. and Cybernetics, SSC-4(2):100-107, 1968”。从此，一种精巧、高效的算法------A*算法横空出世了，并在相关领域得到了广泛的应用。

F. 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 的函数值。

G. A*算法的原理

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)等于最短距离，那么搜索将严格沿着最短路径进行， 此时的搜索效率是最高的。
如果 估价值>实际值,搜索的点数少，搜索范围小，效率高，但不能保证得到最优解。

H. A*算法现实应用的实际意义

A*算法在人工智能中是一种典型的启发式搜索算法，为了说清楚A*算法，我看还是先说说何谓启发式算法。

一、何谓启发式搜索算法

在说它之前先提提状态空间搜索。状态空间搜索，如果按专业点的说法就是将问题求解过程表现为从初始状态到目标状态寻找这个路径的过程。通俗点说，就是在解一个问题时，找到一条解题的过程可以从求解的开始到问题的结果（好象并不通俗哦）。由于求解问题的过程中分枝有很多，主要是求解过程中求解条件的不确定性，不完备性造成的，使得求解的路径很多这就构成了一个图，我们说这个图就是状态空间。问题的求解实际上就是在这个图中找到一条路径可以从开始到结果。这个寻找的过程就是状态空间搜索。

常用的状态空间搜索有深度优先和广度优先。广度优先是从初始状态一层一层向下找，直到找到目标为止。深度优先是按照一定的顺序前查找完一个分支，再查找另一个分支，以至找到目标为止。这两种算法在数据结构书中都有描述，可以参看这些书得到更详细的解释。

前面说的广度和深度优先搜索有一个很大的缺陷就是他们都是在一个给定的状态空间中穷举。这在状态空间不大的情况下是很合适的算法，可是当状态空间十分大，且不预测的情况下就不可取了。他的效率实在太低，甚至不可完成。在这里就要用到启发式搜索了。

启发式搜索就是在状态空间中的搜索对每一个搜索的位置进行评估，得到最好的位置，再从这个位置进行搜索直到目标。这样可以省略大量无畏的搜索路径，提到了效率。在启发式搜索中，对位置的估价是十分重要的。采用了不同的估价可以有不同的效果。我们先看看估价是如何表示的。

启发中的估价是用估价函数表示的，如：

f(n) = g(n) + h(n)

其中f(n)是节点n的估价函数，g(n)实在状态空间中从初始节点到n节点的实际代价，h(n)是从n到目标节点最佳路径的估计代价。在这里主要是h(n)体现了搜索的启发信息，因为g(n)是已知的。如果说详细点，g(n)代表了搜索的广度的优先趋势。但是当h(n)>>g(n)时，可以省略g(n),而提高效率。这些就深了，不懂也不影响啦！我们继续看看何谓A*算法。

二、初识A*算法

启发式搜索其实有很多的算法，比如：局部择优搜索法、最好优先搜索法等等。当然A*也是。这些算法都使用了启发函数，但在具体的选取最佳搜索节点时的策略不同。象局部择优搜索法，就是在搜索的过程中选取“最佳节点”后舍弃其他的兄弟节点，父亲节点，而一直得搜索下去。这种搜索的结果很明显，由于舍弃了其他的节点，可能也把最好的节点都舍弃了，因为求解的最佳节点只是在该阶段的最佳并不一定是全局的最佳。最好优先就聪明多了，他在搜索时，便没有舍弃节点（除非该节点是死节点），在每一步的估价中都把当前的节点和以前的节点的估价值比较得到一个“最佳的节点”。这样可以有效的防止“最佳节点”的丢失。那么A*算法又是一种什么样的算法呢？其实A*算法也是一种最好优先的算法。只不过要加上一些约束条件罢了。由于在一些问题求解时，我们希望能够求解出状态空间搜索的最短路径，也就是用最快的方法求解问题，A*就是干这种事情的！我们先下个定义，如果一个估价函数可以找出最短的路径，我们称之为可采纳性。A*算法是一个可采纳的最好优先算法。A*算法的估价函数可表示为：

f'(n) = g'(n) + h'(n)

这里，f'(n)是估价函数，g'(n)是起点到终点的最短路径值，h'(n)是n到目标的最断路经的启发值。由于这个f'(n)其实是无法预先知道的，所以我们用前面的估价函数f(n)做近似。g(n)代替g'(n)，但g(n)>=g'(n)才可（大多数情况下都是满足的，可以不用考虑），h(n)代替h'(n)，但h(n)<=h'(n)才可（这一点特别的重要）。可以证明应用这样的估价函数是可以找到最短路径的，也就是可采纳的。我们说应用这种估价函数的最好优先算法就是A*算法。哈！你懂了吗？肯定没懂！接着看！

举一个例子，其实广度优先算法就是A*算法的特例。其中g(n)是节点所在的层数，h(n)=0，这种h(n)肯定小于h'(n)，所以由前述可知广度优先算法是一种可采纳的。实际也是。当然它是一种最臭的A*算法。

再说一个问题，就是有关h(n)启发函数的信息性。h(n)的信息性通俗点说其实就是在估计一个节点的值时的约束条件，如果信息越多或约束条件越多则排除的节点就越多，估价函数越好或说这个算法越好。这就是为什么广度优先算法的那么臭的原因了，谁叫它的h(n)=0，一点启发信息都没有。但在游戏开发中由于实时性的问题，h(n)的信息越多，它的计算量就越大，耗费的时间就越多。就应该适当的减小h(n)的信息，即减小约束条件。但算法的准确性就差了，这里就有一个平衡的问题。