NYOJ 58 最少步數

最少步數

時間限制：3000 ms  |  內存限制：65535 KB

難度：4

 

描述

這有一個迷宮，有0~8行和0~8列：

 1,1,1,1,1,1,1,1,1
 1,0,0,1,0,0,1,0,1
 1,0,0,1,1,0,0,0,1
 1,0,1,0,1,1,0,1,1
 1,0,0,0,0,1,0,0,1
 1,1,0,1,0,1,0,0,1
 1,1,0,1,0,1,0,0,1
 1,1,0,1,0,0,0,0,1
 1,1,1,1,1,1,1,1,1

0表示道路，1表示牆。

現在輸入一個道路的坐標作為起點，再如輸入一個道路的坐標作為終點，問最少走幾步才能從起點到達終點？

（注：一步是指從一坐標點走到其上下左右相鄰坐標點，如：從（3，1）到（4,1）。）

 

輸入

第一行輸入一個整數n（0<n<=100），表示有n組測試數據;
隨后n行,每行有四個整數a,b,c,d（0<=a,b,c,d<=8）分別表示起點的行、列，終點的行、列。

輸出

輸出最少走幾步。

樣例輸入

2
3 1  5 7
3 1  6 7

樣例輸出

12
11

原題來自：http://acm.nyist.net/JudgeOnline/problem.php?pid=58

 

代碼一：dfs

 1 // dfs
 2 #include <stdio.h>
 3 int ans,sx,sy,ex,ey;
 4 bool vis[9][9],map[9][9]={
 5  1,1,1,1,1,1,1,1,1,
 6  1,0,0,1,0,0,1,0,1,
 7  1,0,0,1,1,0,0,0,1,
 8  1,0,1,0,1,1,0,1,1,
 9  1,0,0,0,0,1,0,0,1,
10  1,1,0,1,0,1,0,0,1,
11  1,1,0,1,0,1,0,0,1,
12  1,1,0,1,0,0,0,0,1,
13  1,1,1,1,1,1,1,1,1
14 };
15 
16 void dfs(int i,int j,int cnt)
17 {
18     if(i<0||i>8||j<0||j>8||vis[i][j]||map[i][j]||cnt>=ans)return;
19     if(i==ex&&j==ey)
20     {
21         ans=cnt;
22         return;
23     }
24 
25     vis[i][j]=1;       // 這個已經遍歷了x`
26 
27     dfs(i,j-1,cnt+1);
28     dfs(i-1,j,cnt+1);
29     dfs(i,j+1,cnt+1);
30     dfs(i+1,j,cnt+1);
31 
32     vis[i][j]=0;
33 }
34 
35 int main()
36 {
37     int n;
38     scanf("%d",&n);
39     while(n--)
40     {
41         scanf("%d%d%d%d",&sx,&sy,&ex,&ey);
42         ans=100;
43         dfs(sx,sy,0);
44         printf("%d\n",ans);
45     }
46     return 0;
47 }

代碼二：bfs

 1 /*BFS*/
 2 #include<cstdio>
 3 #include<cstring>
 4 #include<queue>
 5 using namespace std;
 6 
 7 #define N 9
 8 
 9 typedef struct
10 {
11     int x,y,cnt;
12 }Node;
13 
14 int dir[4][2] = {{-1,0},{0,1},{1,0},{0,-1}};
15 int sx,sy,ex,ey;
16 int mp[N][N] = 
17 {
18     {1,1,1,1,1,1,1,1,1},
19     {1,0,0,1,0,0,1,0,1},
20     {1,0,0,1,1,0,0,0,1},
21     {1,0,1,0,1,1,0,1,1},
22     {1,0,0,0,0,1,0,0,1},
23     {1,1,0,1,0,1,0,0,1},
24     {1,1,0,1,0,1,0,0,1},
25     {1,1,0,1,0,0,0,0,1},
26     {1,1,1,1,1,1,1,1,1}
27 };
28 int vis[N][N];
29 int bfs()
30 {
31     queue<Node> Q;
32     Node tmp,p;
33     p.x = sx;    p.y = sy;
34     p.cnt = 0;
35     memset(vis,0,sizeof(vis));
36     vis[sx][sy] = 1;
37     Q.push(p);
38     while(!Q.empty())
39     {
40         p = Q.front();
41         Q.pop();
42         if (p.x == ex && p.y == ey)
43             return p.cnt;
44 
45         for(int di=0;di<4;di++)
46         {
47             tmp.x = p.x + dir[di][0];    tmp.y = p.y + dir[di][1];
48             tmp.cnt = p.cnt + 1;
49             if(tmp.x>=0 && tmp.x<=8 && tmp.y>=0 && tmp.y<=8 &&!vis[tmp.x][tmp.y] && !mp[tmp.x][tmp.y] )
50             {
51                 Q.push(tmp);
52                 vis[tmp.x][tmp.y] = 1;
53             }
54         }
55     }
56     return -1;
57 }
58 int main()
59 {
60     int t;
61     scanf("%d",&t);
62     while(t--)
63     {
64         scanf("%d%d%d%d",&sx,&sy,&ex,&ey);
65         printf("%d\n",bfs());
66     }
67     return 0;
68 }

求最短路徑常用算法：

戴克斯特拉算法（Dijkstra algorithm）：該算法解決的是有向圖中單個源點到其他頂點的最短路徑問題。

弗洛伊德算法（Floyd algorithm）：該算法解決的是有向帶權圖中兩頂點之間最短路徑的問題。

A*搜索算法：A*搜索算法，俗稱A星算法。這是一種在圖平面上，有多個節點的路徑，求出最低通過成本的算法。常用於游戲中的NPC的移動計算，或線上游戲的BOT的移動計算上。該算法像Dijkstra算法一樣，可以找到一條最短路徑；也像BFS一樣，進行啟發式的搜索。

SPFA算法：中國人發明的算法，該算法是求單源最短路徑的一種算法，在Bellman-ford算法的基礎上加上一個隊列優化，減少了冗余的松弛操作。