vis演算法
① 粒子群優化演算法和多模態優化演算法有什麼區別
摘 要：，粒子群演算法據自己的速度來決定搜索過程，只有最優的粒子把信息給予其他的粒子，整個搜索更新過程是跟隨當前最優解的過程，所有的粒子還可以更快的收斂於最優解。由於微粒群演算法簡單，容易實現，與其它求解約束優化問題的方法相比較，具有一定的優勢。實驗結果表明，對於無約束的非線性求解，粒子群演算法表現出較好的收斂性和健壯性。
關鍵詞：粒子群演算法；函數優化；極值尋優
0 引言
非線性方程的求根問題是多年來數學家努力解決的問題之一。長期以來，人們已找出多種用於解決方程求根的方法，例如牛頓法、弦割法、拋物線法等。然而，很多傳統的方法僅能運用於相應的小的問題集，推廣性相對較差。對於一個現實世界中的優化問題，必須嘗試很多不同的方法，甚至要發明相應的新的方法來解決，這顯然是不現實的。我們需要另外的方法來克服這樣的困難。
粒子群演算法是一種現代啟發式演算法，具有推廣性強、魯棒性高等特點[1]。該演算法具有群體智能、內在並行性、迭代格式簡單、可快速收斂到最優解所在區域等優點[2]。本文採用粒子群演算法，對函數的極值進行尋優計算，實現了對函數的極值求解。
1 粒子群演算法
1.1 基本原理
粒子群演算法（PSO）是一種基於群體的隨機優化技術，它的思想來源於對鳥群捕食行為的研究與模擬。粒子群演算法與其它基於群體的進化演算法相類似，選用「群體」和「進化」的概念，按照個體的適應度值進行操作，也是一種基於迭代的尋優技術。區別在於，粒子群演算法中沒有交叉變異等進化運算元，而是將每個個體看作搜索空間中的微粒，每個微粒沒有重量和體積，但都有自己的位置向量、速度向量和適應度值。所有微粒以一定的速度飛行於搜索空間中，其中的飛行速度是由個體飛行經驗和群體的飛行經驗動態調整，通過追蹤當前搜索到的最優值來尋找全局最優值。
1.2 參數選擇
粒子群演算法需要修改的參數很少，但對參數的選擇卻十分敏感。El-Gallad A, El-Hawary M, Sallam A, Kalas A[3]主要對演算法中的種群規模、迭代次數和粒子速度的選擇方法進行了詳細分析，利用統計方法對約束優化問題的求解論證了這 3 個參數對演算法性能的影響，並給出了具有一定通用性的3 個參數選擇原則[4]。
種群規模：通常根據待優化問題的復雜程度確定。
最大速度：決定粒子在一次迭代中的最大移動距離,通常設定為不超過粒子的范圍寬度。
加速常數：加速常數c1和c2通常是由經驗值決定的，它代表粒子向pbest和gbest靠攏的加速項的權重。一般取值為：c1=c2=2。
中止條件：達到最大迭代次數或得到最小誤差要求，通常要由具體問題確定。
慣性權重：慣性權重能夠針對待優化問題調整演算法的局部和全局搜索能力。當該值較大時有利於全局搜索，較小時有利於局部搜索。所以通常在演算法開始時設置較大的慣性權重，以便擴大搜索范圍、加快收斂。而隨著迭代次數的增加逐漸減小慣性權重的值，使其進行精確搜索，避免跳過最優解。
1.3 演算法步驟
PSO演算法步驟如下：
Step1：初始化一個規模為 m 的粒子群，設定初始位置和速度。
初始化過程如下：
（1）設定群體規模m;
（2）對任意的i，s，在[-xmax, xmax]內均勻分布，產生初始位置xis；
（3）對任意的i，s，在[-vmax, vmax]內均勻分布，產生速度vis；
（4）對任意的i，設yi=xi，保存個體。
Step2：計算每個粒子的適應度值。
Step3：對每個粒子的適應度值和得到過的最好位置pis的適應度值進行比較，若相對較好，則將其作為當前的最好位置。
Step4：對每個粒子的適應度值和全局得到過的最好位置pgs的適應度值進行比較，若相對較好，則將其作為當前的全局最好位置。
Step5：分別對粒子的所在位置和速度進行更新。
Step6：如果滿足終止條件，則輸出最優解；否則，返回Step2。
1.4 粒子群演算法函數極值求解
粒子群演算法優化是計算機智能領域，除蟻群演算法外的另一種基於群體智能的優化演算法。粒子群演算法是一種群體智能的煙花計算技術。與遺傳演算法相比，粒子群演算法沒有遺傳演算法的選擇（Selection）、交叉（Crossover）、變異（Mutation）等操作，而是通過粒子在解空間追隨最優的粒子進行搜索。
粒子群演算法流程如圖所示：
粒子群為由n個粒子組成的種群X = (X1,X2,X3,…Xn).
第i個粒子表示一個D維向量Xi = (X1,X2,X3,…XD)T.
第i個粒子的速度為Vi = (Vi1,Vi2,Vi3,…ViD)T.
個體極值為Pi = (Pi1,Pi2,Pi3,…PiD)T.
全局極值為Pg = (Pg1,Pg2,Pg3,…PgD)T.
速度更新為，式中，c1和c2為其兩個學習因子的參數值；r1和r2為其兩個隨機值。
位置更新為.
2 粒子群演算法應用舉例
2.1 實驗問題
這是一個無約束函數的極值尋優，對於Ackley函數，
.
其中c1=20，e=2. 71289。
2.2 實驗步驟
對於Ackley函數圖形，選取一個凹峰進行分析，程序運行結果如圖所示。
圖1 Ackley函數圖形
可以看出，選取區間內的Ackley函數圖形只有一個極小值點。因此，對於該段函數進行尋優，不會陷入局部最小。採用粒子群演算法對該函數進行極值尋優。
首先，進行初始化粒子群，編寫的MATLAB代碼如下：
% 初始化種群
for i=1:sizepop
x1 = popmin1 (popmax1-popmin1)*rand;
% 產生隨機個體
x2 = popmin2 (popmax2-popmin2)*rand;
pop(i,1) = x1; % 保存產生的隨機個體
pop(i,2) = x2;
fitness(i) = fun([x1,x2]); % 適應度值
V(i,1) = 0; % 初始化粒子速度
V(i,2) = 0;
end
程序運行後所產生的個體值為：
表1 函數個體值
然後，根據待尋優的目標函數，計算適應度值。待尋優的目標函數為：
function y = fun(x)
y=-20*exp(-0.2*sqrt((x(1)^2x(2)^2)/2))-exp((cos(2*pi*x(1)) cos(2*pi*x(2)))/2) 20 2.71289;
根據每一組個體，通過目標函數，得到的適應度值為：
表2 函數適應度值
搜索個體最優極值，即搜索最小的適應度值，我們可利用MATLAB繪圖將所有個體的適應度值繪成plot圖查看相對最小值。
圖3 函數適應度plot圖
從圖中可看出，當個體=20時，得到相對最小值，在程序中，將其保存下來。
之後進行迭代尋優，直到滿足終止條件。
最後，得到的最優值為：
圖4 MATLAB運行得到結果
迭代後得到的運行結果圖如下：
圖5 迭代曲線圖
2.3 實驗結果
通過圖5中可看出，該函數的尋優是收斂的，最優個體和實際情況較吻合。因此，採用粒子群演算法進行函數極值尋優，快速、准確且魯棒性較好。
3 結論
本文闡述了粒子群演算法求解最化問題的過程，實驗結果表明了該演算法對於無約束問題的可行性。與其它的進化演算法相比，粒子群演算法容易理解、編碼簡單、容易實現。但是參數的設置對於該演算法的性能卻有很大的影響，例如控制收斂，避免早熟等。在未來的工作中，將努力於將其它計算智能演算法或其它優化技術應用於粒子群演算法中，以進一步提高粒子群演算法的性能。
② 數據結構(C語言版)題目，大神來
Prim演算法：
intMap[10][10];
intdis[10],vis[10],F[10];
voidPrim(){
memset(vis,0,sizeof(vis));
intans=0;vis[1]=1;
for(inti=2;i<=7;i++){dis[i]=Map[i][1]!=-1?Map[i][1]:INF;F[i]=1;}
for(inti=2;i<=7;i++){
intMin=INF,p;
for(intj=1;j<=7;j++)if(!vis[j]&&dis[j]<Min)
Min=dis[p=j];
vis[p]=1;ans+=Min;
cout<<"加邊:("<<p<<","<<F[p]<<")邊權："<<Map[p][F[p]]<<endl;
for(intj=1;j<=7;j++)if(!vis[j]&&Map[p][j]!=-1)
if(Map[p][j]<dis[j]){
dis[j]=Map[p][j];
F[j]=p;
}
}
cout<<"總權值："<<ans<<endl;
}
intmain(){
memset(Map,-1,sizeof(Map));
while(true){
inta,b;cin>>a>>b;if(a==-1&&b==-1)break;
intc;cin>>c;Map[a][b]=Map[b][a]=c;
}
Prim();
return0;
}
輸入及運行結果：
輸入：
166
1220
1719
6717
659
2717
5719
2316
7315
7420
5424
3413
-1-1
結果：
加邊:(6,1)邊權：6
加邊:(5,6)邊權：9
加邊:(7,6)邊權：17
加邊:(3,7)邊權：15
加邊:(4,3)邊權：13
加邊:(2,3)邊權：16
總權值：76
Kruskal演算法：
structEdge{
intu,v,w;
booloperator<(constEdge&a)const{
returnw<a.w;
}
};
Edgeedge[100];inttot=0;
intpre[100];
intFind(intx){
returnx==pre[x]?x:pre[x]=Find(pre[x]);
}
voidKruskal(){
for(inti=0;i<=7;i++)pre[i]=i;
sort(edge,edge+tot);
intcnt=1,ans=0;
for(inti=0;i<tot;i++){
if(cnt==7)break;
intu=edge[i].u,v=edge[i].v,w=edge[i].w;
intfu=Find(u),fv=Find(v);
if(fu==fv)continue;
pre[fu]=fv;cnt++;ans+=w;
cout<<"加邊（"<<u<<","<<v<<"）"<<"邊權："<<w<<endl;
}
cout<<"總的權值："<<ans<<endl;
}
intmain(){
while(true){
inta,b;cin>>a>>b;if(a==-1&&b==-1)break;
intc;cin>>c;edge[tot++]=(Edge){a,b,c};
}
Kruskal();
return0;
}
輸入及運行結果：
輸入：
166
1220
1719
6717
659
2717
5719
2316
7315
7420
5424
3413
-1-1
結果：
加邊（1,6）邊權：6
加邊（6,5）邊權：9
加邊（3,4）邊權：13
加邊（7,3）邊權：15
加邊（2,3）邊權：16
加邊（6,7）邊權：17
總的權值：76
③ 求A到B之間的最短路徑，怎麼獲取
問題：從某頂點出發，沿圖的邊到達另一頂點所經過的路徑中，各邊上權值之和最小的一條路徑——最短路徑。解決最短路的問題有以下演算法，Dijkstra演算法，Bellman-Ford演算法，Floyd演算法和SPFA演算法，另外還有著名的啟發式搜索演算法A*，不過A*准備單獨出一篇，其中Floyd演算法可以求解任意兩點間的最短路徑的長度。任意一個最短路演算法都是基於這樣一個事實：從任意節點A到任意節點B的最短路徑不外乎2種可能，1是直接從A到B，2是從A經過若干個節點到B。
(1) 迪傑斯特拉(Dijkstra)演算法按路徑長度(看下面表格的最後一行，就是next點)遞增次序產生最短路徑。先把V分成兩組：
S：已求出最短路徑的頂點的集合
V-S=T：尚未確定最短路徑的頂點集合
將T中頂點按最短路徑遞增的次序加入到S中，依據：可以證明V0到T中頂點Vk的最短路徑，或是從V0到Vk的直接路徑的權值或是從V0經S中頂點到Vk的路徑權值之和（反證法可證，說實話，真不明白哦）。
(2) 求最短路徑步驟
初使時令 S={V0},T={其餘頂點}，T中頂點對應的距離值， 若存在<V0,Vi>，為<V0,Vi>弧上的權值（和SPFA初始化方式不同），若不存在<V0,Vi>，為Inf。
從T中選取一個其距離值為最小的頂點W(貪心體現在此處)，加入S(注意不是直接從S集合中選取，理解這個對於理解vis數組的作用至關重要)，對T中頂點的距離值進行修改：若加進W作中間頂點，從V0到Vi的距離值比不加W的路徑要短，則修改此距離值（上面兩個並列for循環，使用最小點更新）。
重復上述步驟，直到S中包含所有頂點，即S=V為止（說明最外層是除起點外的遍歷）。
④ Java數組的全排列，裡面布爾類型的數組vis[ ]，在遞歸演算法里起了什麼作用，遞歸那塊理解不了，求詳細解答
不要急於看代碼，你心理要知道全排列的思路，不注重思路是很多程序員易犯的錯誤。
全排列演算法：
如果我求得固定第一位後的排列，那麼全部排列就可以求出，固定第一位有10種可能，可以循環求得。
如果我求得固定第二位後的排列，固定第一位後的排列就可以求出，固定第二位有9種可能，可以循環求得。
。。。
如果我求得固定第10位後的排列，固定第9位後的排列就可以求出，固定第10位有1種可能，可以循環求得。
這很明顯是遞歸的演算法。
static void dfs(int start,int end,int num){//為全部排列的集合，start為數字的位置,end為最後一位，num多餘的
if(start==end){//當前的數字位置為最後一位時，說明，一個序列已經生成
for(int i=1;i<end;i++)
System.out.print(a[i]+" ");//輸出序列
System.out.println();
}
else{//序列沒有生成時
for(int i=1;i<end;i++){
if(vis[i])//i是否在前面使用過
continue;//如果是直接跳過
a[start]=i;//確定start位置的數字，當start為1時就是確定第一位，有10種可能
vis[i]=true;//設置i為已使用狀態，避免下一位使用i
dfs(start+1,end,num);//求得確定start位後的全部序列
vis[i]=false;//設置i為未使用狀態
}
}
⑤ 運動員最佳配對問題
#include <bits/stdc++.h>
using namespace std;
int n, a[22][22], b[22][22], vis[22], pre[22], ans;
void dfs(int x, int s)
{
if(x>n)
{
ans = max(ans, s);
return;
}
if(s+pre[n]-pre[x-1]<ans)
{
return;
}
for(int i = 1; i<=n; i++)
{
if(!vis[i])
{
vis[i] = 1;
dfs(x+1, s+a[x][i]*b[i][x]);
vis[i] = 0;
}
}
}
int main()
{
cin>>n;
for(int i = 1; i<=n; i++)
{
for(int j = 1; j<=n; j++)
{
cin>>a[i][j];
}
}
for(int i = 1; i<=n; i++)
{
for(int j = 1; j<=n; j++)
{
cin>>b[i][j];
}
}
for(int i = 1; i<=n; i++)
{
for(int j = 1; j<=n; j++)
{
pre[i] = max(pre[i], a[i][j] * b[j][i]);
}
pre[i] += pre[i - 1];
}
dfs(1, 0);
cout<< ans <<endl;
}
⑥ 求此程序！在線等，急！
Tarjan 演算法
一.演算法簡介
Tarjan 演算法一種由Robert Tarjan提出的求解有向圖強連通分量的演算法，它能做到線性時間的復雜度。
我們定義：
如果兩個頂點可以相互通達，則稱兩個頂點強連通(strongly connected)。如果有向圖G的每兩個頂點都強連通，稱G是一個強連通圖。有向圖的極大強連通子圖，稱為強連通分量(strongly connected components)。
1 void Tarjan ( int x ) { 2 dfn[ x ] = ++dfs_num ; 3 low[ x ] = dfs_num ; 4 vis [ x ] = true ;//是否在棧中 5 stack [ ++top ] = x ; 6 for ( int i=head[ x ] ; i!=0 ; i=e[i].next ){ 7 int temp = e[ i ].to ; 8 if ( !dfn[ temp ] ){ 9 Tarjan ( temp ) ;10 low[ x ] = gmin ( low[ x ] , low[ temp ] ) ;11 }12 else if ( vis[ temp ])low[ x ] = gmin ( low[ x ] , dfn[ temp ] ) ;13 }14 if ( dfn[ x ]==low[ x ] ) {//構成強連通分量15 vis[ x ] = false ;16 color[ x ] = ++col_num ;//染色17 while ( stack[ top ] != x ) {//清空18 color [stack[ top ]] = col_num ;19 vis [ stack[ top-- ] ] = false ;20 }21 top -- ;22 }23 }
⑦ 演算法入門經典的黑白圖問題
說實話沒弄明白什麼是八連塊。。。
不過貌似有越界問題——dfs(x-1,y-1);
這個地方邊界也不對
for(int i=0;i<=n;i++)
for(int j=0;j<=n;j++)
if((!vis[i][j])&&(mat[i][j]))
⑧ 如何通俗地解釋匈牙利演算法
是指二分圖匹配的這個演算法吧？下面是復制的，原文有圖
原文地址：http://blog.csdn.net/lw277232240/article/details/72615522
二分圖匹配，江湖稱二分匹配，圖論相關演算法。
現在給出兩個集合，我們拿約會來舉例子。一方是男生集合，一方是女生集合，女生都比較內斂，對不認識的男孩紙並不喜歡一起約會，所以這里邊就要有人際關系的問題了。
這里給男生編號n1,n2.....nn;女生編號v1v2....vn；
下面給出女生認識的男生的列表：
v1 :n1 ,n2.
v2 :n2, n3.
v3 : n1.
這里顯而易見，1號男生2號男生是比較受歡迎的哈~。不用演算法思想的去想這個問題我們可以這樣思考：三號女生只認識1號男生，匹配上。（1組搞定）這個時候一號女生就不能選擇1號男生了，她只能去選2號男生，這時候2號女生也就有了自己能選擇的男生，這里我們就匹配成功了：
v1 n2
v2 n3
v3 n1
這里我們就完成了匹配的過程，這個時候我們因為所有人都有了約會對象，我們這個時候稱之為最大匹配，同時也是完美匹配。
最大匹配：一個圖所有匹配中，所含匹配邊數最多的匹配，稱為這個圖的最大匹配。
完美匹配：如果一個圖的某個匹配中，所有的頂點都是匹配點，那麼它就是一個完美匹配。剛剛給出的例子就是完美匹配。
那麼我們要如何實現演算法呢？因為代碼是不能直接看出來如何匹配能得到最大匹配的，所以我們這里就要有一個順序去尋找最大匹配，這里我們以編號大小的順序來尋找約會對象。
從v1開始找，先找到了n1.約上，然後是v2,找到了n2,約上。v3找到了n1,但是這里n1和v1已經約好了，怎麼辦呢？v1對v3說：我還認識n2,我去問問他有沒有約會人選，要是沒有的話，n1讓給你。（其實我想說她是傻逼。。。。）然後v1去找n2,但是n2和v2約上了，這個時候呢v2對v1說：我還認識n3,我去看看他有沒有約會的人選，要是沒有的話n2，讓給你（這兩個傻逼。。。。）然後v2找到了n3,n3樂的屁顛屁顛的，說正好沒人約我，然後他倆約上了，v2找到了n3,那麼v1就能和v2約上了，然後v3也就能和n1約上了，我們這個時候就從剛剛的兩組匹配，轉到了3組匹配。
剛剛所述的過程，其實就是在找增廣路。（這里增廣路的含義自己就可以理解了吧~）那麼我們如何用代碼實現這個過程呢？其實並不難，我們這里需要三個數組，一個是圖，一個是詢問vis標記，一個是match匹配。
出自：http://blog.csdn.net/lw277232240/article/details/72615522
原文有圖
⑨ 廣度優先搜索C語言演算法
它沒有固定的寫法， 但是大框都差不多， 一定要使用隊列， 因為隊列的存在可以維護程序按照廣度優先的方式進行搜索。即層次遍歷
可以給你一份我作過的一個題的代碼，大體上就是這個樣子
/****************************************************\
*
* Title : Rescue
* From : HDU 1242
* AC Time : 2012.01.12
* Type : 廣度優先搜索求最短步數
* Method :從目標結點向回搜索，初始結點有多個
*
\****************************************************/
#include <stdio.h>
#include <string.h>
#define DATASIZE 201
#define QUEUESIZE 65536
typedef struct
{
int x,y;
}CPOINT;
int bfs(char map[][DATASIZE], int n, int m, CPOINT cpa);
int direction[][2] = {{1,0},{-1,0},{0,1},{0,-1}};
int main(void)
{
int m,n,i,j,res;
CPOINT cpa;
char map[DATASIZE][DATASIZE];
freopen("c:\\in.data","r",stdin);
while(scanf("%d%d%*c",&n,&m) != EOF) {
for(i = 0 ; i < n ; i++) {
gets(map[i]);
for(j = 0 ; j < m ; j++) {
if(map[i][j] == 'a') {
cpa.x = i;
cpa.y = j;
}
}
}
res = bfs(map, n, m, cpa);
if(res) {
printf("%d\n",res);
} else {
printf("Poor ANGEL has to stay in the prison all his life.\n");
}
}
return 0;
}
int bfs(char map[][DATASIZE], int n, int m, CPOINT cpa)
{
CPOINT q[QUEUESIZE],u,np;
int vis[DATASIZE][DATASIZE],step[DATASIZE][DATASIZE],i,front,rear,res;
memset(q, 0, sizeof(q));
memset(vis, 0, sizeof(vis));
memset(step, 0, sizeof(step));
front = rear = res = 0;
q[rear++] = cpa;
vis[cpa.x][cpa.y] = 1;
step[cpa.x][cpa.y] = 0;
while(front <= rear) {
u = q[front++];
if(map[u.x][u.y] == 'r') {
res = step[u.x][u.y];
break;
}
for(i = 0 ; i < 4; i++) {
np.x = u.x + direction[i][0];
np.y = u.y + direction[i][1];
if(np.x >= 0 && np.x < n && np.y >= 0 && np.y < m && !vis[np.x][np.y] && map[np.x][np.y] != '#' ) {
vis[np.x][np.y] = 1;
q[rear++] = np;
step[np.x][np.y] = step[u.x][u.y] + 1;
if(map[np.x][np.y] == 'x') {
++step[np.x][np.y];
}
}
}
}
return res;
}
⑩ 用圖論做一個求迷宮最短路徑的演算法
01.#include <stdio.h>
02.#define MAXN 10
03.int dx[] = {-1, 1, 0, 0}, dy[] = {0, 0, -1, 1};
04.char name[] = {'U', 'D', 'L', 'R'};
05.int q[MAXN * MAXN]; //隊列，保存當前結點編號
06.int vis[MAXN][MAXN], nMap[MAXN][MAXN];
07.int m, n; //行、列數
08.int dir[MAXN * MAXN];
09.int fa[MAXN][MAXN], dis[MAXN][MAXN], last_dir[MAXN][MAXN];
10.void funcInit();
11.void bfs(int x, int y);
12.void funcInput();
13.void print_path(int x, int y);
14.int main()
15.{
16. funcInput();
17. funcInit();
18. bfs(0, 0);
19. print_path(m - 1, n - 1);
20. return 0;
21.}
22.void funcInit()
23.{
24. int i, j;
25. for (i = 0; i != m; ++i)
26. {
27. for (j = 0; j != n; ++j)
28. {
29. vis[i][j] = 0;
30. dis[i][j] = 0;
31. }
32. }
33.}
34.void funcInput()
35.{
36. int i, j;
37. scanf("%d %d", &m, &n);
38. for (i = 0; i != m; ++i)
39. {
40. for (j = 0; j != n; ++j)
41. {
42. scanf("%d", &nMap[i][j]);
43. }
44. }
45.}
46.void bfs(int x, int y)
47.{
48. int front = 0, rear = 0;
49. int d, u; //方向標記、結點編號
50.
51. u = x * m + y;
52. vis[x][y] = 1;
53. fa[x][y] = u;
54. q[rear++] = u; //將當前結點編好放入隊列
55.
56. while (front != rear)
57. {
58. u = q[front++];
59. x = u / m; y = u % m;
60. for (d = 0; d != 4; ++d)
61. {
62. int nx = x + dx[d], ny = y + dy[d];
63. if (nx >= 0 && nx < m && ny >= 0 && ny < n && !vis[nx][ny] && !nMap[nx][ny])
64. {
65. int v = nx * m + ny;
66. q[rear++] = v;
67. vis[nx][ny] = 1;
68. fa[nx][ny] = u;
69. dis[nx][ny] = dis[x][y] + 1; //記錄路徑長度
70. last_dir[nx][ny] = d; //記錄移動方向標記
71. }
72. }
73. }
74.}
75.void print_path(int x, int y)
76.{
77. int c = 0;
78.
79. while (1)
80. {
81. int fx = fa[x][y] / m;
82. int fy = fa[x][y] % m;
83. if (fx == x && fy == y) break;
84. dir[c++] = last_dir[x][y];
85. x = fx; y = fy;
86. }
87. while (c--)
88. {
89. putchar(name[dir[c]]);
90. putchar('/n');
91. }
92. printf("最短路徑長度為:%d/n", dis[m-1][n-1]);
93.}