寻找最短路径的汇编语言实现源代码是什么(用Dijkstra 算法) 关于求最短路径的Dijkstra算法的程序源代码

\u600e\u4e48\u7528c\u8bed\u8a00\u5b9e\u73b0\u5355\u6e90\u6700\u77ed\u8def\u5f84\u95ee\u9898\uff1f\u8981\u6c42\u662f\u7528Dijkstra\u7b97\u6cd5\uff0c\u6700\u597d\u5199\u51fa\u6240\u6709\u7684\u4ee3\u7801 \uff0c\u5305\u62ec\u7ed3\u6784\u5b9a\u4e49\u7b49\u7b49\uff0c\u5bf9\u4e00

C\u8bed\u8a00\u4ee3\u7801\uff1a//\u6e05\u534e\u5927\u5b66\u51fa\u7248\u793e\u5149\u76d8\u7684\u4ee3\u7801
void ShortestPath_DIJ(MGraph G,int v0,PathMatrix &P,ShortPathTable &D)
{ // \u7b97\u6cd57.15
// \u7528Dijkstra\u7b97\u6cd5\u6c42\u6709\u5411\u7f51G\u7684v0\u9876\u70b9\u5230\u5176\u4f59\u9876\u70b9v\u7684\u6700\u77ed\u8def\u5f84P[v]
// \u53ca\u5176\u5e26\u6743\u957f\u5ea6D[v]\u3002
// \u82e5P[v][w]\u4e3aTRUE\uff0c\u5219w\u662f\u4ecev0\u5230v\u5f53\u524d\u6c42\u5f97\u6700\u77ed\u8def\u5f84\u4e0a\u7684\u9876\u70b9\u3002
// final[v]\u4e3aTRUE\u5f53\u4e14\u4ec5\u5f53v\u2208S,\u5373\u5df2\u7ecf\u6c42\u5f97\u4ecev0\u5230v\u7684\u6700\u77ed\u8def\u5f84\u3002
int i=0,j, v,w,min;
bool final[MAX_VERTEX_NUM];
for (v=0; v<G.vexnum; ++v) {
final[v] = FALSE;
D[v] = G.arcs[v0][v].adj;
for (w=0; w<G.vexnum; ++w) P[v][w] = FALSE; // \u8bbe\u7a7a\u8def\u5f84
if (D[v] < INFINITY) { P[v][v0] = TRUE; P[v][v] = TRUE; }
}
D[v0] = 0; final[v0] = TRUE; // \u521d\u59cb\u5316\uff0cv0\u9876\u70b9\u5c5e\u4e8eS\u96c6
//--- \u5f00\u59cb\u4e3b\u5faa\u73af\uff0c\u6bcf\u6b21\u6c42\u5f97v0\u5230\u67d0\u4e2av\u9876\u70b9\u7684\u6700\u77ed\u8def\u5f84\uff0c\u5e76\u52a0v\u5230S\u96c6 ---
for (i=1; i<G.vexnum; ++i) { // \u5176\u4f59G.vexnum-1\u4e2a\u9876\u70b9
min = INFINITY; // \u5f53\u524d\u6240\u77e5\u79bbv0\u9876\u70b9\u7684\u6700\u8fd1\u8ddd\u79bb
for (w=0; w<G.vexnum; ++w)
if (!final[w]) // w\u9876\u70b9\u5728V-S\u4e2d
if (D[w]<min) { v = w; min = D[w]; } // w\u9876\u70b9\u79bbv0\u9876\u70b9\u66f4\u8fd1
final[v] = TRUE; // \u79bbv0\u9876\u70b9\u6700\u8fd1\u7684v\u52a0\u5165S\u96c6
for (w=0; w<G.vexnum; ++w) // \u66f4\u65b0\u5f53\u524d\u6700\u77ed\u8def\u5f84\u53ca\u8ddd\u79bb
if (!final[w] && (min+G.arcs[v][w].adj<D[w])) {
// \u4fee\u6539D[w]\u548cP[w], w\u2208V-S
D[w] = min + G.arcs[v][w].adj;
for(j=0;j<G.vexnum;j++) P[w][j] = P[v][j]; //\u7b2cv\u884c\u8d4b\u503c\u4e8e\u7b2cw\u884c
P[w][w] = TRUE; // P[w] = P[v]+[w]
}//if
}//for
} // ShortestPath_DIJ

\u4e0b\u9762\u662f\u5728\u767e\u5ea6\u4e0a\u627e\u5230\u7684\u4e00\u7bc7\uff0c\u5df2\u7ecf\u53d1\u5230\u4f60\u7684\u90ae\u7bb1\u91cc\u9762\u4e86\uff1a\uff09
Dijkstra\u7b97\u6cd5--c++\u6e90\u4ee3\u7801--by \u4f1f\u4f1f\u732a [\u8f6c\u8d34 2005-12-15 20:21:00 ] \u53d1\u8868\u8005: \u4f1f\u4f1f\u732a




