牛客网——走出迷宫

题目

题目传送门
链接：https://ac.nowcoder.com/acm/problem/14572
来源：牛客网

小明现在在玩一个游戏，游戏来到了教学关卡，迷宫是一个N*M的矩阵。
小明的起点在地图中用“S”来表示，终点用“E”来表示，障碍物用“#”来表示，空地用“.”来表示。
障碍物不能通过。小明如果现在在点（x，y）处，那么下一步只能走到相邻的四个格子中的某一个：（x+1，y），（x-1，y），（x，y+1），（x，y-1）；
小明想要知道，现在他能否从起点走到终点。

深搜思路

深搜或者广搜都可，最近正在学，把两种都写一下。先写深搜的，我们可以先开一个标记数组，标记是否访问过了，然后开一个地图为map数组，来存放对应的地图。在第一层里面，搜索位置为’S’的起点，然后进行深搜。按照右下左上四个方向，不断深搜，直到找到终点’E’或者退出。

这道题的地图最大有500个，深搜的话，只能过三个例子。。。

代码

import java.util.Scanner;

public class Main{

    static int N;//行数
    static int M;//列数
    static char map[][]=new char[510][510];//存储地图
    static int visited[][]=new int[510][510];//标记数组
    static int flag; //路径标记

    //方向数组,右下左上
    static int d_x[]={0,1,0,-1};
    static int d_y[]={1,0,-1,0};


    public static void main(String[] args) {
        Scanner reader=new Scanner(System.in);
        while (reader.hasNextInt()) //多组数据
        {
            N=reader.nextInt();//接收行数
            M=reader.nextInt();//接收列数
            String a=reader.nextLine();//接收上面的回车
            flag=0;//初始化寻找标记

            //接收地图
            for (int i=0;i<N;++i)
            {
                String test=reader.nextLine();//接收地图字符串
                for (int j=0;j<M;++j)
                {
                    map[i][j]=test.charAt(j);
                    visited[i][j]=0; //初始化整个标记数组
                }
            }

            //找到地点，开始深搜
            for (int i=0;i<N;++i)
                for (int j=0;j<M;++j)
                    if (map[i][j]=='S')
                    {
                        dfs(i,j);
                        break;
                    }
            if (flag>0)
                System.out.println("Yes");
            else
                System.out.println("No");
        }
    }

    //深搜
    public  static void dfs(int x,int y)
    {
        if (map[x][y]=='E')
        {
            ++flag;
            return; //深搜剪枝
        }
        if (flag>0) //深搜剪枝
            return;
        int tx=0;
        int ty=0;
        for (int i=0;i<=3;++i)
        {
            tx=x+d_x[i];
            ty=y+d_y[i];
            if (check(tx,ty))
            {
                visited[tx][ty]=1;
                dfs(tx,ty);
                visited[tx][ty]=0;
            }
        }
    }
    //不越界，没有走过且可以走
    public static boolean check(int a,int b)
    {
        return a>=0 && a<N && b>=0 && b<M && visited[a][b]==0 && (map[a][b]=='.' || map[a][b]=='E');
    }
}

结果

代码我检查了两遍，应该是没问题的，应该就是因为题目的地图太大，用深搜爆栈了或者时间运行太大了，深搜即回溯法，要遍历每一个结果，通不过也是在意料之中。不过这次也算加深了一下深搜模板！

广搜思路

深搜走不了，用广搜来。还是搜右下左上，能的点进队，每次取队头的点判断一下是否到了终点，直到找到重点或者队列为空而退出循环！

代码

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

class  Point
{
    int x;
    int y;
}
public class Main{

    static int N;//行数
    static int M;//列数
    static char map[][]=new char[510][510];//存储地图
    static int visited[][]=new int[510][510];//标记数组
    static int flag; //路径标记

    //方向数组,右下左上
    static int d_x[]={0,1,0,-1};
    static int d_y[]={1,0,-1,0};
    static Queue<Point> queue=new LinkedList<>();

    public static void main(String[] args) {
        Scanner reader=new Scanner(System.in);
        while (reader.hasNextInt()) //多组数据
        {
            N=reader.nextInt();//接收行数
            M=reader.nextInt();//接收列数
            String blank=reader.nextLine();//接收上面的回车
            flag=0;//初始化寻找标记
            queue.clear();//清空队列

            //接收地图
            for (int i=0;i<N;++i)
            {
                String test=reader.nextLine();//接收地图字符串
                for (int j=0;j<M;++j)
                {
                    map[i][j]=test.charAt(j);
                    visited[i][j]=0; //初始化整个标记数组
                }
            }

            //找到地点，开始广搜
            for (int i=0;i<N;++i)
                for (int j=0;j<M;++j)
                    if (map[i][j]=='S')
                    {
                        Point temp=new Point();
                        temp.x=i;
                        temp.y=j;
                        queue.offer(temp);
                        visited[i][j]=1;
                    }

            //搜索到对垒为空
            while (!queue.isEmpty())
            {
                int a=queue.peek().x;
                int b=queue.peek().y;
                if (map[a][b]=='E')
                {
                    ++flag;
                    break;
                }
                int tx=0;
                int ty=0;
                for (int i=0;i<=3;++i)
                {
                    tx=a+d_x[i];
                    ty=b+d_y[i];
                    if (check(tx,ty))
                    {
                        Point tempory=new Point();
                        tempory.x=tx;
                        tempory.y=ty;
                        queue.offer(tempory);
                        visited[tx][ty]=1;
                    }
                }
                queue.poll();//弹出队首
            }

            if (flag>0)
                System.out.println("Yes");
            else
                System.out.println("No");
        }
    }

    public static boolean check(int x,int y)
    {
        return x>=0 && x<N && y>=0 && y<M && visited[x][y]==0 && (map[x][y]=='.' || map[x][y]=='E');
    }
}

结果

嗯，用广搜就ac了。还是广搜好！复杂度低，而且直接搜出来就是最优值！
广搜最秀了！今晚才真正理解了为什么广搜一旦搜到就是最优值。

算法之路无穷尽也，加油！