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
",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
",bfs());
66     }
67     return 0;
68 }

马上21点。要下课了，晚点我用求最短路径的算法来写写看，不求ac，只求学习，用不同的方法来实现它。

求最短路径常用算法：

戴克斯特拉算法（Dijkstra algorithm）：该算法解决的是有向图中单个源点到其他顶点的最短路径问题。

弗洛伊德算法（Floyd algorithm）：该算法解决的是有向带权图中两顶点之间最短路径的问题。

A*搜索算法：A*搜索算法，俗称A星算法。这是一种在图平面上，有多个节点的路径，求出最低通过成本的算法。常用于游戏中的NPC的移动计算，或线上游戏的BOT的移动计算上。该算法像Dijkstra算法一样，可以找到一条最短路径；也像BFS一样，进行启发式的搜索。

SPFA算法：中国人发明的算法，该算法是求单源最短路径的一种算法，在Bellman-ford算法的基础上加上一个队列优化，减少了冗余的松弛操作。