逃离迷宫

Problem Description

　　给定一个m × n (m行, n列)的迷宫，迷宫中有两个位置，gloria想从迷宫的一个位置走到另外一个位置，当然迷宫中有些地方是空地，gloria可以穿越，有些地方是障碍，她必须绕行，从迷宫的一个位置，只能走到与它相邻的4个位置中,当然在行走过程中，gloria不能走到迷宫外面去。令人头痛的是，gloria是个没什么方向感的人，因此，她在行走过程中，不能转太多弯了，否则她会晕倒的。我们假定给定的两个位置都是空地，初始时，gloria所面向的方向未定，她可以选择4个方向的任何一个出发，而不算成一次转弯。gloria能从一个位置走到另外一个位置吗？

 

Input

　　第1行为一个整数t (1 ≤ t ≤ 100),表示测试数据的个数，接下来为t组测试数据，每组测试数据中， 　　第1行为两个整数m, n (1 ≤ m, n ≤ 100),分别表示迷宫的行数和列数，接下来m行，每行包括n个字符，其中字符'.'表示该位置为空地，字符'*'表示该位置为障碍，输入数据中只有这两种字符，每组测试数据的最后一行为5个整数k, x[sub]1[/sub], y[sub]1[/sub], x[sub]2[/sub], y[sub]2[/sub] (1 ≤ k ≤ 10, 1 ≤ x[sub]1[/sub], x[sub]2[/sub] ≤ n, 1 ≤ y[sub]1[/sub], y[sub]2[/sub] ≤ m),其中k表示gloria最多能转的弯数，(x[sub]1[/sub], y[sub]1[/sub]), (x[sub]2[/sub], y[sub]2[/sub])表示两个位置，其中x[sub]1[/sub]，x[sub]2[/sub]对应列，y[sub]1[/sub], y[sub]2[/sub]对应行。

 

Output

　　每组测试数据对应为一行，若gloria能从一个位置走到另外一个位置，输出“yes”，否则输出“no”。

 

Sample Input

  
  

   
   2
5 5
...**
*.**.
.....
.....
*....
1 1 1 1 3
5 5
...**
*.**.
.....
.....
*....
2 1 1 1 3

  
  

 

Sample Output

  
  

   
   no
yes
  
  
  
  

   
   这道题目可以使用DFS来做 用一个标记数组来记录从开始到这一步到底转了多少个弯 这个初始化为0xf1111111 然后初始位置为0 DFS形参
  
  
  
  

   
   中的K为原本走的方向 初始化为-1 如果要走的位置比现在的位置转的弯数还要小的话就 continue 如果不同方向则要走的弯数等于现在弯
  
  
  
  

   
   数加一  如果一样则直接复制 用flag来记录是否找到 如果找到就不断return跳出来
  
  
  
  

   
   
#include <iostream>
   
   
#include <cstdio>
   
   
using namespace std;
   
   
#define inf 0x3fffffff
   
   
#define M 105
   
   
   //1、wan用于转弯数剪枝；2、step用于步数剪枝，就不用vis标记访问了
   
   
int r, c, ex, ey, k, wan[M][M];
   
   
char map[M][M];
   
   
int x_move[4] = {-1, 0, 1, 0};
   
   
int y_move[4] = {0, 1, 0, -1};
   
   
bool flag;
   
   
 
   
   
void dfs (int x, int y, int dir)    //dir为当前方向
   
   
{
   
   
   if (x == ex && y == ey)
   
   
    {
   
   
       if (wan[x][y] <= k)
   
   
           flag = true;
   
   
       return ;
   
   
    }
   
   
   if (wan[x][y] > k)   //转弯数超过k不用往下走了
   
   
       return ;
   
   
   //x !=ex && y != ey 说明必须至少再转一次弯，但是已经不能再转了
   
   
   if (wan[x][y] == k && x !=ex && y != ey)
   
   
       return ;
   
   
   for (int i = 0; i < 4; i++)
   
   
    {
   
   
       int tx = x + x_move[i];
   
   
       int ty = y + y_move[i];
   
   
       if (tx < 0 || tx >= r || ty < 0 || ty >= c)
   
   
           continue;
   
   
//转弯数相等不可剪掉，所以是wan[tx][ty]< wan[x][y]而不是wan[tx][ty] <= wan[x][y]
   
   
       if (map[tx][ty] == '*' || wan[tx][ty] < wan[x][y])   //转弯数剪枝
   
   
           continue;
   
   
       if (dir != -1 && i != dir && wan[tx][ty] < wan[x][y]+ 1)    //转弯数剪枝
   
   
           continue;
   
   
       wan[tx][ty] = wan[x][y];
   
   
       if (dir != -1 && i != dir)
   
   
           wan[tx][ty]++;  //如果方向变了转弯+1
   
   
       dfs (tx, ty, i);
   
   
       if (flag)
   
   
           return ;
   
   
    }
   
   
}
   
   
 
   
   
