蓝桥杯——迷宫

题目

X星球的一处迷宫游乐场建在某个小山坡上。它是由10x10相互连通的小房间组成的。
房间的地板上写着一个很大的字母。我们假设玩家是面朝上坡的方向站立，则：
L表示走到左边的房间，R表示走到右边的房间，U表示走到上坡方向的房间，D表示走到下坡方向的房间。
X星球的居民有点懒，不愿意费力思考。他们更喜欢玩运气类的游戏。这个游戏也是如此！
开始的时候，直升机把100名玩家放入一个个小房间内。玩家一定要按照地上的字母移动。
迷宫地图如下：

---

UDDLUULRUL
UURLLLRRRU
RRUURLDLRD
RUDDDDUUUU
URUDLLRRUU
DURLRLDLRL
ULLURLLRDU
RDLULLRDDD
UUDDUDUDLL
ULRDLUURRR

---

请你计算一下，最后，有多少玩家会走出迷宫? 而不是在里边兜圈子。

思路

递归，无论从哪里出去，最终一定会到达那些边界的点。只要我们从边界可以走出迷宫的点开始往内递归，就可以找出所有的点。【一个点无论如何，肯定是从上下左右四个边界走出去的，只要我们将这四个边界的点都递归完毕，一定能够找出所有的点】

代码

import java.util.Scanner;

class Point{
    int x;
    int y;
    public Point(int x,int y)
    {
        this.x=x;
        this.y=y;
    }
}
public  class  Main{
    static char map[][]=new char[100][100];
    static int visited[][]=new int[100][100];

    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);
        int n=reader.nextInt();//接收大小
        String balnk=reader.nextLine();

        //接收整个地图
        for (int i=0;i<n;++i)
        {
            String test=reader.next();
            for (int j=0;j<n;++j)
                map[i][j]=test.charAt(j);
        }

        //左右列可达出口
        for (int i=0;i<n;++i)
        {
            if (map[i][0]=='L')
                visited[i][0]=1;
            if (map[i][n-1]=='R')
                visited[i][n-1]=1;
        }

        //上下行可达出口
        for (int j=0;j<n;++j)
        {
            if (map[0][j]=='U')
                visited[0][j]=1;
            if (map[n-1][j]=='D')
                visited[n-1][j]=1;
        }

        for (int i=0;i<n;++i)
            for (int j=0;j<n;++j)
            {
                if (visited[i][j]==1)
                    bfs(i,j);
            }

        int count=0;//可达点计数器
        for (int i=0;i<n;++i)
        {
            for (int j=0;j<n;++j)
            {
                if (visited[i][j]==1)
                    ++count;
            }
        }
        System.out.println(count);
    }

    public static void bfs(int a, int b)
    {
        //表记为可达
        visited[a][b]=1;
        int c=0;
        int d=0;
        for (int i=0;i<=3;++i)
        {
            c=a+d_x[i];
            d=b+d_y[i];
            //递归右边的点，一定要是往左走的才可以到达出口
            if (i==0 && check(c,d) && map[c][d]=='L')
            {
                bfs(c,d);
            }
            else if (i==1 && check(c,d) && map[c][d]=='U')
            {
               bfs(c,d);
            }
            else if (i==2 && check(c,d) && map[c][d]=='R')
            {
                bfs(c,d);
            }
            else if (i==3 && check(c,d) && map[c][d]=='D')
            {
                bfs(c,d);
            }
        }
    }
    //检查是否越界
    public  static boolean check(int x,int y)
    {
        return x>=0 && x<10 && y>=0 && y<10 && visited[x][y]==0;
    }
}

总结

最终结果是31个点，一开始想得太复杂了，结果就错了，把递归和广搜结合起来即可。