/***********************************************
\u8bbeG=(V,E)\u662f\u4e00\u4e2a\u6bcf\u6761\u8fb9\u90fd\u6709\u975e\u8d1f\u957f\u5ea6\u7684\u6709\u5411\u56fe\uff0c\u6709\u4e00\u4e2a\u7279\u5f02\u7684\u9876\u70b9s\u79f0\u4e3a\u7f18\u3002
\u5355\u6e90\u6700\u77ed\u8def\u5f84\u95ee\u9898\uff0c\u6216\u8005\u79f0\u4e3a\u6700\u77ed\u8def\u5f84\u95ee\u9898\uff0c\u662f\u8981\u786e\u5b9a\u4eces\u5230V\u4e2d\u6ca1\u4e00\u4e2a\u5176\u4ed6
\u9876\u70b9\u7684\u8ddd\u79bb\uff0c\u8fd9\u91cc\u4ece\u9876\u70b9s\u5230x\u7684\u8ddd\u79bb\u5b9a\u4e49\u4e3a\u4eces\u5230x\u7684\u6700\u77ed\u8def\u5f84\u95ee\u9898\u3002\u8fd9\u4e2a\u95ee\u9898
\u53ef\u4ee5\u7528Dijkstra\u7b97\u6cd5\u89e3\u51b3\u3002\u4e0b\u9762\u6211\u7ed9\u6211\u4e86c++\u4e0b\u7684\u6e90\u4ee3\u7801\uff01 --by \u4f1f\u4f1f\u732a
************************************************/
#include
void main()
{
int infinity=100,j,i,n,k,t,**w,*s,*p,*d;
cout<<"input the value of n:";
cin>>n;
cout<<endl;

d=new int[n];
s=new int[n];
p=new int[n];
w=new int*[n];
for(i=0;i<n;i++) {w[i]=new int[n];}
for(i=0;i<n;i++)
for(j=0;j<n;j++)
cin>>w[i][j];


for(s[0]=1,i=1;i<n;i++)
{
s[i]=0;d[i]=w[0][i];
if(d[i]<infinity) p[i]=0;
else p[i]=-1;
}



for(i=1;i<n;i++)
{
t=infinity;k=1;
for(j=1;j<n;j++)
if((!s[j])&&(d[j]<t)) {t=d[j];k=j;}
s[k]=1;//point k join the S
for (j=1;j<n;j++)
if((!s[j])&&(d[j]>d[k]+w[k][j]))
{d[j]=d[k]+w[k][j];p[j]=k;}

}
cout<<"\u4ece\u6e90\u70b9\u5230\u5176\u5b83\u9876\u70b9\u7684\u6700\u77ed\u8ddd\u79bb\u4f9d\u6b21\u5982\u4e0b\uff1a";
for(i=1;i<n;i++) cout<<d[i]<<" ";



}
/*********
\u9876\u70b9\u4e2a\u6570\u7528n\u8868\u793a\uff0c\u8fd9\u91cc\u7ed9\u51fa\u7684\u4f8b\u5b50n=6
100 1 12 100 100 100
100 100 9 3 100 100
100 100 100 100 5 100
100 100 4 100 13 15
100 100 100 100 100 4
100 100 100 100 100 100
\u5177\u4f53\u4f8b\u5b50\u89c1 \u7535\u5b50\u5de5\u4e1a\u51fa\u7248\u793e \u300a\u7b97\u6cd5\u8bbe\u8ba1\u6280\u5de7\u4e0e\u5206\u6790\u300b148\u9875
************/

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]）;
年底。

有难度

瀵绘壘鏈鐭矾寰勭殑姹囩紪璇█瀹炵幇婧浠ｇ爜鏄粈涔(鐢―ijkstra 绠楁硶)
绛旓細Dijkstra绠楁硶Dijkstra绠楁硶鏄吀鍨嬬殑鏈鐭矾寰绠楁硶,鐢ㄤ簬璁＄畻涓涓妭鐐圭殑鏈鐭矾寰勪腑鐨勬墍鏈夊叾浠栬妭鐐广傚叾涓昏鐗圭偣鏄嚭鍙戠偣涓轰腑蹇冨悜澶栧眰灞傛墿灞,鐩村埌鎵╁睍鍒扮粨鏉熸棩鏈熴 Dijkstra鏈鐭矾寰勭畻娉曡兘寰楀嚭鏈浣崇殑瑙ｅ喅鏂规,浣嗚澶氳妭鐐,瀹冮亶鍘嗚绠,杩欐牱鐨勬晥鐜囨槸浣庣殑銆傛渶鐭矾寰勭畻娉曠殑 Dijkstra绠楁硶鏄潪甯告湁浠ｈ〃鎬х殑璁稿涓撲笟璇剧▼鐨勫熀鏈唴瀹硅繘琛屼簡...

