C#迷宫的实现（1）

最新推荐文章于 2024-09-10 10:25:31 发布
最新推荐文章于 2024-09-10 10:25:31 发布
阅读量1.9k 收藏 5
点赞数
分类专栏： C#Language


迷宫的基础算法在严蔚敏老师写的数据结构（C语言版）已经描述过了。主要是用栈的特性来保存在迷宫之中走过的路径，走到死胡同后再用栈弹出栈顶，再将指针指到栈顶。这种穷尽的算法有点笨（额  电脑就是这样），貌似也有一些更好的搜索路径，不过现在俺还没接触学习到0 0 ，比如A*算法。记得老师讲过，不过很快就还给老师了。哈哈~~废话少说，现在就是用面向对象的思想来完成走迷宫的这样一个程序。（第一次写，不好勿怪，纯属菜鸟交流~~）

 首先可以认为迷宫分为许多个划分为许多个小格子的有序集合（乱扯的。。。），迷宫就是这些小格子组成的。可以认为它们有坐标，x，y；给一个标记Flag来指示该格子是否已经走过（默认为false）；因为迷宫之间还应该有一些不能走的地方，称之为墙，那么在用一个IsWall来标识该格子是否是墙。哦，还应该给这个格子标记上行走的方向（这个方向我想应该做为一个枚举）。下面是代码：

 

[csharp] view plain copy print ?
  1. <p>    //迷宫中的一个小格子  
  2.     public class MazeElem  
  3.     {  
  4.         //这是方向，初始的方向应该是None~木有方向~  
  5.         public Direction dir = Direction.None;  
  6.         //构造函数  
  7.         public MazeElem(int x,int y,bool isWall)  
  8.         {  
  9.             _x=x;  
  10.             _y=y;  
  11.             _isWall=isWall;  
  12.         }</p><p>        private int _x;  
  13.         private int _y;</p><p>        //flag的默认值应该是false，假定所有的格子都没有走过  
  14.         private bool _flag=false;  
  15.         private bool _isWall;  
  16.         //X坐标，作为属性了  
  17.         public int X  
  18.         {  
  19.             get { return _x; }  
  20.             set { _x = value; }  
  21.         }  
  22.         //Y坐标，也成属性了0 0  
  23.         public int Y  
  24.         {  
  25.             get { return _y; }  
  26.             set { _y = value; }  
  27.         }  
  28.         //是否墙  
  29.         public bool IsWall  
  30.         {  
  31.             get{return _isWall;}  
  32.             set{_isWall=value;}  
  33.         }  
  34.         //是否走过  
  35.         public bool Flag  
  36.         {  
  37.             get { return _flag; }  
  38.             set { _flag = value; }  
  39.         }  
  40.     }</p>   
    //迷宫中的一个小格子
    public class MazeElem
    {
        //这是方向，初始的方向应该是None~木有方向~
        public Direction dir = Direction.None;
        //构造函数
        public MazeElem(int x,int y,bool isWall)
        {
            _x=x;
            _y=y;
            _isWall=isWall;
        }
        private int _x;
        private int _y;
        //flag的默认值应该是false，假定所有的格子都没有走过
        private bool _flag=false;
        private bool _isWall;
        //X坐标，作为属性了
        public int X
        {
            get { return _x; }
            set { _x = value; }
        }
        //Y坐标，也成属性了0 0
        public int Y
        {
            get { return _y; }
            set { _y = value; }
        }
        //是否墙
        public bool IsWall
        {
            get{return _isWall;}
            set{_isWall=value;}
        }
        //是否走过
        public bool Flag
        {
            get { return _flag; }
            set { _flag = value; }
        }
    }

 好了，格子类写好了。应该挺容易理解的把。这些都是基础，俺只是想打一下自己的基础~我们再写一个方向的枚举。一个格子的方向很容易想到：东西南北对应（右左下上），除了这些，还应该有这两个：一个是初始的方向，（一开始方向的初始值我想设置为null的，结果报错了。。。。切记。。枚举是值类型。。）还有当这个格子各个方面都无路可走的时候（人若如此只能感叹悲催...），我以为要做一个标记，那就设置NoDir。

