帅气的HYC迷路了

描述

 有一天, 我们帅气的HYC找到了一张藏宝图, 这张图很神奇, 只要你看它一眼, 立马就会被传送到一个迷宫里, 这个迷宫仅有一个出口.那么现在问题来啦, 问你找到这个出口需要走多少步?

    现在给出HYC在迷宫房中走的规则, HYC每走出一步, 都会优先向左走, 如果左边是墙, 那么他会向前走, 如果前边也是墙, 那么他就会向右走, 如果右边也是墙, 那么他只能选择后退了~~~~>_<~~~~

    另外, HYC也想知道如果不这样走, 他最少能走多少步能走出出口呢?

输入

首先给出一个T (1 <= T < 100) 代表T组测试数据 每组测试数据第一行为两个整数r 和 c (3 <= r,c <= 40) r代表这个迷宫有多少列,c代表这个迷宫有多少行. S表示入口, E表示出口, #表示墙不能走, .表示空白区域, 可以走. 题目保证给出的迷宫四周都是墙, 而且按照规则走总能找到出口, 且初始方向为向北走,快来帮帮他吧!

输出

每组数据输出两个数, 第一个数表示按照规则走的步数, 第二个数表示走到出口最短需要多少步.

样例输入1  复制

1
9 5
#########
#.#.#.#.#
S.......E
#.#.#.#.#
#########

样例输出1

17 9

好受伤又好激动，一个月了，终于自己独立的写好了一个搜索【泪奔】

1.  
2. #include <stdio.h>
3. #include <stdlib.h>
4. #include <string.h>
5. //左前右后
6. int n, m, p, q;
7. char a[45][45];
8. int book[45][45];
9. int judge(int x,int y) {
10.     return (x >= 0 && x < n && y >= 0 && y < m && a[x][y] != '#');
11. }
12. int dfs(int x, int y, int dir, int step) {
13.     //dir 0:左 1上 2右 3后
14.     //              x-1,y
15.     //   x,y-1      x,y      x,y+1
16.     //              x+1,y
17.  
18.  
19.     int tx, ty;
20.     int next[4][2] = {{0,-1},{-1,0},{0,1},{1,0}};
21.     for(int k = 0; k < 4; k++) {
22.         if(x == p && y == q) return (step + 1);
23.         int ndir = (dir + k + 3) % 4;
24.         tx = x + next[ndir][0];
25.         ty = y + next[ndir][1];
26.         if(!judge(tx,ty)) continue;
27.         return dfs(tx,ty,ndir,step+1);
28.     }
29. }
30. struct node {
31.     int x;
32.     int y;
33.     int dir;
34.     int step;
35. }que[2500];
36. int main()
37. {
38.     int T;
39.     scanf("%d",&T);
40.     while(T--) {
41.         memset(a,0,sizeof(a));
42.         int startx, starty;
43.         scanf("%d%d",&m,&n);
44.         for(int i = 0; i < n; i++) {
45.             getchar();
46.             for(int j = 0; j < m; j++) {
47.                 a[i][j] = getchar();
48.                 if(a[i][j] == 'S') {
49.                     startx = i;
50.                     starty = j;
51.                 }
52.                 if(a[i][j] == 'E') {
53.                     p = i;
54.                     q = j;
55.                 }
56.             }
57.         }
58.         int step = dfs(startx,starty,1,0);
59.         printf("%d ",step);
60.         /****************hualidefengexian*****************/
61.         memset(que,0,sizeof(que));
62.         memset(book,0,sizeof(book));
63.         int head, tail;
64.         head = tail = 1;
65.         book[startx][starty] = 1;
66.         que[tail].x = startx;
67.         que[tail].y = starty;
68.         que[tail].dir = 0;
69.         que[tail].step = 0;
70.         tail++;
71.         int flag = 0;
72.         int next[4][2] = {{0,-1},{-1,0},{0,1},{1,0}};
73.         while(head < tail) {
74.             for(int k = 0; k < 4; k++) {
75.                 int ndir = (que[head].dir + k + 3) % 4;
76.                 int tx = que[head].x + next[ndir][0];
77.                 int ty = que[head].y + next[ndir][1];
78.                 if(judge(tx,ty) && book[tx][ty] == 0) {
79.                     book[tx][ty] = 1;
80.                     que[tail].x = tx;
81.                     que[tail].y = ty;
82.                     que[tail].dir = ndir;
83.                     que[tail].step = que[head].step + 1;
84.                     tail++;
85.                 }
86.                 if(tx == p && ty == q) {
87.                     flag = 1;
88.                     break;
89.                 }
90.             }
91.             if(flag == 1) break;
92.             head++;
93.         }
94.         printf("%d\n",que[tail-1].step + 1);
95.     }
96.     return 0;
97. }