HDU 1728 逃离迷宫

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 1, y 1, x 2, y 2 (1 ≤ 


k ≤ 10, 1 ≤ x 1, x 2 ≤ n, 1 ≤ y 1, y 2 ≤ m),其中k表示gloria最多能转的弯数


，(x 1, y 1), (x 2, y 2)表示两个位置，其中x 1，x 2对应列，y 1, y 2对应行。 
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做的，能对，但超时
//用广搜
//但不是一般的广搜，而是结合了深搜思想
//如果，还是用普通广搜，结果仍有可能超时
//既然是求最小转弯数，那么此题的重点不同于以前求最短路径，而是去求最小转弯数，路程再远也没关系
//求出搜索到终点前每点的最小转弯数
//于是，一个点广搜不是上下左右四个点，而是上下左右四个方向能搜索的所有点
//沿一个方向搜索时，会遇到碰到已经搜到的点的情况，不用管，接着走，直到不能走
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct node{
    int x;
    int y;
    int turn;//到此点最小的转弯次数
};
struct node start,end;//起点与终点
struct node queue[10001];
int head=0;
int tail=0;
int next[4][2]={{-1,0},{1,0},{0,-1},{0,1}};
int m,n;
int k;
char map[101][101];
int book[101][101];

int bfs()
{
    start.turn=-1;//起点的turn赋值为-1
    book[start.x][start.y]=1;
    queue[tail].x=start.x;
    queue[tail].y=start.y;
    queue[tail].turn=start.turn;
    tail++;
    while(head<tail){
        if(queue[head].x==end.x&&queue[head].y==end.y&&queue[head].turn<=k)
           return 1;
        int xnext;
        int ynext;
        for(int i=0;i<4;i++){
            xnext=queue[head].x+next[i][0];
            ynext=queue[head].y+next[i][1];
            while(xnext>=1&&xnext<=m&&ynext>=1&&ynext<=n&&map[xnext][ynext]=='.'){
                if(book[xnext][ynext]==0){
                    book[xnext][ynext]=1;
                    queue[tail].x=xnext;
                    queue[tail].y=ynext;
                    queue[tail].turn=queue[head].turn+1;
                    tail++;
                }
                xnext=xnext+next[i][0];
                ynext=ynext+next[i][1];

            }
        }
        head++;
    }
   return 0;
}
int main()
{
    int number;
    scanf("%d",&number);
    for(int i=1;i<=number;i++){
        scanf("%d%d",&m,&n);
        for(int j=1;j<=m;j++)
            scanf("%s",map[j]+1);
        scanf("%d%d%d%d%d",&k,&start.y,&start.x,&end.y,&end.x);
        for(int t=0;t<101;t++)
            memset(book[t],0,sizeof(book[t]));
        head=0;
        tail=0;
        int flag=bfs();
        if(flag)
          printf("yes\n");
        else
          printf("no\n");
    }
    return 0;
}

//dfs没过的

#include <stdio.h>
#include <stdlib.h>
struct node{
    int x;
    int y;
};
struct node start,end;
int m,n;
int k;
char map[101][101];
int book[101][101];
int flag;
int next[4][2]={{-1,0},{0,-1},{1,0},{0,1}};//去:上左下右
int to[4]={1,2,3,4};//代表四个方向,上左下右
void dfs(int x,int y,int towards,int occur)
{
    if(x==end.x&&y==end.y){
        if(occur<=k)
            flag=1;
        return;
    }
    int xnext,ynext;
    for(int i=0;i<4;i++){
       xnext=x+next[i][0];
       ynext=y+next[i][1];
       if(xnext>=1&&xnext<=m&&ynext>=1&&ynext<=n&&book[xnext][ynext]==0&&map[xnext][ynext]=='.'){
          book[xnext][ynext]=1;
          if(x==start.x&&y==start.y)
            dfs(xnext,ynext,to[i],0);
          else
            dfs(xnext,ynext,to[i],occur+((int)fabs(towards-to[i]))%2);
          book[xnext][ynext]=0;
       }
    }
    return;
}
int main()
{
    int number;
    scanf("%d",&number);
    //getchar();
    for(int i=1;i<=number;i++){
        flag=0;
        scanf("%d%d",&m,&n);
        //getchar();
        for(int j=1;j<=m;j++)
            scanf("%s",map[j]+1);
        scanf("%d%d%d%d%d",&k,&start.y,&start.x,&end.y,&end.x);
        //for(int t=0;t<101;t++)
            //memset(book[t],0,sizeof(book[t]));
        book[start.x][start.y]=1;
        dfs(start.x,start.y,0,0);
        if(flag)
          printf("yes\n");
        else
          printf("no\n");
    }
    return 0;
}