[csharp] view plain copy print ?
  1. //方向枚举  
  2. public enum Direction  
  3. {   
  4.     /// <summary>  
  5.     /// 初始值，木有方向  
  6.     /// </summary>  
  7.     None,  
  8.     /// <summary>  
  9.     /// 北/上  
  10.     /// </summary>  
  11.     North,  
  12.     /// <summary>  
  13.     /// 南/下  
  14.     /// </summary>  
  15.     South,  
  16.     /// <summary>  
  17.     /// 西/左  
  18.     /// </summary>  
  19.     West,  
  20.     /// <summary>  
  21.     /// 东/右  
  22.     /// </summary>  
  23.     East,  
  24.     /// <summary>  
  25.     /// 无放向可走  
  26.     /// </summary>  
  27.     NoDir  
  28. }  
    //方向枚举
    public enum Direction
    { 
        /// <summary>
        /// 初始值，木有方向
        /// </summary>
        None,
        /// <summary>
        /// 北/上
        /// </summary>
        North,
        /// <summary>
        /// 南/下
        /// </summary>
        South,
        /// <summary>
        /// 西/左
        /// </summary>
        West,
        /// <summary>
        /// 东/右
        /// </summary>
        East,
        /// <summary>
        /// 无放向可走
        /// </summary>
        NoDir
    }


接下来开始写这个迷宫类。可以认为迷宫是一个n X n 个迷宫格子的集合，所以设置一个迷宫格子的的二维数组MazeElem[,]；为了指示当前行走的迷宫格子，设置一个MazeElem类型cur变量；当然还要设置一个迷宫的出口end（这里简化一下吧，默认出口就是这个迷宫右下角的那个小格子，入口就是迷宫左上角的格子。。。cur初始值为入口处。。。）。还有栈是必须的，主要是用来保存走过的路径，.NET已经提供一个Stack类，不需要我们自己写（想想用List来写栈好像也不是很难，这是看到某位大神的思路的）。嗯，还要用一对xy变量来保存这个迷宫的大小，方便后面的比较。

 