姹鏈鐭矾寰浼浠ｇ爜,鐢–璇█鎴朇++
绛旓細濡備笅鎵绀 class HelloWorld public static void main(String[] args) } 娉ㄦ剰鎴戜滑鐨刣isplayHelloWorld()鏂规硶鐨勫０鏄庯紝瀹冩湁涓涓叧閿瓧native锛岃〃鏄庤繖涓柟娉曚娇鐢╦ava浠ュ鐨璇█瀹炵幇銆傛柟娉曚笉鍖呮嫭瀹炵幇锛屽洜涓烘垜浠鐢╟/c++璇█瀹炵幇瀹冦傛敞鎰廠ystem.loadLibrary("hello")杩欏彞浠ｇ爜锛屽畠鏄湪闈欐佸垵濮嬪寲鍧椾腑瀹氫箟鐨勶紝绯...

c璇█缂栧啓璺嚎
绛旓細int previous[MAX-1];// 姹傝矾寰勯渶瑕 int pp[MAX-1];// 璁板綍鏈鐭矾寰 typedef struct graphnode { int vexnum; //椤剁偣 int arcnum; //寮 int gra[MAX][MAX]; //閭绘帴鐭╅樀琛ㄧず0鎴1 }Graph;int dist[MAX]; // 鏈鐭窛绂 int arc[MAX][MAX]; // 鏉 int main(){ void Dijkst...

C璇█鎴栬匔++ 鎴栬匔# 缂栫▼棰樼洰
绛旓細VC浠ｈ〃鐨刅isual C + +锛孋 + +璇█鐨勬牳蹇冩槸涓涓 C + +涓殑c璇█鐨勫熀纭涓婂彂灞曡屾潵鐨勯潰鍚戝璞＄殑鐗规с C / C + +缂栬瘧鍣鐨勭▼搴鐩存帴缂栬瘧鎴愪簩杩涘埗浠ｇ爜锛孋锛冩湰璐ㄤ笂鐨勪笉鍚屻侰 / C + + / C锛冨彲浠ヨ鏄竴绯诲垪鐨勮瑷锛屽叾璇硶鐪嬭捣鏉ラ潪甯哥殑鍠滄銆侰锛冪殑璇炵敓涓嶆槸C / C + +锛孋 + +澶╃殑鏇夸唬鍝...

绗17灞婁俊鎭濂ヨ禌
绛旓細B.绋嬪簭杩愯鏃剁悊璁轰笂鎵鍗犵殑鏁扮粍绌洪棿C.绋嬪簭杩愯鏃剁悊璁轰笂鎵鍗犵殑纭洏绌洪棿D.绋嬪簭婧鏂囦欢鐞嗚涓婃墍鍗犵殑纭洏绌洪棿7.搴旂敤蹇熸帓搴忕殑鍒嗘不鎬濇兂,鍙互瀹炵幇涓涓眰绗琄澶ф暟鐨勭▼搴銆傚亣瀹氫笉鑰冭檻鏋佺鐨勬渶鍧忔儏鍐,鐞嗚涓婂彲浠瀹炵幇鐨鏈浣庣殑绠楁硶鏃堕棿澶嶆潅搴︿负( )銆侫.O (n2) B.O (n log n ) C.O (n) D. O (1) 8.涓鸿В鍐...

澶х悊澶у璁＄畻鏈轰笓涓氳绋嬭缃浣?
绛旓細绋嬪簭璁捐鍩虹锛氭湰璇剧▼涓昏璁叉巿绋嬪簭璁捐鐨勫熀鏈師鐞嗗拰鏂规硶锛屽寘鎷暟鎹被鍨嬨佹帶鍒剁粨鏋勩佸嚱鏁般佹暟缁勩佹寚閽堢瓑鍩烘湰姒傚康銆傚鐢熷皢瀛︿範浣跨敤C璇█鎴朖ava璇█杩涜绋嬪簭璁捐銆傛暟鎹粨鏋勪笌绠楁硶锛氭湰璇剧▼浠嬬粛璁＄畻鏈轰腑甯哥敤鐨勬暟鎹粨鏋勶紙濡傜嚎鎬ц〃銆佹爤銆侀槦鍒椼佹爲銆佸浘绛夛級鍜岀畻娉曪紙濡傛帓搴忋佹煡鎵俱鏈鐭矾寰绛夛級銆傚鐢熷皢瀛︿範濡備綍鍒嗘瀽绠楁硶...

