迷宫求解 明

2013-01-22

摘要：用“穷举”的方法，从入口出发，顺某一方向向前探索。若能走通，继续；不能，原路返回，换方向继续。这样；遍历所有的道路，直到发现出口。因为要原路返回，也需要栈。

using System;
using System.Collections.Generic;

namespace MazePath
{
    //方向
    public enum Direct{NA=-1,East=0,South=1,West=2,North=3,Out=886};

    struct Point
    {
        public int x;
        public int y;
    }
    struct Element
    {
        public Point p;
        public Direct d; 
    }

    class Program
    {
        static void Main(string[] args)
        {
            Point start = GetStartMark();
            Point end = GetEndMark();
            int[,] maze = InitMaze();
            int[,] diradd = InitDirAdd();
            MazePath(start, end, maze, diradd);
            Console.Read();
        }

        /// <summary>
        /// step 1 依次尝试东南西北四个方向，
        /// step 1.1 如果下一步可通，标记下一位置已访问，把当前位置和方向入栈
        /// step 1.1.1 若下一位置为出口，显示所有路径，返回
        /// step 1.1.2 若不是，则可通往的位置为当前位置
        /// step 1.2 如果不通，换个方向
        /// step 2 如果不通或已走过，退栈取得上一次位置和方向，换其他方向
        /// </summary>
        /// <param name="start"></param>
        /// <param name="end"></param>
        /// <param name="maze"></param>
        /// <param name="diradd"></param>
        static void MazePath(Point start, Point end, int[,] maze, int[,] diradd)
        {
            Point p;
            Element elem;
            Stack<Element> S1 = new Stack<Element>();
            Stack<Element> S2 = new Stack<Element>();
            maze[start.x, start.y] = 2; //入口点作上标记 
            p = start;
            elem.p = p;
            elem.d = Direct.East;
            do
            {
                //step 1. 依次尝试东南西北四个方向
                while (elem.d < Direct.North)
                {
                    p = GetNextPoint(elem.p, elem.d, diradd);
                    //step 1.1 若当前位置可通，标记可通往的位置，并入栈当前位置、方向
                    if (maze[p.x, p.y] == 0) 
                    {                        
                        maze[p.x, p.y] = 2;
                        S1.Push(elem);
                        //step 1.1.1 若下一位置为出口，显示所有路径，返回。
                        if (p.x == end.x && p.y == end.y)
                        {
                            elem.p = p;
                            elem.d = Direct.Out; //方向输出为-1 判断是否到了出口 
                            S1.Push(elem);
                            Console.WriteLine("\n0=东 1=南 2=西 3=北 886为则走出迷宫\n\n通路为:(行坐标,列坐标,方向)\n");
                            while (S1.Count != 0) //逆置序列 并输出迷宫路径序列 
                            {
                                S2.Push(S1.Pop());
                            }
                            while (S2.Count != 0)
                            {
                                elem = S2.Pop();
                                Console.WriteLine("坐标'{0},{1}',方向{2}->", elem.p.x, elem.p.y, elem.d);
                            }
                            return;
                        }
                        //step 1.1.2 若不是，则可通往的位置为当前位置
                        else
                        {
                            elem.p = p;
                            elem.d = Direct.East;
                        }
                    }
                    // step 1.2 如果不通，换个方向
                    else
                    {
                        elem.d = TurnClockwise(elem.d);
                    }
                }
                //step 2 如果不通或已走过，退栈取得上一次位置和方向，换其他方向
                if (S1.Count != 0)
                {
                    elem = S1.Pop();
                    elem.d = TurnClockwise(elem.d);
                }
            }
            while (S1.Count != 0);

            Console.WriteLine("没有找到可以走出此迷宫的路径\n");
        }

        static int[,] InitMaze()
        {
            //横坐标向右为正，纵坐标向下为正
            /// + ----+
            /// |     |
            /// | | | |
            /// | |   |
            /// | +---+
            /// |     
            /// +------
            
            //0为可通，1为不可通
            int[,] maze = new int[,] { { 1, 1, 1, 1, 1, 1, 1 }, { 0, 0, 0, 0, 0, 0, 1 }, { 1, 0, 1, 1, 1, 0, 1 }, { 1, 0, 0, 0, 1, 0, 1 }, { 1, 0, 1, 0, 1, 0, 1 }, { 1, 0, 0, 0, 1, 0, 0 }, { 1, 1, 1, 1, 1, 0, 1 } };
            return maze;
        }

        //得到迷宫的入口点
        static Point GetStartMark()
        {
            Point mark;
            mark.x = 1;
            mark.y = 0;
            return mark;
        }
        //得到迷宫的出口点
        static Point GetEndMark()
        {
            Point mark;
            mark.x = 6;
            mark.y = 5;
            return mark;
        }
        //按东西南北走，相对应x，y坐标的增减
        static int[,] InitDirAdd()
        {
            int[,] dirAdd = new[,] { { 1, 0 }, { 0, 1 }, { -1, 0 }, { 0, -1 } };
            return dirAdd;
        }
        //顺时针旋转
        static Direct TurnClockwise(Direct d)
        {
            return d + 1;
        }

        //下一步
        static Point GetNextPoint(Point p, Direct d, int[,] diradd)
        {
            Point q;
            q.x = p.x + diradd[(int)d, 0];
            q.y = p.y + diradd[(int)d, 1];
            return q;
        }
    }
}