POJ 2243

 1 #include <iostream>
 2 #include <queue>
 3 using namespace std;
 4
 5 int dir[8][2] = {-2,-1,-2,1,2,-1,2,1,1,-2,-1,-2,1,2,-1,2};
 6
 7 struct node
 8 {
 9     int x;
10     int y;
11     int step;
12     node()
13     {
14         step = 0;
15     }
16 };
17
18 queue<node> coll;
19
20 bool mark[8][8];
21
22 node beg;
23 node end;
24
25 bool bfs(node p);
26
27 int main()
28 {
29     //freopen("acm.acm","r",stdin);
30     char s_1[2];
31     char s_2[2];
32
33     while(cin>>s_1>>s_2)
34     {
35         memset(mark,false,sizeof(mark));
36         beg.x = s_1[0] - ‘a‘;
37         beg.y = s_1[1] - ‘0‘ - 1;
38
39         end.x = s_2[0] - ‘a‘;
40         end.y = s_2[1] - ‘0‘ - 1;
41         coll.push(beg);
42         mark[beg.x][beg.y] = true;
43         cout<<"To get from "<<s_1<<" to "<<s_2<<" takes ";
44
45         while(!coll.empty() && !bfs(coll.front()))
46         {
47             coll.pop();
48         }
49         while(!coll.empty())
50         {
51             coll.pop();
52         }
53         cout<<" knight moves."<<endl;
54     }
55 }
56
57 bool bfs(node p)
58 {
59     int i;
60     int j;
61     if(p.x == end.x && p.y == end.y)
62     {
63         cout<<p.step;
64         return true;
65     }
66     int tem_i;
67     int tem_j;
68     node tem;
69
70     for(i = 0; i < 8; ++ i)
71     {
72         tem_i = p.x + dir[i][0];
73         tem_j = p.y + dir[i][1];
74         if(tem_i >= 0 && tem_i < 8 && tem_j >= 0 && tem_j < 8 && !mark[tem_i][tem_j])
75         {
76             tem.x = tem_i;
77             tem.y = tem_j;
78             tem.step = p.step + 1;
79             mark[tem_i][tem_j] = true;
80             coll.push(tem);
81         }
82     }
83     return false;
84 }
时间: 2024-10-09 09:44:48

POJ 2243的相关文章

POJ 2243 || HDU 1372:Knight Moves(BFS)

Knight Moves Time Limit: 1000MS Memory Limit: 65536K Total Submissions: 11223 Accepted: 6331 Description A friend of you is doing research on the Traveling Knight Problem (TKP) where you are to find the shortest closed tour of knight moves that visit

poj 2243 bfs 利用 结构体中的step成员保存步数 ,STL的队列

//BFS #include <iostream> #include <queue> using namespace std; bool used[8][8]; int move[8][2]={1,2, -1,2, -2,1, -2,-1, -1,-2, 1,-2, 2,-1, 2,1}; struct position { int i,j; int step; position(int a,int b,int c) { i=a; j=b; step=c; } }; int mai

poj 2243 Knight Moves

Knight Moves Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 11794   Accepted: 6646 Description A friend of you is doing research on the Traveling Knight Problem (TKP) where you are to find the shortest closed tour of knight moves that v

hdu 1372 AND poj 2243 bfs

骑士巡游找最短路. 1 #include <iostream> 2 #include <cstring> 3 #include <cstdio> 4 using namespace std; 5 6 const int N = 8; 7 const int M = N * N; 8 int step[N][N]; 9 int dir[N][2] = { 1, 2, 1, -2, -1, 2, -1, -2, 2, 1, 2, -1, -2, 1, -2, -1 }; 1

POJ 2243:Knight Moves(BFS)

可以理解为象棋中的马走“日”字形,从第一个位置到第二个位置所需的最短步数,简单的BFS 每走一步需判断一次是否到达目标点. 由于BFS写得不多,一直用DFS的思维理解,递归写一直溢出.超时~~ #include"cstdio" #include"iostream" #include"cstring" #include"queue" using namespace std; int dx[8]={-1,1,-2,2,-2,2,-

BFS、双向BFS和A*

BFS.双向BFS和A* Table of Contents 1. BFS 2. 双向BFS 3. A*算法 光说不练是无用的.我们从广为人知的POJ 2243这道题谈起:题目大意:给定一个起点和一个终点.按骑士的走法(走日字),从起点到终点的最少移动多少次 watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvd2RraXJjaGhvZmY=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/g

BFS学习总结

BFS学习总结 给你一个n*m的网格迷宫,迷宫中有些格子不能走,其他的格子都能走.然后给你起点与终点,问你从起点走到终点最少需要多少步? 上面的问题就是一个典型的BFS问题,对于这类问题来说,只要你掌握了这类问题的关键思想,其实他们都是可以用类似的思路来做的. 你可以把BFS问题想象成:从一个父亲(起点状态)生儿子(后继状态),儿子又生孙子(后继状态)的过程,只要这个家族中出生了一个满意的后代(终点状态),这个家族就不生了. 但是如果这个家族中有两个完全一样的人出生(他们的辈分不一定相同),那么

POJ - 2778 ~ HDU - 2243 AC自动机+矩阵快速幂

这两题属于AC自动机的第二种套路通过矩阵快速幂求方案数. 题意:给m个病毒字符串,问长度为n的DNA片段有多少种没有包含病毒串的. 根据AC自动机的tire图,我们可以获得一个可达矩阵. 关于这题的tire图详解可以点击这里,往下面翻,这个博主的图对于tire图讲的非常详细. 知道了什么是tire图,理解了tire图后,后面的AC自动机的题目才能写. AC自动机的灵魂应该就是tire图 然后问题就变成了,得到了一个可达矩阵后,如何求方案数呢? 这个n = 2000000000 这咋办呢? 给定一

POJ Knight Moves 2243 x

Knight Moves Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 13974   Accepted: 7797 Description A friend of you is doing research on the Traveling Knight Problem (TKP) where you are to find the shortest closed tour of knight moves that v