int main()
   
   
{
   
   
   int t, i, j, sx, sy;    //sx， sy是起点
   
   
   scanf ("%d", &t);
   
   
   while (t--)
   
   
    {
   
   
       scanf ("%d%d", &r, &c);
   
   
       for (i = 0; i < r; i++)
   
   
           scanf ("%s", map[i]);
   
   
       scanf ("%d%d%d%d%d", &k, &sy, &sx, &ey,&ex);
   
   
       sx--, sy--, ex--, ey--;     //我从0开始编号，而题目是从1开始
   
   
       for (i = 0; i < r; i++)
   
   
           for (j = 0; j < c; j++)
   
   
                wan[i][j] = inf;    //初始化转弯数和步数为无穷大
   
   
       wan[sx][sy] = 0;    //到达起点的转弯数
   
   
       flag = false;
   
   
       dfs (sx, sy, -1);   //一开始可以走任意方向，所以设方向为-1
   
   
       if (flag)
   
   
           puts ("yes");
   
   
       else puts ("no");
   
   
    }
   
   
   return 0;
   
   
}
下面分享一种在网上看到的代码就是使用了DFS与BFS的结合 十分巧妙  以BFS为主题但是在扩张的时候采取的是单边不断扩张
  
  
  
  

   
   
#include <iostream>
   
   
#include <queue>
   
   
#include <cstdio>
   
   
using namespace std;
   
   
#define inf 0x3fffffff
   
   
#define M 105
   
   
 
   
   
int r, c, sx, sy, ex, ey, wan[M][M], t, k;
   
   
char map[M][M];
   
   
int x_move[4] = {-1, 0, 1, 0};
   
   
int y_move[4] = {0, 1, 0, -1};
   
   
 
   
   
struct pos{
   
   
   int x, y;
   
   
};
   
   
 
   
   
void bfs ()
   
   
{
   
   
   int i, j;
   
   
   for (i = 0; i < r; i++)
   
   
       for (j = 0; j < c; j++)
   
   
           wan[i][j] = inf;
   
   
   pos ft, tp;
   
   
   ft.x = sx, ft.y = sy;
   
   
   wan[ft.x][ft.y] = -1;
   
   
   queue<pos> q;
   
   
   q.push (ft);
   
   
   while (!q.empty())
   
   
    {
   
   
       ft = q.front();
   
   
       q.pop();
   
   
       if (ft.x == ex && ft.y == ey && wan[ft.x][ft.y] <= k)
   
   
       {
   
   
           puts ("yes");
   
   
           return ;
   
   
       }
   
   
       for (i = 0; i < 4; i++)
   
   
       {
   
   
           tp.x = ft.x + x_move[i];
   
   
           tp.y = ft.y + y_move[i];
   
   
           while (!(tp.x < 0 || tp.y < 0 || tp.x >= r || tp.y >= c))
   
   
           {
   
   
                if (map[tp.x][tp.y] == '*')
   
   
                    break;
   
   
               if (wan[tp.x][tp.y] <wan[ft.x][ft.y] + 1)
   
   
                    break;
   
   
                wan[tp.x][tp.y] =wan[ft.x][ft.y] + 1;
   
   
                if (wan[tp.x][tp.y] > k)
   
   
                    break;
   
   
                if (wan[tp.x][tp.y] == k&& tp.x != ex && tp.y != ey)
   
   
                    break;
   
   
                q.push (tp);
   
   
                tp.x += x_move[i];
   
   
                tp.y += y_move[i];    //单方向优先扩展
   
   
           }
   
   
       }
   
   
    }
   
   
   puts ("no");
   
   
}
   
   
 
   
   
int main()
   
   
{
   
   
   int t, i;
   
   
   scanf ("%d", &t);
   
   
   while (t--)
   
   
    {
   
   
       scanf ("%d%d", &r, &c);
   
   
       for (i = 0; i < r; i++)
   
   
           scanf ("%s", map[i]);
   
   
       scanf ("%d%d%d%d%d", &k, &sy, &sx, &ey,&ex);
   
   
       sx--, sy--, ex--, ey--;
   
   
       bfs ();
   
   
    }
   
   
   return 0;
   
   
}