[csharp] view plain copy print ?
  1. public class Maze  
  2. {  
  3.     //很多的格子  
  4.     public MazeElem[,] maze;  
  5.     //当前格子  
  6.     MazeElem cur;  
  7.     //这是出口的那个格子  
  8.     MazeElem end;  
  9.     //用来保存路径的栈  
  10.     Stack<MazeElem> path = new Stack<MazeElem>();  
  11.     //这两个变量是用来保存迷宫的大小的  
  12.     int x, y;  
  13.     public Maze()  
  14.     {  
  15.       
  16.     }  
  17.     //构造函数，这个是最简单木有任何墙出现的空白迷宫。。  
  18.     public Maze(int x,int y)  
  19.     {  
  20.         x = x;  
  21.         y = y;  
  22.         maze=new MazeElem[x,y];  
  23.         //初始化  
  24.         for(int i=0;i<x;i++)  
  25.             for(int j=0;j<y;j++)  
  26.                 maze[i,j]=new MazeElem(i,j,false);  
  27.     }  
  28.     //用一个二维数组来初始化的构造函数- -  
  29.     public Maze(int[,] mazeArray)  
  30.     {  
  31.         //获取数组mazeArray0维中的个数  
  32.         x = (int)mazeArray.GetLongLength(0);  
  33.         //获取数组mazeArray1维中的个数  
  34.         y = (int)mazeArray.GetLongLength(1);  
  35.         //初始化maze  
  36.         maze = new MazeElem[x, y];  
  37.         for (int i = 0; i < x; i++)  
  38.             for(int j=0;j<y;j++)  
  39.                 maze[i, j] = new MazeElem(i, j, mazeArray[i,j]>0?true:false);  
  40.         //cur默认为左上角的格子，出口默认为右下角的格子  
  41.         cur=maze[0, 0];  
  42.         end = maze[x - 1, y - 1];  
  43.     }  
    public class Maze
    {
        //很多的格子
        public MazeElem[,] maze;
        //当前格子
        MazeElem cur;
        //这是出口的那个格子
        MazeElem end;
        //用来保存路径的栈
        Stack<MazeElem> path = new Stack<MazeElem>();
        //这两个变量是用来保存迷宫的大小的
        int x, y;
        public Maze()
        {
        
        }
        //构造函数，这个是最简单木有任何墙出现的空白迷宫。。
        public Maze(int x,int y)
        {
            x = x;
            y = y;
            maze=new MazeElem[x,y];
            //初始化
            for(int i=0;i<x;i++)
                for(int j=0;j<y;j++)
                    maze[i,j]=new MazeElem(i,j,false);
        }
        //用一个二维数组来初始化的构造函数- -
        public Maze(int[,] mazeArray)
        {
            //获取数组mazeArray0维中的个数
            x = (int)mazeArray.GetLongLength(0);
            //获取数组mazeArray1维中的个数
            y = (int)mazeArray.GetLongLength(1);
            //初始化maze
            maze = new MazeElem[x, y];
            for (int i = 0; i < x; i++)
                for(int j=0;j<y;j++)
                    maze[i, j] = new MazeElem(i, j, mazeArray[i,j]>0?true:false);
            //cur默认为左上角的格子，出口默认为右下角的格子
            cur=maze[0, 0];
            end = maze[x - 1, y - 1];
        }


 有一些方法还没写出来。先理清一下走迷宫的算法：

判断当前格子是否已经走过，如果没走过（flag=false）：设置为已经走过flag=true，该格子入栈，然后选定一个方向尝试走其他格子；如果走过了：检查该格子的方向，如果不是NoDir（NoDir说明四个方向都尝试过了），选定一个方向尝试走其他格子；如果是NoDir，那么将栈顶弹出，并将cur指向栈顶的格子。重复操作直道格当前格子指向迷宫的出口。选定一个方向尝试走其他格子的方法流程是这样的：先切换这个格子的方向，然后根据切换后的方向进行尝试，如果该方向的格子无法走过，那么继续选定一个方向尝试走其他格子，如果可以走过，那么将cur指向该格子。切换这个格子的方向，这个就比较简单~我们顺时针方向切换，开始的是East，向右走（dir为None，我就返回East；如果是East，那我返回South；如果是South，那返回West；如果是West，返回North；如果是North，那返回NoDir）。额，应该说得稍微清楚些把？具体看代码~一下都是Maze里面的方法，想复制的童鞋别复制错地方了0 0

[csharp] view plain copy print ?
  1. private  void CurGoNextStep(MazeElem me)  
  2. {  
  3.     switch (SwitchDirection(me))  
  4.     {   
  5.         case Direction.East:  
  6.             if (me.Y + 1 < y)  
  7.             {  
  8.                 MazeElem next = maze[me.X, me.Y+1];  
  9.                 //不能为墙，是墙你会走过去么？而且也不能是已经走过的，好马不吃回头草  
  10.                 if (!next.IsWall && !next.Flag)  
  11.                 {  
  12.                     //next.Flag = true;  
  13.                     cur = next;  
  14.                 }  
  15.                  //不行就换个方向把.  
  16.                 else  
  17.                 {  
  18.                     CurGoNextStep(me);  
  19.                 }  
  20.             }  
  21.             else  
  22.             {  
  23.                 CurGoNextStep(me);  
  24.             }  
  25.             break;  
  26.         case Direction.South:  
  27.             if (me.X + 1 <x)  
  28.             {  
  29.                 MazeElem next = maze[me.X+1, me.Y];  
  30.                 if (!next.IsWall && !next.Flag)  
  31.                 {  
  32.                     //next.Flag = true;  
  33.                     cur = next;  
  34.                 }  
  35.                 else  
  36.                 {  
  37.                     CurGoNextStep(me);  
  38.                 }  
  39.             }  
  40.             else  
  41.             {  
  42.                 CurGoNextStep(me);  
  43.             }  
  44.             break;  
  45.         case Direction.West:  
  46.             if (me.Y - 1>0)  
  47.             {  
  48.                 MazeElem next = maze[me.X, me.Y - 1];  
  49.                 if (!next.IsWall && !next.Flag)  
  50.                 {  
  51.                     //next.Flag = true;  
  52.                     cur = next;  
  53.                 }  
  54.                 else  
  55.                 {  
  56.                     CurGoNextStep(me);  
  57.                 }  
  58.             }  
  59.             else  
  60.             {  
  61.                 CurGoNextStep(me);  
  62.             }  
  63.             break;  
  64.         case Direction.North:  
  65.             if (me.X - 1 >0)  
  66.             {  
  67.                 MazeElem next = maze[me.X - 1, me.Y];  
  68.                 if (!next.IsWall && !next.Flag)  
  69.                 {  
  70.                     //next.Flag = true;  
  71.                     cur = next;  
  72.                 }  
  73.                 else  
  74.                 {  
  75.                     CurGoNextStep(me);  
  76.                 }  
  77.             }  
  78.             else  
  79.             {  
  80.                 CurGoNextStep(me);  
  81.             }  
  82.             break;  
  83.         case Direction.NoDir:  
  84.             //无路可走了已经  
  85.             break;  
  86.     }  
  87. }  
  88.   
  89. //转换方向  
  90. private  Direction SwitchDirection(MazeElem me)  
  91. {  
  92.     switch (me.dir)  
  93.     {   
  94.         case Direction .None:  
  95.             me.dir = Direction.East;  
  96.             return Direction.East;  
  97.             break;  
  98.         case Direction.East:  
  99.             me.dir = Direction.South;  
  100.             return Direction.South;  
  101.             break;  
  102.         case Direction.South:  
  103.             me.dir = Direction.West;  
  104.             return Direction.West;  
  105.             break;  
  106.         case Direction.West:  
  107.             me.dir = Direction.North;  
  108.             return Direction.North;  
  109.             break;  
  110.         case Direction.North:  
  111.             me.dir = Direction.NoDir;  
  112.             return Direction.NoDir;  
  113.             break;  
  114.     }  
  115.     return Direction.None;  
  116. }  
        private  void CurGoNextStep(MazeElem me)
        {
            switch (SwitchDirection(me))
            { 
                case Direction.East:
                    if (me.Y + 1 < y)
                    {
                        MazeElem next = maze[me.X, me.Y+1];
                        //不能为墙，是墙你会走过去么？而且也不能是已经走过的，好马不吃回头草
                        if (!next.IsWall && !next.Flag)
                        {
                            //next.Flag = true;
                            cur = next;
                        }
                         //不行就换个方向把.
                        else
                        {
                            CurGoNextStep(me);
                        }
                    }
                    else
                    {
                        CurGoNextStep(me);
                    }
                    break;
                case Direction.South:
                    if (me.X + 1 <x)
                    {
                        MazeElem next = maze[me.X+1, me.Y];
                        if (!next.IsWall && !next.Flag)
                        {
                            //next.Flag = true;
                            cur = next;
                        }
                        else
                        {
                            CurGoNextStep(me);
                        }
                    }
                    else
                    {
                        CurGoNextStep(me);
                    }
                    break;
                case Direction.West:
                    if (me.Y - 1>0)
                    {
                        MazeElem next = maze[me.X, me.Y - 1];
                        if (!next.IsWall && !next.Flag)
                        {
                            //next.Flag = true;
                            cur = next;
                        }
                        else
                        {
                            CurGoNextStep(me);
                        }
                    }
                    else
                    {
                        CurGoNextStep(me);
                    }
                    break;
                case Direction.North:
                    if (me.X - 1 >0)
                    {
                        MazeElem next = maze[me.X - 1, me.Y];
                        if (!next.IsWall && !next.Flag)
                        {
                            //next.Flag = true;
                            cur = next;
                        }
                        else
                        {
                            CurGoNextStep(me);
                        }
                    }
                    else
                    {
                        CurGoNextStep(me);
                    }
                    break;
                case Direction.NoDir:
                    //无路可走了已经
                    break;
            }
        }

        //转换方向
        private  Direction SwitchDirection(MazeElem me)
        {
            switch (me.dir)
            { 
                case Direction .None:
                    me.dir = Direction.East;
                    return Direction.East;
                    break;
                case Direction.East:
                    me.dir = Direction.South;
                    return Direction.South;
                    break;
                case Direction.South:
                    me.dir = Direction.West;
                    return Direction.West;
                    break;
                case Direction.West:
                    me.dir = Direction.North;
                    return Direction.North;
                    break;
                case Direction.North:
                    me.dir = Direction.NoDir;
                    return Direction.NoDir;
                    break;
            }
            return Direction.None;
        }
[csharp] view plain copy print ?
  1. //开始走迷宫  
  2. public void Start()  
  3. {  
  4.   
  5.     while (cur != end)  
  6.     {     
        //开始走迷宫
        public void Start()
        {

            while (cur != end)
            {
[csharp] view plain copy print ?
  1. //如果没走过  
  2. if (!cur.Flag)  
  3. {  
  4.     //留下痕迹  
  5.     cur.Flag = true;  
  6.     //节点入栈  
  7.     path.Push(maze[cur.X,cur.Y]);  
  8.  //换方向走     
                //如果没走过
                if (!cur.Flag)
                {
                    //留下痕迹
                    cur.Flag = true;
                    //节点入栈
                    path.Push(maze[cur.X,cur.Y]);
                 //换方向走
[csharp] view plain copy print ?
  1.  CurGoNextStep(cur);  
  2. }  
  3. else  
  4. {  
                 CurGoNextStep(cur);
                }
                else
                {
[csharp] view plain copy print ?
  1.             //如果不是无路可走的情况  
  2.             if (cur.dir != Direction.NoDir)  
  3.                 CurGoNextStep(cur);  
  4.             else//无路可走了~~那就回头...  
  5.             {  
  6.                 if (path.Count != 0)  
  7.                 //栈顶弹出  
  8.                      path.Pop();  
  9.                 if (path.Count != 0)  
  10.                 {  
  11.                     //更新cur  
  12.                     cur = path.Peek();  
  13.                 }  
  14.             }  
  15.         }  
  16.     }  
  17. }  
                    //如果不是无路可走的情况
                    if (cur.dir != Direction.NoDir)
                        CurGoNextStep(cur);
                    else//无路可走了~~那就回头...
                    {
                        if (path.Count != 0)
                        //栈顶弹出
                             path.Pop();
                        if (path.Count != 0)
                        {
                            //更新cur
                            cur = path.Peek();
                        }
                    }
                }
            }
        }


 

就这么多吧。可以测试一下：

 
[csharp] view plain copy print ?
  1. //用数组简单表示一个迷宫，大于0则表示该格子为墙  
  2. int[,] array = new int[5, 5] { {0,0,1,0,0 }, {0,1,0,0,0}, {0,1,0,0,0},{ 0,1,0,0,0},{0,0,0,1,0}};  
//用数组简单表示一个迷宫，大于0则表示该格子为墙
int[,] array = new int[5, 5] { {0,0,1,0,0 }, {0,1,0,0,0}, {0,1,0,0,0},{ 0,1,0,0,0},{0,0,0,1,0}};


大概是下面这样的图~~这编辑器有点蛋疼，直接用表格画了（黑色表示墙），左上角和右下角分别为入口和出口（黄色的....）

     
     
     
     
     

[html] view plain copy print ?
  1. //构造迷宫  
  2. Maze m = new Maze(array);  
  3. //开始走迷宫  
  4. m.Start();  
  5. //打印出迷宫中走的方向  
  6. if (m.maze != null)  
  7. {  
  8.     int tmp = 0;  
  9.     foreach (MazeElem me in m.maze)  
  10.     {  
  11.         tmp++;  
  12.         Console.Write(me.dir +" ");  
  13.         if (tmp % 5 == 0)  
  14.             Console.WriteLine();  
  15.     }  
  16. }  
            //构造迷宫
            Maze m = new Maze(array);
            //开始走迷宫
            m.Start();
            //打印出迷宫中走的方向
            if (m.maze != null)
            {
                int tmp = 0;
                foreach (MazeElem me in m.maze)
                {
                    tmp++;
                    Console.Write(me.dir +" ");
                    if (tmp % 5 == 0)
                        Console.WriteLine();
                }
            }


结果如下：

感觉面向对象是好理解些，不过我不是很能够体现出面向对象的好处

警醒与鞭策
关注
专栏目录
C#迷宫的实现~~
08-11 897
自己希望打实基础。当初看这个迷宫很是晕乎，所以现在拿出来写一下。以前一直没能认真地研究一下数据结构，现在当作是还债把。我是菜鸟不解释。。。 迷宫的基础算法在严蔚敏老师写的数据结构（C语言版）已经描述过了。主要是用栈的特性来保存在迷宫之中走过的路径，走到死胡同后再用栈弹出栈顶，再
走迷宫C#版(一)
海&火
06-29 1707
//迷宫类相关 using System;using System.Drawing;using System.Drawing.Drawing2D;using System.Collections; namespace MazeDemo{ ///  /// 迷宫类 ///  public class CMaze {  bool[,] mg;  //地图格子  Stack stack; //堆栈  P
A*算法的迷宫演示（C#实现）
03-03
A*算法的迷宫演示（C#实现），含有详尽代码以及注释
C#实现A*算法迷宫求解演示
最新发布
weixin_42376614的博客
09-10 1266
本文还有配套的精品资源，点击获取 简介：A 算法是一种高效的图形搜索算法，用于寻找最短路径，它结合了Dijkstra算法的最优化策略和Greedy最佳优先搜索的效率。本项目以C#语言实现A 算法，演示其在迷宫问题中的应用。包括迷宫数据结构定义、评估函数计算、开放列表与关闭列表管理、路径搜索、回溯路径构建以及提供详细注释的源代码和可运行程序。通过这个项目，学习者...
C#编写简单的迷宫游戏
qq_18352005的博客
11-29 1110
使用DFS生成迷宫，使用类进行封装。 using System; using System.Threading; using System.Windows.Forms; using System.Text.RegularExpressions; namespace GameApplication { class Map { private char shapeBegin = '*', shapeEnd = '!'; private int size, unit; private (int
C#迷宫程序
06-09
个个用C#的迷宫程序，可以自动生成和求解 PS:该版本为较早版本，重绘方面做得不好，最新版本可以到http://cnc.skycn.com/soft/47630.html下载，有需要源码的朋友可以与我联系。
C# 迷宫源码
09-09
这里我们关注的是一个使用C#编程语言实现的迷宫生成项目，标题为"C# 迷宫源码"。这个项目包含了三种不同的迷宫生成方法：深度优先搜索（DFS）、递归分割法以及随机PRIM算法。这些方法各有特点，适用于不同的场景和...
C#迷宫寻路系统
09-22
C#迷宫寻路系统的开发涉及数据结构、算法和面向对象编程等多个方面。通过学习和实践这样的项目，开发者可以提升对C#的理解，同时锻炼解决问题和优化算法的能力。不论选择DFS、BFS还是A*，都能为求解迷宫路径提供有趣...
C# OpenCvSharp 实现迷宫解密.rar
10-07
在本项目中，"C# OpenCvSharp 实现迷宫解密" 是一个使用C#编程语言结合OpenCvSharp库来解决迷宫问题的应用示例。OpenCvSharp是OpenCV的C#版本，它提供了一系列图像处理和计算机视觉功能，可以用于图像分析、模式识别...
迷宫_C＃游戏_迷宫_自动寻路_
09-29
在本文中，我们将深入探讨如何...通过以上步骤，我们可以创建一个基本的C#迷宫游戏，包含自动迷宫生成和自动寻路功能。这不仅展示了C#语言在游戏开发中的应用，也涵盖了数据结构、算法和游戏设计等多个IT领域的知识。
C#实现4种经典迷宫生成算法和迷宫寻路算法
12-05
本项目涉及的是使用C#语言实现的4种经典迷宫生成算法和A*寻路算法。以下是对这些算法的详细解释： 1. **并查集算法生成迷宫**： 并查集是一种数据结构，用于处理一些不相交集合的合并与查询。在迷宫生成中，可以将...
C#编写的的简易迷宫
04-08
采用C#编写的迷宫游戏程序，使用上下左右控制。 迷宫生成算法为深度优先遍历，具体为拆墙法。 代码是很多年前的了，有很多不尽如人意的地方。
c# winform 非常简单的走迷宫
06-28
c# winform 非常简单走迷宫 将001.txt 002.txt 003.txt放到D盘根目录即可运行，你也可以自己修改路径 键盘方向键控制移动
C#迷宫小游戏
07-27
C#课程设计，功能完成的可以，但程序依然有待改进，特别是使用随机函数搜索的一段，可以继续优化
c#迷宫游戏源码c#迷宫游戏源码
06-06
c#迷宫游戏源码c#迷宫游戏源码c#迷宫游戏源码c#迷宫游戏源码
迷宫路径（C#实现）
11-16
用C#写的可视化程序，采用广度优先算法求迷宫求最短路径程序，环境VS2008
C#开发迷宫控制台小游戏MazeDemo
ylq1045的专栏
02-19 1259
迷宫小游戏，主要使用二维数组，栈Stack，自定义操作符operator，递归遍历等功能。 在VS2017中，新建控制台应用程序MazeDemo，选择.net framework 4.5。 一、新建一个枚举Direction，用于记录方向。Direction.cs代码如下： using System; namespace MazeDemo { /// <summary>...
c#实现迷宫算法。
johncools的博客
04-22 2593
今天突然翻开了c语言数据结构，按照和课本上类似的思路，用c#重写了迷宫算法。算法没有实现最短路径走法，如果你知道最短路径要怎么走，麻烦留言告诉我一下，谢谢！  1using System;  2using System.Collections;  3using System.ComponentModel;  4using System.Data;  5using System.Drawing;
C# 实现迷宫游戏
ftfmatlab的博客
09-17 719
迷宫游戏
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值