java编程题-走迷宫

Question

Description:  
Word Maze 是一个网络小游戏，你需要找到以字母标注的食物，但要求以给定单词字母的顺序吃掉。如上图（暂时无图），假设给定单词if，你必须先吃掉i然后才能吃掉f。
但现在你的任务可没有这么简单，你现在处于一个迷宫Maze（n×m的矩阵）当中，里面到处都是以字母标注的食物，但你只能吃掉能连成给定单词W的食物。
如下图，指定W为“SOLO”，则在地图中红色标注了单词“SOLO”。 
 
注意区分英文字母大小写,你只能上下左右行走。 
Input: 
输入第一行包含两个整数n、m(0<n,m<21)分别表示n行m列的矩阵，第二行是长度不超过100的单词W，从第3行到底n+3行是只包含大小写英文字母的长度为m的字符串。
Output: 
如果能在地图中连成给定的单词，则输出“YES”，否则输出“NO”。注意：每个字母只能用一次。
Sample Input: 
5 5
SOLO
CPUCY
EKLQH
CRSOL
EKLQO
PGRBC 
Sample Output: 
YES

Answer 1

这题实际上就是遍历+递归迷宫就是char[n][m]你要找的String也给它拆成char[]，它的长度就是你要递归的最高次数先找第一个字母。（找到一个符合的时，定义个数组接收此时的查询位置）再找它的上下左右（注意别越界），看看是否跟第二个字母相同（有相同的继续往里加）。。再找第三个字母的上下左右（注意排除已经记录入的数据）再找第四个。

Answer 2

//重装系统还没装java,C#的凑合一下        static void Main(string[] args) {
            char[] keys = "SOLO".ToCharArray();
            char[] tr0 = "CPUCY".ToCharArray();
            char[] tr1 = "EKLQH".ToCharArray();
            char[] tr2 = "CRSOL".ToCharArray();
            char[] tr3 = "EKLQO".ToCharArray();
            char[] tr4 = "PGRBC".ToCharArray();
            sf(new char[][] { tr0, tr1, tr2, tr3, tr4 }, keys);
            System.Console.In.Read();
        }        static void sf(char[][] map, char[] key) {
            for (int y = 0; y < map.Length; y++) {
                for (int x = 0; x < map[y].Length; x++) {
                    if (map[y][x] == key[0]) {
                        //如果找到第一个相同,则进行查找
                        if (dg(map, key, x, y)) {
                            System.Console.WriteLine("Yes");
                            return;
                        }
                    }
                }
            }
            System.Console.WriteLine("No");
        }        //递归初始化
        static bool dg(char[][] map, char[] key, int sx, int sy) {
            List<point> points = new List<point>();
            return dg(map, key, sx, sy, 0, points);
        }        //递归查找
        static bool dg(char[][] map, char[] key, int px, int py, int np, List<point> points) {
            if (np + 1 == key.Length) return true;
            points.Add(new point(px, py));            //不越界,数相符,不是已存在的点
            //上
            if (py - 1 >= 0 && map[py - 1][px] == key[np + 1] && !exists(points, px, py - 1)) {
                return dg(map, key, px, py - 1, np + 1, new List<point>(points));
            }
            //下
            if (py + 1 < map.Length && map[py + 1][px] == key[np + 1] && !exists(points, px, py + 1)) {
                return dg(map, key, px, py + 1, np + 1, new List<point>(points));
            }
            //左
            if (px - 1 >= 0 && map[py][px - 1] == key[np + 1] && !exists(points, px - 1, py)) {
                return dg(map, key, px - 1, py, np + 1, new List<point>(points));
            }
            //右
            if (px + 1 < map[0].Length && map[py][px + 1] == key[np + 1] && !exists(points, px + 1, py)) {
                return dg(map, key, px + 1, py, np + 1, points);
            }
            //没有找到符合的则返回false
            return false;
        }        //查找数组中是否存在x,y这个位置
        static bool exists(List<point> list, int x, int y) {
            foreach (point p in list) {
                if (p.Equals(x, y)) {
                    return true;
                }
            }
            return false;
        }
    }
    class point {
        public int x;
        public int y;
        public point(int x, int y) {
            this.x = x;
            this.y = y;
        }
        public bool Equals(int x, int y) {
            return this.x == x && this.y == y;
        }
    }