鐢佃剳绋嬪紡璇█閮芥湁鍝簺鍟?
绛旓細绋嬪紡璇█閮芥湁鍝簺婕旂畻娉 锛堜竴锛夊熀鏈紨绠楁硶 : 1.鍒椾妇 2.鎼滃: 娣卞害浼樺厛鎼滃 骞垮害浼樺厛鎼滃 鍚彂寮忔悳瀵 閬椾紶婕旂畻娉 锛堜簩锛夎祫鏂欑粨鏋勭殑婕旂畻娉 锛堜笁锛夋暟璁轰笌浠ｆ暟婕旂畻娉 锛堝洓锛夎绠楀嚑浣曠殑婕旂畻娉曪細姹傚嚫鍖 锛堜簲锛夊浘璁 婕旂畻娉曪細 1.鍝堝か鏇肩紪鐮 2.鏍戠殑閬嶅巻 3.鏈鐭矾寰 婕旂畻娉 4.鏈灏忕敓鎴愭爲 婕旂畻娉 5...

璁＄畻鏈3绾ч兘鍖呮嫭閭ｄ簺绉戠洰?
绛旓細鍙墽琛岀▼寮.exe鏄渶鐔熸倝鐨 鍙鏄彲浠ュ弻鍑绘墽琛岀殑閮藉彨绋嬪紡! 鐥呮瘨涔熸槸绋嬪紡! 甯屾湜鎴戠殑鍥炵瓟鍙互甯埌鎮ㄥ摝 璁＄畻鏈轰笁绾у寘鎷偅浜?鍝釜濂藉? 涓夌骇鈥淧C 鎶鏈濊瘉涔,琛ㄦ槑鎸佹湁浜哄叿鏈夎绠楁満搴旂敤鐨勫熀纭鐭ヨ瘑,鎺屾彙Pentium寰鐞嗗櫒鍙奝C璁＄畻鏈虹殑宸ヤ綔鍘熺悊,鐔熸倝PC鏈哄父鐢ㄥ閮ㄨ缃殑鍔熻兘涓庣粨鏋,浜嗚ВWINDOWS浣滀笟绯荤粺鐨勫熀鏈師鐞,鑳戒娇鐢姹囩紪璇█...

noip鐨勫涔犺鍒?(杩藉姞鍒)
绛旓細缈昏瘧绋嬪簭: (缂栬瘧绋嬪簭)涓绫诲緢閲嶈鐨勮瑷澶勭悊绋嬪簭,瀹冩妸楂樼骇璇█(濡侳ORTRAN,COBOL,pascal,c绛)婧愮▼搴浣滀负杈撳叆,杩涜缈昏瘧杞崲,浜х敓鍑烘満鍣ㄨ瑷鐨勭洰鏍囩▼搴,鐒跺悗鍐嶈璁＄畻鏈哄幓鎵ц杩欎釜鐩爣绋嬪簭,寰楀埌璁＄畻缁撴灉.璇█: 鏈哄櫒璇█ 姹囩紪璇█ 楂樼骇璇█(闈㈠悜瀵硅薄,闈㈠悜杩囩▼)c. 搴旂敤杞欢鏁版嵁搴撶鐞嗚蒋浠: Foxpro,Access,Orale,Sybase,DB2鍜...

2006 璁＄畻鏈虹瓑绾ц冭瘯澶х翰
绛旓細5銆佽绠楁満涓満鍣ㄨ瑷銆姹囩紪璇█銆侀珮绾ц瑷鍜屾暟鎹簱璇█鐨勬蹇点 6銆佽绠楁満鐨勫畨鍏ㄦ搷浣,鐥呮瘨鐨勬蹇靛強鍏堕槻娌汇 7.澶氬獟浣撹绠楁満鐨勫垵姝ョ煡璇嗐 浜屻佹搷浣滅郴缁熺殑鍔熻兘鍜屼娇鐢 1.鎿嶄綔绯荤粺鐨勫姛鑳藉拰鍒嗙被銆 2.鎿嶄綔绯荤粺鐨勭粍鎴愩佹枃浠躲佺洰褰曘佺洏绗﹀拰璺緞銆佸父鐢ㄥ懡浠ゃ 3.Windows 95浣跨敤鍒濇: (1)Windows 95鐨勭壒鐐广佸姛鑳姐侀厤缃佽繍琛...

扩展阅读：扫一扫题目出答案 ... 最短路径表格怎么画 ... 初二数学最短路径问题 ... 最短路径问题画法 ... 最短路径图解 ... 单源最短路径画图 ... 最短路径和简单路径 ... 最短路径的生成算法 ... 八年级最短路径题以及答案 ...