① 最短路径算法
Dijkstra算法，A*算法和D*算法
Dijkstra算法是典型最短路算法，用于计算一个节点到其他所有节点的最短路径。主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。Dijkstra算法能得出最短路径的最优解，但由于它遍历计算的节点很多，所以效率低。
Dijkstra算法是很有代表性的最短路算法，在很多专业课程中都作为基本内容有详细的介绍，如数据结构，图论，运筹学等等。
Dijkstra一般的表述通常有两种方式，一种用永久和临时标号方式，一种是用OPEN, CLOSE表方式，Drew为了和下面要介绍的 A* 算法和 D* 算法表述一致，这里均采用OPEN,CLOSE表的方式。
大概过程：
创建两个表，OPEN, CLOSE。
OPEN表保存所有已生成而未考察的节点，CLOSED表中记录已访问过的节点。
1． 访问路网中里起始点最近且没有被检查过的点，把这个点放入OPEN组中等待检查。
2． 从OPEN表中找出距起始点最近的点，找出这个点的所有子节点，把这个点放到CLOSE表中。
3． 遍历考察这个点的子节点。求出这些子节点距起始点的距离值，放子节点到OPEN表中。
4． 重复2，3，步。直到OPEN表为空，或找到目标点。
提高Dijkstra搜索速度的方法很多，常用的有数据结构采用Binary heap的方法，和用Dijkstra从起始点和终点同时搜索的方法。
A*（A-Star)算法是一种启发式算法，是静态路网中求解最短路最有效的方法。
公式表示为： f(n)=g(n)+h(n),
其中f(n) 是节点n从初始点到目标点的估价函数，
g(n) 是在状态空间中从初始节点到n节点的实际代价，
h(n)是从n到目标节点最佳路径的估计代价。
保证找到最短路径（最优解的）条件，关键在于估价函数h(n)的选取：
估价值h(n)<= n到目标节点的距离实际值，这种情况下，搜索的点数多，搜索范围大，效率低。但能得到最优解。
如果 估价值>实际值, 搜索的点数少，搜索范围小，效率高，但不能保证得到最优解。
估价值与实际值越接近，估价函数取得就越好。
例如对于几何路网来说，可以取两节点间欧几理德距离（直线距离）做为估价值，即f=g(n)+sqrt((dx-nx)*(dx-nx)+(dy-ny)*(dy-ny))；这样估价函数f在g值一定的情况下，会或多或少的受估价值h的制约，节点距目标点近，h值小，f值相对就小，能保证最短路的搜索向终点的方向进行。明显优于Dijstra算法的毫无无方向的向四周搜索。
conditions of heuristic
Optimistic (must be less than or equal to the real cost)
As close to the real cost as possible
主要搜索过程：
创建两个表，OPEN表保存所有已生成而未考察的节点，CLOSED表中记录已访问过的节点。
遍历当前节点的各个节点，将n节点放入CLOSE中，取n节点的子节点X,->算X的估价值->
While(OPEN!=NULL)
{
从OPEN表中取估价值f最小的节点n;
if(n节点==目标节点) break;
else
{
if(X in OPEN) 比较两个X的估价值f //注意是同一个节点的两个不同路径的估价值
if( X的估价值小于OPEN表的估价值 )
更新OPEN表中的估价值; //取最小路径的估价值
if(X in CLOSE) 比较两个X的估价值 //注意是同一个节点的两个不同路径的估价值
if( X的估价值小于CLOSE表的估价值 )
更新CLOSE表中的估价值; 把X节点放入OPEN //取最小路径的估价值
if(X not in both)
求X的估价值;
并将X插入OPEN表中; //还没有排序
}
将n节点插入CLOSE表中;
按照估价值将OPEN表中的节点排序; //实际上是比较OPEN表内节点f的大小，从最小路径的节点向下进行。
}
A*算法和Dijistra算法的区别在于有无估价值，Dijistra算法相当于A*算法中估价值为0的情况。
动态路网，最短路算法 D*A* 在静态路网中非常有效（very efficient for static worlds），但不适于在动态路网，环境如权重等不断变化的动态环境下。
D*是动态A*（D-Star,Dynamic A*） 卡内及梅隆机器人中心的Stentz在1994和1995年两篇文章提出，主要用于机器人探路。是火星探测器采用的寻路算法。
主要方法：
1.先用Dijstra算法从目标节点G向起始节点搜索。储存路网中目标点到各个节点的最短路和该位置到目标点的实际值h,k（k为所有变化h之中最小的值,当前为k=h。每个节点包含上一节点到目标点的最短路信息1(2),2(5),5(4)，4（7）。则1到4的最短路为1-2-5-4。
原OPEN和CLOSE中节点信息保存。
2.机器人沿最短路开始移动，在移动的下一节点没有变化时，无需计算，利用上一步Dijstra计算出的最短路信息从出发点向后追述即可，当在Y点探测到下一节点X状态发生改变，如堵塞。机器人首先调整自己在当前位置Y到目标点G的实际值h(Y)，h(Y)=X到Y的新权值c(X,Y)+X的原实际值h(X).X为下一节点(到目标点方向Y->X->G），Y是当前点。k值取h值变化前后的最小。
3.用A*或其它算法计算，这里假设用A*算法,遍历Y的子节点，点放入CLOSE,调整Y的子节点a的h值，h(a)=h(Y)+Y到子节点a的权重C(Y,a),比较a点是否存在于OPEN和CLOSE中，方法如下：
while()
{
从OPEN表中取k值最小的节点Y;
遍历Y的子节点a,计算a的h值 h(a)=h(Y)+Y到子节点a的权重C(Y,a)
{
if(a in OPEN) 比较两个a的h值
if( a的h值小于OPEN表a的h值 )
{ 更新OPEN表中a的h值;k值取最小的h值
有未受影响的最短路经存在
break;
}
if(a in CLOSE) 比较两个a的h值 //注意是同一个节点的两个不同路径的估价值
if( a的h值小于CLOSE表的h值 )
{
更新CLOSE表中a的h值; k值取最小的h值;将a节点放入OPEN表
有未受影响的最短路经存在
break;
}
if(a not in both)
将a插入OPEN表中; //还没有排序
}
放Y到CLOSE表；
OPEN表比较k值大小进行排序；
}
机器人利用第一步Dijstra计算出的最短路信息从a点到目标点的最短路经进行。
D*算法在动态环境中寻路非常有效，向目标点移动中，只检查最短路径上下一节点或临近节点的变化情况，如机器人寻路等情况。对于距离远的最短路径上发生的变化，则感觉不太适用。
② 寻找最短路径的汇编语言实现源代码是什么(用Dijkstra 算法)
Dijkstra算法Dijkstra算法是典型的最短路径算法，用于计算一个节点的最短路径中的所有其他节点。其主要特点是出发点为中心向外层层扩展，直到扩展到结束日期。 Dijkstra最短路径算法能得出最佳的解决方案，但许多节点，它遍历计算，这样的效率是低的。最短路径算法的
Dijkstra算法是非常有代表性的许多专业课程的基本内容进行了详细的介绍，如数据结构，图论，运筹学，等等。
Dijkstra算法的一般性发言一般有两种方式，永久和临时的标签，开启，关闭表的方式之一，德鲁表示，为了引进和下面的A *算法和D *算法一致，这里是开放的，关闭表。
贪婪的方法，算法策略
大概过程如下：
创建两个表，打开，关闭。
OPEN表保存没有调查之前已产生的所有节点，CLOSED表中记录已访问过的节点。
1。的道路网络的出发点和等待在公开组的检查没有检查点，此点。
2。打开表，以找出从起点最近的点，以确定所有的子节点，这一点，这点上关闭表。
3。遍历访问这个点的子节点。获得这些子节点从子节点到OPEN表的放电的开始点的距离的值。
4。重复步骤2和步骤3，直到OPEN表为空，或找到目标点。
[编辑本段]算法是
包括的文件
定义MAXNUM 765432100的
使用命名空间std;
ifstream的散热片（Dijkstra算法。在“）;
ofstream这样的FOUT（”Dijkstra.out“）;
诠释地图[501] [501];
布尔is_arrived [501];
诠释区[501] [501]，堆栈[501];
整数P，Q，K，路径，源代码，顶点，温度，SetCard
诠释FindMin（）
{
诠释P，温度= 0，MINM = MAXNUM;
（P = 1，P <=顶点，P + +）
（（区[P] MINM）&&（！is_arrived [P] ））
{
MINM区[P]。
温度= P;
}
收益温度;
}
：（ ）
{
的memset（is_arrived，0，大小（is_arrived））;
鳍>>源代码>>顶点;
（P = 1，P <=顶点，P + +）
（Q = 1，Q =顶点，Q + +）
{
鳍>>地图[P] [Q];
（图[ P] [Q] == 0）地图[P] [Q] = MAXNUM;
}
为（P = 1，P <=顶点，P + +）
{ />区[P] =地图[来源] [P];
（区[P]！= MAXNUM）
[P] =源;
其他
[P] = P;
}
is_arrived [来源] = TRUE;
SetCard = 1;
{
温度= FindMin（）;
（Temp! = 0）
{
SetCard SetCard +1;
is_arrived [温度] = TRUE;
（P = 1，P <=顶点，P + +）
（（区[P]>区[温度] +地图[温度] [P]）&&（！is_arrived [P]））
{
区[P] =区[温度] +地图[温度] [P]
[P] =温度;
}
}
其他
突破; BR />}
（SetCard! =顶点）;
（P = 1，P <=顶点，P + +）
（p! =源）
{
FOUT <<“======================== \ n”;
FOUT <<“来源：”<; <资料来源<<“\ n目标：”“P <<'\ n';
（区[P] == MAXNUM）
{
FOUT <<”距离：“< “无限\ n”;
FOUT <<“路径：没办法！”;
}
其他
{
FOUT“距离”：“<<区[P] <<'\ n';
K = 1;
路径= P;
同时（从[路径]！=路径）
{
栈[K] =路径;
路径=从[路径];
K = K +1;
}
FOUT <<“路径：”<（Q = K-1，Q = 1，Q - ）
FOUT“ - >”<<栈[问];
}
FOUT <<“\ ?======================== \ n \ n“;}
fin.close（）;
fout.close（）;
返回0;
}
样品输入
2
7
00 20 50 30 00 00 00
20 00 25 00 00 70 00
50 25 00 40 25 50 00
30 00 40 0??0 55 00 00
00 00 25 55 00 10 00
00 70 50 00 10 00 00
00 00 00 00 00 00 00
样本输出
========================
来源：2
目标：1
距离：20
路径：2 - > 1
==================== ====
========================
来源：
目标：3
距离：25
路径：2 - > 3 ========================
===== ===================
来源：
目标：4
距离：50
路径：2 - > 1 - > ======================== 4
============== =========
来源：
目标：5
距离：50
路径：2 - > 3 - > 5
== ======================
========================
来源：
目标：6
距离：60
路径：2 - > 3 - > 5 - > 6
========= ===============
========================
来源：2
目标：7
距离：无限
路径：没办法！
========================
示例程序和相关子程序如下：
无效的Dijkstra（INT N，INT [ ]距离的int [] iPath标）
{
诠释最短距离，U
INT I，J;
/ /从n个顶点的邻接矩阵的副本可以摆脱行了，是复制前n行的距离[]
（i = 0;我VerNum，我+ +）
{
距离=圆弧[N];
访问= 0;
} / / n个结点访问，因为n个顶点的出发点是
访问[N] = 1;
/ /找到的顶点其他顶点的路线，并且它不是顶点n的开头，没有先前旅游。
/ /相当于u点，这一点是没有的出发点N（i = 0; I <VerNum，我+ +）
{
U = 0
最短距离=否;
为（J = 0; <VerNum; + +）
（访问[J] == 0 &&（距离[J]最短距离））
{
最短距离=距离[J];
ü= J;
}
/ /例如P1871图G6距离=无，无，无，30,100]第一次看的是V2，U = 2
/ /找到结束，的MinDis意味着它无法连接，然后返回。这种情况是相似的V5。
（最短距离==否）返回;
/ /建立一个u个顶点将被用于顶点u，相当于弧[V，U +弧U，W] 。
访问[U] = 1;
/ /找到一个U顶点到所有其他顶点最小的路径实际上是在寻找弧] [U，J，J值在[0， VerNum]。
/ /如果是圆弧，U [I] +凯旋门[U，J] ARC [I，J]，ARC [I，J] =弧[I，U] +凯旋门[U J] <弧[I，J]
/ /的做法，因为距离[]是期望的结果，起始点确定的情况下，那就是：
/ /如果（距离[U] +圆弧[U，J）<=距离[J]：
/ /距离[J]距离[U] + [U，J弧];
/ /保存iPath标[] u点数量;
/ /同样，设置访问量：新发现的路由[J] = 0，经过寻找另一条道路，这条道路可能不利用。 V3
（J = 0; <VerNum; + +）
（访问[J] == 0 &&弧U，J] <&& U！= J） /> {
（（距离[U] +圆弧[U，J）<=距离[J]）
{
距离[J]距离[U] +弧[ U，J];
访问[J] = 0;
iPath标[J] = U;
}
}
}
} / /辅助功能
无效的Prim（），
{
INT I，M，N = 0;
为（i = 0;我VerNum;我+ +）
{
访问= 0;
T =新的TreeNode（）;
T.Text = V;
}
访问[N] + +;
listBox1.Items。添加（V [N]）;
（参观（）> 0）
{
（（M = MinAdjNode（N））！= -1）
{ BR /> T [N]。 Nodes.Add（T [M]）;
N = M;
访问[N] + +;
}
其他
{
?= MinNode（0）;
（N> 0）T [旻]。 Nodes.Add（T [敏]）;
访问[N] + +;
}
listBox1.Items.Add（V [N]）;
} treeView1.Nodes.Add（T [0]）;
}
的无效TopoSort（）
{
INT I，N;
listBox1.Items.Clear（ ）;
栈S =新的堆栈（）;
为（i = 0;我VerNum，我+ +）
访问= 0;
为（= VerNum- 1> = 0; I - ）
（入度（I）== 0）
{
S.Push（I）;
访问+ +; ...... />}
而（S.Count！= 0）
{
N =（INT）S.Pop（）;
listBox1.Items.Add（V [N] ）;
CLEARLINK（N）;
为（i = VerNum-1> = 0; I - ）
（分== 0 &&入度（I）== 0）
{
S.Push（I）;
访问+ +;
}
}
}
无效AOETrave（INT N，树节点TR，W）
{
INT I，W0;
（出度（N）== 0）返回;
（i = 0; <VerNum; + +）
（（W0 =圆弧[N，I]）！= 0）
{
listBox1.Items.Add（V +“\ t”+（W + W0）的ToString（）+“\ t”+ i.ToString（）+“\ t”+ n.ToString（））;
TreeNode的T1 =新的TreeNode（）;
T1.Text = V + “W =”+（W + W0）。的ToString（）+“]”;
TR.Nodes.Add（T1）;
AOETrave（I，T1，W + W0）;
}
}
无效AOE（）
{
INT I，W = 0，M = 1;
TreeNode的T1 =新的TreeNode（）;
为（i = 0; <VerNum;我+ +）
{
访问= 0;
}
T1.Text = V [0];
listBox1.Items.Add（“父母符号显示生成树：“）;
listBox1.Items.Add（”V \ TW \工业贸易署\ TPID“）;
为（i = 0;我VerNum，我+ +）
{
（（W =弧[0，I]）！= 0）
{
listBox1.Items.Add（V +“\ t”+ w.ToString（）+“\ T“+ i.ToString（）+”\ T0“）;
TreeNode的T2 =新的TreeNode（）;
T2.Text = V +”W =“+ w.ToString（）+” “;
AOETrave（I，T2，W）;
listBox1.Items.Add（”\ t \ t树“+ m.ToString
T1.Nodes.Add（ T2），（））;
米+ +;
}
}
treeView1.Nodes.Clear（）;
treeView1.Nodes.Add（T1）;
}
IsZero（）
{
我;
为（i = 0;我VerNum，我+ +）
（LineIsZero （一）> = 0）返回;
返回-1;
}
诠释LineIsZero（N）
{
我
（i = 0; <VerNum;我+ +）
（电弧[N，I] = 0）返回;
返回-1;}
：无效DepthTraverse（）
{
INT I，M;
（i = 0; <VerNum，我+ +）
{
访问= 0; BR /> T =新的TreeNode（）;
T.Text = V
R = 0;
}
而（（M = IsZero（））> = 0）
{
（访问[M] == 0）
{
listBox1.Items.Add（V [M]）;
R [M] = 1 ;}
访问[M] + +;
DTrave（M）;
}
为（i = 0; {
（R == 1）
treeView1.Nodes.Add（T）;
}
}
无效DTrave（N） /> {
我;
（LineIsZero（N）<0）返回;
为（i = VerNum-1> = 0; I - ）
（弧[N] = 0）
{
弧[N，I] = 0;
弧[I，N] = 0;
（访问= = 0）
{
listBox1.Items.Add（V）;
T [N]。 Nodes.Add（T）;
R = 0;
}
访问+ +;
DTrave（I）;
}
} ：无效BreadthTraverse（）
{
INT I，M;
（i = 0; <VerNum，我+ +）
{
访问= 0;
T =新的TreeNode（）;
T.Text = V;
R = 0;
}
而（（M = IsZero（））> = 0 ）
{
（访问[M] == 0）
{
listBox1.Items。添加（V [M]）;
R [M] = 1;
}
访问[M] + +;
BTrave（M）;
} BR />（i = 0;我VerNum，我+ +）
{
（R == 1）
treeView1.Nodes.Add（T）;
}
}
无效BTrave（N）
{
我
队列Q =新的Queue（）;
Q.Enqueue（N）
而（Q.Count！= 0）
{
为（i = 0;我VerNum，我+ +）
{
（电弧N，I] = 0）
{
弧[N，I] = 0;
弧[N] = 0;
（访问== 0）
{
listBox1.Items.Add（V）;
T [N]。 Nodes.Add（T）;
直径= 0;
}
访问+ +;
Q.Enqueue（I）;
}
} BR /> N =（int）的Q.Dequeue（）;
}
}
诠释MinNode（VN）
{
INT I，J，N，米，最小=否;
N = -1，M = -1;
为（i = VN我VerNum，我+ +）
中for（j = 0; J < VerNum; + +）
（电弧[I，J] = &&弧[I，J]闵&&分== 0 &&访问[J] == 1）
{ BR />最小值=弧[I，J]; N = I，M = J;
}
敏=旻= M
返回n;
} BR />诠释MinAdjNode（N）
{
我，敏，米;
最小值=否，M = -1;
（i = 0; I < VerNum，我+ +）
（电弧[N，I] =没有访问&& == 0 &&最小弧[N，I] &&访问[N] == 1）{BR /> BR />最小值=弧[N，I]，M = I;}
返回米;
}
INT访问（）
{
INT I，S = 0;
为（i = 0; <VerNum，我+ +）
（访问== 0）+ +;
返回s;
>}
[编辑本段] Dijkstra算法的Pascal实现：
程序Dijkstra的;
VAR
答：ARRAY [1 .. 100,1 .. 100的整数;
标志：数组[1] .. 100]布尔值;
W，X，N，I，J，分，明尼苏达州：整数;
开始
readln（N）;
我：= 1到n
开始
对于j = 1到n
读（A）;
readln;
结束;
fillchar（标志中，sizeof（标志），假）;
标志[1]：= TRUE;
明尼苏达州：= 1;
为：= 2到n
开始
分： 32767;
W：=明尼苏达州
我：= 1到n做
（W >）和（[W，I] <MIN），然后
开始
分：= [];
明尼苏达州：= I;
结束;
标志[明尼苏达州]：= TRUE;
J： 1到n做
（J >明尼苏达州）和（A [1，明尼苏达州] + A [明尼苏达州，J]，A [1，J）和（标志[J] = FALSE），那么 BR /> A [1，J] = [1，明尼苏达州] + A [明尼苏达州，J];
结束;
我：= 1到n做
写（ [1]）;
年底。
③ 计算机网络的最短路径算法有哪些对应哪些协议
用于解决最短路径问题的算法被称做“最短路径算法”，有时被简称作“路径算法”。最常用的路径算法有：
Dijkstra算法、A*算法、SPFA算法、Bellman-Ford算法和Floyd-Warshall算法，本文主要介绍其中的三种。
最短路径问题是图论研究中的一个经典算法问题，旨在寻找图（由结点和路径组成的）中两结点之间的最短路径。
算法具体的形式包括：
确定起点的最短路径问题：即已知起始结点，求最短路径的问题。
确定终点的最短路径问题：与确定起点的问题相反，该问题是已知终结结点，求最短路径的问题。在无向图中该问题与确定起点的问题完全等同，在有向图中该问题等同于把所有路径方向反转的确定起点的问题。
确定起点终点的最短路径问题：即已知起点和终点，求两结点之间的最短路径。
全局最短路径问题：求图中所有的最短路径。
Floyd
求多源、无负权边的最短路。用矩阵记录图。时效性较差，时间复杂度O(V^3)。
Floyd-Warshall算法（Floyd-Warshall algorithm）是解决任意两点间的最短路径的一种算法，可以正确处理有向图或负权的最短路径问题。
Floyd-Warshall算法的时间复杂度为O(N^3)，空间复杂度为O(N^2)。
Floyd-Warshall的原理是动态规划：
设Di,j,k为从i到j的只以(1..k)集合中的节点为中间节点的最短路径的长度。
若最短路径经过点k，则Di,j,k = Di,k,k-1 + Dk,j,k-1；
若最短路径不经过点k，则Di,j,k = Di,j,k-1。
因此，Di,j,k = min(Di,k,k-1 + Dk,j,k-1 , Di,j,k-1)。
在实际算法中，为了节约空间，可以直接在原来空间上进行迭代，这样空间可降至二维。
Floyd-Warshall算法的描述如下：
for k ← 1 to n do
for i ← 1 to n do
for j ← 1 to n do
if (Di,k + Dk,j < Di,j) then
Di,j ← Di,k + Dk,j;
其中Di,j表示由点i到点j的代价，当Di,j为 ∞ 表示两点之间没有任何连接。
Dijkstra
求单源、无负权的最短路。时效性较好，时间复杂度为O（V*V+E）,可以用优先队列进行优化，优化后时间复杂度变为0（v*lgn）。
源点可达的话，O（V*lgV+E*lgV）=>O（E*lgV）。
当是稀疏图的情况时，此时E=V*V/lgV，所以算法的时间复杂度可为O（V^2） 。可以用优先队列进行优化，优化后时间复杂度变为0（v*lgn）。
Bellman-Ford
求单源最短路，可以判断有无负权回路（若有，则不存在最短路），时效性较好，时间复杂度O（VE）。
Bellman-Ford算法是求解单源最短路径问题的一种算法。
单源点的最短路径问题是指：给定一个加权有向图G和源点s，对于图G中的任意一点v，求从s到v的最短路径。
与Dijkstra算法不同的是，在Bellman-Ford算法中，边的权值可以为负数。设想从我们可以从图中找到一个环
路（即从v出发，经过若干个点之后又回到v）且这个环路中所有边的权值之和为负。那么通过这个环路，环路中任意两点的最短路径就可以无穷小下去。如果不处理这个负环路，程序就会永远运行下去。 而Bellman-Ford算法具有分辨这种负环路的能力。
SPFA
是Bellman-Ford的队列优化，时效性相对好，时间复杂度O（kE）。（k< 与Bellman-ford算法类似，SPFA算法采用一系列的松弛操作以得到从某一个节点出发到达图中其它所有节点的最短路径。所不同的是，SPFA算法通过维护一个队列，使得一个节点的当前最短路径被更新之后没有必要立刻去更新其他的节点，从而大大减少了重复的操作次数。
SPFA算法可以用于存在负数边权的图，这与dijkstra算法是不同的。
与Dijkstra算法与Bellman-ford算法都不同，SPFA的算法时间效率是不稳定的，即它对于不同的图所需要的时间有很大的差别。
在最好情形下，每一个节点都只入队一次，则算法实际上变为广度优先遍历，其时间复杂度仅为O(E)。另一方面，存在这样的例子，使得每一个节点都被入队(V-1)次，此时算法退化为Bellman-ford算法，其时间复杂度为O(VE)。
SPFA算法在负边权图上可以完全取代Bellman-ford算法，另外在稀疏图中也表现良好。但是在非负边权图中，为了避免最坏情况的出现，通常使用效率更加稳定的Dijkstra算法，以及它的使用堆优化的版本。通常的SPFA。