~跪求~C/C++ 老鼠走迷宫 详细源代码啊！！！拜谢~~~课程设计的

走迷宫游戏
    程序开始运行时显示一个迷宫地图，迷宫*有一只老鼠，迷宫的右下方有一个粮仓。游戏的任务是使用键盘上的方向键操纵老鼠在规定的时间内走到粮仓处。
要求：
1) 老鼠形象可辨认，可用键盘操纵老鼠上下左右移动；
2) 迷宫的墙足够结实，老鼠不能穿墙而过；
3) 正确检测结果，若老鼠在规定时间内走到粮仓处，提示成功，否则提示失败；
4) 添加编辑迷宫功能，可修改当前迷宫，修改内容：墙变路、路变墙；
5) 找出走出迷宫的所有路径，以及最短路径。
利用序列化功能实现迷宫地图文件的存盘和读出等功能

16 个解决方案

#1

测试头像！

#2

分解几个任务

1. 迷宫生成算法。
2. 迷宫 及 老鼠 显示，以及键盘交互。
3. 广度搜索，以找到最短路径。

#3

http://www.pudn.com/downloads22/sourcecode/windows/detail71822.html

要代码都可以去pudn.

#4

学习了，应该有些复杂

#5

来了有的话就把代码留下，定谢~~~还求3楼的帮个忙 谢了啊

#6

哎..不应该告诉他的..

引用 3 楼 hairetz 的回复:

http://www.pudn.com/downloads22/sourcecode/windows/detail71822.html

要代码都可以去pudn.

#7

我也在琢磨这个问题。

#8

去pudn要会员，我要源代码啊  有的速度传~~~~~~~给全分

#9

自己做

#10

我回帖不是为了分。跟分数无关。

#11

#include <graphics.h> 
#include <stdlib.h> 
#include <stdio.h> 
#include <conio.h> 
#include <dos.h> 
#define N 20/*迷宫的大小，可改变*/ 
int  oldmap[N][N];/*递归用的数组,用全局变量节约时间*/ 
int  yes=0;/*yes是判断是否找到路的标志,1找到，0没找到*/ 
int  way[100][2],wayn=0;/*way数组是显示路线用的,wayn是统计走了几个格子*/ 
void Init(void);/*图形初始化*/ 
void Close(void);/*图形关闭*/ 
void DrawPeople(int *x,int *y,int n);/*画人工探索物图*/ 
void PeopleFind(int (*x)[N]);/*人工探索*/ 
void WayCopy(int (*x)[N],int (*y)[N]);/*为了8个方向的递归，把旧迷宫图拷贝给新数组*/ 
int  FindWay(int (*x)[N],int i,int j);/*自动探索函数*/ 
void MapRand(int (*x)[N]);/*随机生成迷宫函数*/ 
void PrMap(int (*x)[N]);/*输出迷宫图函数*/ 
void Result(void);/*输出结果处理*/ 
void Find(void);/*成功处理*/ 
void NotFind(void);/*失败处理*/ 
void main(void)/*主函数*/ 
{ 
  int map[N][N]; /*迷宫数组*/ 
  char ch; 
  clrscr(); 
  printf("\n Please select hand(1) else auto\n");/*选择探索方式*/ 
  scanf("%c",&ch); 
  Init();  /*初始化*/ 
  MapRand(map);/*生成迷宫*/ 
  PrMap(map);/*显示迷宫图*/ 
  if(ch=='1') 
      PeopleFind(map);/*人工探索*/ 
  else 
      FindWay(map,1,1);/*系统自动从下标1,1的地方开始探索*/ 
  Result();/*输出结果*/ 
  Close(); 
} 
void Init(void)/*图形初始化*/ 
{ 
  int gd=DETECT,gm; 
  initgraph(&gd,&gm,"c:\\tc"); 
} 
void DrawPeople(int *x,int *y,int n)/*画人工控制图*/ 
{/*如果将以下两句注释掉，则显示人工走过的路径，*/ 
  /*setfillstyle(SOLID_FILL,WHITE);*/  /*设置白色实体填充样式*/ 
  /*bar(100+(*y)*15-6,50+(*x)*15-6,100+(*y)*15+6,50+(*x)*15+6);  */ 
/*恢复原通路*/ 
  switch(n)/*判断x,y的变化，8个方向的变化*/ 
  { 
      case 1: (*x)--;break; /*上*/ 
      case 2: (*x)--;(*y)++;break ;/*右上*/ 
      case 3: (*y)++;break;  /*右*/ 
      case 4: (*x)++;(*y)++;break; /*右下*/ 
      case 5: (*x)++;break;  /*下*/ 
      case 6: (*x)++;(*y)--;break; /*左下*/ 
      case 7: (*y)--;break;  /*左*/ 
      case 8: (*x)--;(*y)--;break; /*左上*/ 
  } 
  setfillstyle(SOLID_FILL,RED);/*新位置显示探索物*/ 
  bar(100+(*y)*15-6,50+(*x)*15-6,100+(*y)*15+6,50+(*x)*15+6); 
} 
void PeopleFind(int (*map)[N])/*人工手动查找*/ 
{ 
  int x,y; 
  char c=0;/*接收按键的变量*/ 
  x=y=1;/*人工查找的初始位置*/ 
  setcolor(11); 
  line(500,200,550,200); 
  outtextxy(570,197,"d"); 
  line(500,200,450,200); 
  outtextxy(430,197,"a"); 
  line(500,200,500,150); 
  outtextxy(497,130,"w"); 
  line(500,200,500,250); 
  outtextxy(497,270,"x"); 
  line(500,200,450,150); 
  outtextxy(445,130,"q"); 
  line(500,200,550,150); 
  outtextxy(550,130,"e"); 
  line(500,200,450,250); 
  outtextxy(445,270,"z"); 
  line(500,200,550,250); 
  outtextxy(550,270,"c");/*以上是画8个方向的控制介绍*/ 
  setcolor(YELLOW); 
  outtextxy(420,290,"Press 'Enter' to end");/*压回车键结束*/ 
  setfillstyle(SOLID_FILL,RED); 
  bar(100+y*15-6,50+x*15-6,100+y*15+6,50+x*15+6);/*入口位置显示*/ 
  while(c!=13)/*如果按下的不是回车键*/ 
  { 
      c=getch();/*接收字符后开始各个方向的探索*/ 
      if(c=='w'&&map[x-1][y]!=1) 
    DrawPeople(&x,&y,1);/*上*/ 
      else 
    if(c=='e'&&map[x-1][y+1]!=1) 
        DrawPeople(&x,&y,2);/*右上*/ 
    else 
        if(c=='d'&&map[x][y+1]!=1) 
          DrawPeople(&x,&y,3);/*右*/ 
        else 
          if(c=='c'&&map[x+1][y+1]!=1) 
          DrawPeople(&x,&y,4);/*右下*/ 
          else 
          if(c=='x'&&map[x+1][y]!=1) 
            DrawPeople(&x,&y,5);/*下*/ 
          else 
            if(c=='z'&&map[x+1][y-1]!=1) 
            DrawPeople(&x,&y,6); /*左下*/ 
            else 
            if(c=='a'&&map[x][y-1]!=1) 
              DrawPeople(&x,&y,7); /*左*/ 
            else if(c=='q'&&map[x-1][y-1]!=1) 
              DrawPeople(&x,&y,8); /*左上*/ 
  } 
  setfillstyle(SOLID_FILL,WHITE); /*消去红色探索物，恢复原迷宫图*/ 
  bar(100+y*15-6,50+x*15-6,100+y*15+6,50+x*15+6); 
  if(x==N-2&&y==N-2)/*人工控制找成功的话*/ 
      yes=1; /*如果成功标志为1*/ 
} 
void WayCopy(int (*oldmap)[N],int (*map)[N])/*拷贝迷宫数组 */ 
{ 
  int i,j; 
  for(i=0;i <N;i++) 
      for(j=0;j <N;j++) 
    oldmap[i][j]=map[i][j]; 
} 
int FindWay(int (*map)[N],int i,int j)/*递归找路*/ 
{ 
  if(i==N-2&&j==N-2)/*走到出口*/ 
  { 
      yes=1;/*标志为1,表示成功*/ 
      return; 
  } 
  map[i][j]=1;/*走过的地方变为1*/ 
  WayCopy(oldmap,map); /*拷贝迷宫图*/ 
  if(oldmap[i+1][j+1]==0&&!yes)/*判断右下方是否可走*/ 
  { 
      FindWay(oldmap,i+1,j+1); 
      if(yes)/*如果到达出口了，再把值赋给显示路线的way数组,也正是这个原因,所以具体路线是从最后开始保存*/ 
      { 
    way[wayn][0]=i; 
    way[wayn++][1]=j; 
    return; 
      } 
  } 
  WayCopy(oldmap,map); 
  if(oldmap[i+1][j]==0&&!yes)/*判断下方是否可以走,如果标志yes已经是1也不用找下去了*/ 
  { 
      FindWay(oldmap,i+1,j); 
      if(yes) 
      { 
    way[wayn][0]=i; 
    way[wayn++][1]=j; 
    return; 
      } 
  } 
  WayCopy(oldmap,map); 
  if(oldmap[i][j+1]==0&&!yes)/*判断右方是否可以走*/ 
  { 
      FindWay(oldmap,i,j+1); 
      if(yes) 
      { 
    way[wayn][0]=i; 
    way[wayn++][1]=j; 
    return; 
      } 
  } 
  WayCopy(oldmap,map); 
  if(oldmap[i-1][j]==0&&!yes)/*判断上方是否可以走*/ 
  { 
      FindWay(oldmap,i-1,j); 
      if(yes) 
      { 
    way[wayn][0]=i; 
    way[wayn++][1]=j; 
    return; 
      } 
  } 
  WayCopy(oldmap,map); 
  if(oldmap[i-1][j+1]==0&&!yes)/*判断右上方是否可以走*/ 
  { 
      FindWay(oldmap,i-1,j+1); 
      if(yes) 
      { 
    way[wayn][0]=i; 
    way[wayn++][1]=j; 
    return; 
      } 
  } 
  WayCopy(oldmap,map); 
  if(oldmap[i+1][j-1]==0&&!yes)/*判断左下方是否可以走*/ 
  { 
      FindWay(oldmap,i+1,j-1); 
      if(yes) 
      { 
    way[wayn][0]=i; 
    way[wayn++][1]=j; 
    return; 
      } 
  } 
  WayCopy(oldmap,map); 
  if(oldmap[i][j-1]==0&&!yes)/*判断左方是否可以走*/ 
  { 
      FindWay(oldmap,i,j-1); 
      if(yes) 
      { 
    way[wayn][0]=i; 
    way[wayn++][1]=j; 
    return; 
      } 
  } 
  WayCopy(oldmap,map); 
  if(oldmap[i-1][j-1]==0&&!yes)/*判断左上方是否可以走*/ 
  { 
      FindWay(oldmap,i-1,j-1); 
      if(yes) 
      { 
    way[wayn][0]=i; 
    way[wayn++][1]=j; 
    return; 
      } 
  } 
  return; 
} 
void MapRand(int (*map)[N])/*开始的随机迷宫图*/ 
{ 
  int i,j; 
  cleardevice();/*清屏*/ 
  randomize(); /*随机数发生器*/ 
  for(i=0;i <N;i++) 
  { 
      for(j=0;j <N;j++) 
      { 
    if(i==0||i==N-1||j==0||j==N-1)/*最外面一圈为墙壁*/ 
        map[i][j]=1; 
    else 
        if(i==1&&j==1||i==N-2&&j==N-2)/*出发点与终点表示为可走的*/ 
          map[i][j]=0; 
        else 
          map[i][j]=random(2);/*其它的随机生成0或1*/ 
      } 
  } 
} 
void PrMap(int (*map)[N])/*输出迷宫图*/ 
{ 
  int i,j; 
  for(i=0;i <N;i++) 
      for(j=0;j <N;j++) 
    if(map[i][j]==0) 
    { 
        setfillstyle(SOLID_FILL,WHITE);/*白色为可走的路*/ 
        bar(100+j*15-6,50+i*15-6,100+j*15+6,50+i*15+6); 
    } 
    else 
    { 
        setfillstyle(SOLID_FILL,BLUE);/*蓝色为墙壁*/ 
        bar(100+j*15-6,50+i*15-6,100+j*15+6,50+i*15+6); 
    } 
} 
void Find(void)/*找到通路*/ 
{ 
  int i; 
  setfillstyle(SOLID_FILL,RED);/*红色输出走的具体路线*/ 
  wayn--; 
  for(i=wayn;i>=0;i--) 
  { 
      bar(100+way[i][1]*15-6,50+way[i][0]*15-6,100+ 
      way[i][1]*15+6,50+way[i][0]*15+6); 
      sleep(1);/*控制显示时间*/ 
  } 
  bar(100+(N-2)*15-6,50+(N-2)*15-6,100+ 
    (N-2)*15+6,50+(N-2)*15+6); /*在目标点标红色*/ 
  setcolor(GREEN); 
  settextstyle(0,0,2);/*设置字体大小*/ 
  outtextxy(130,400,"Find a way!"); 
} 
void NotFind(void)/*没找到通路*/ 
{ 
  setcolor(GREEN); 
  settextstyle(0,0,2);/*设置字体大小*/ 
  outtextxy(130,400,"Not find a way!"); 
} 
void Result(void)/*结果处理*/ 
{ 
  if(yes)/*如果找到*/ 
      Find(); 
  else/*没找到路*/ 
      NotFind(); 
  getch(); 
} 
void Close(void)/*图形关闭*/ 
{ 
  closegraph(); 
} 

#12

楼主是那个学校的，我们也是这个作业啊，老师球也木有教，怎么做啊

#13

#include<iostream.h>
#include<stdlib.h>
#include <stdio.h> 
#include <time.h> 
#include<conio.h>
#include"stack.h"
#include<conio.h>

#define R 32  //地图总行数
#define L 32  //地图总列数
#define r R-2  //可用的地图行数
#define l L-2  //可用的地图列数
typedef struct
{
    int x;
    int y;
}Node;//标示位置的节点类型

class RatInMase//老鼠和迷宫的主类
{
private:
    stack<Node> *path; //定义一个栈存放Node节点
    int seed;
   
  int mase[R][L];
    int stept;//查找的步数
public:
bool searchPath(int &i,int &j) 
{
    if(i==r&&j==l) return true;//找到并返回真
    if(path->isFull()||path->isEmpty())//如果出现栈空或栈满的错误，将不能修复，只能退出  
    {
        
        cout<<"系统发生不可修复的异常，请按任意键退出...";
        getch();
        exit(1);
    }
    else if(gotoEast(i,j))
        {
            Node thisnode,secondnode;
            thisnode.x=i;
            thisnode.y=j;
            secondnode=path->getSecondNode();
            if(secondnode.x==i&&secondnode.y==j)
         {
                mase[j-1]=1;
                path->pop();
         }
            else 
                path->push(thisnode);
            searchPath(i,j);
        }
    else if(gotoSouth(i,j))//往南走
        {
            Node thisnode,secondnode;
            thisnode.x=i;
            thisnode.y=j;
            secondnode=path->getSecondNode();
            if(secondnode.x==i&&secondnode.y==j)
         {
                mase[i-1][j]=1;
                path->pop();
         }
            else 
                path->push(thisnode);
            searchPath(i,j);
        }
    else if(gotoWest(i,j))//往西走
        {
            Node thisnode,secondnode;
            thisnode.x=i;
            thisnode.y=j;
            secondnode=path->getSecondNode();
            if(secondnode.x==i&&secondnode.y==j)
         {
                mase[j+1]=1;
                path->pop();
         }
            else 
                path->push(thisnode);
            searchPath(i,j);
        }
    else if(gotoNorth(i,j))//往北走
        {
            Node thisnode,secondnode;
            thisnode.x=i;
            thisnode.y=j;
            secondnode=path->getSecondNode();
            if(secondnode.x==i&&secondnode.y==j)
         {
                mase[i+1][j]=1;
                path->pop();
         }
            else 
                path->push(thisnode);
            searchPath(i,j);
        }
    else//如果没有出路了，而且返回了起点。说明没有出路了
        return false;//返回假
        
    
}
void initMase()   //每次执行时初始迷宫的所有设置
{
    Node n;
    
       n.x=1;
       n.y=1;
        seed=2;//初始化随机种子
        stept=0;
        path->clearStack();
        path->push(n);
}
int getSteptCount()
{
    return stept;
}
void print()
{Node n;
    cout<<"老鼠找到的正确路线是："<<endl;
    while(!path->isEmpty())
    {   n=path->getTopNodeAndPop();
        cout<<"("<<n.x <<","<<n.y<<"),";
    }
}
int getStackDepth()
{
    return path->getElementCount();
}
public :
    RatInMase()
    {  
        path=new stack<Node>(100 );//在试图动态分配栈的元素空间时失败！！！
        if(path==NULL)
        {
            cout<<"内存分配失败！";
            getch();
            exit(1);
        }
        Node n;
        n.x=1;
        n.y=1;
        seed=2;//初始化随机种子
        stept=0;
        path->push(n);
    }
    void setSeed(int &s)
    {
        seed=s;
    }
     createMap()
    {
        try{
        for(int j=0;j<L;j++)
            mase[0][j]=1;
        for(j=0;j<L;j++)
            mase[R-1][j]=1;
        for(j=0;j<R;j++)
            mase[j][0]=1;
        for(j=0;j<R;j++)
            mase[j][L-1]=1;//以上四个循环设立围墙
        
        for(int i=1;i<=r;i++)
            for(j=1;j<=l;j++)
            {    srand(j*i*197%seed);//输入随机种子
                mase[j]=rand()%2;
         }
        mase[1][1]=0;//设置入口
        mase[r][l]=0;//设置出口
        for(i=1;i<r;i++)
            for(j=1;j<l;j++)
            {if(i==j)
                mase[j]=1;
             if(i%3==0)
                 mase[j]=0;
         }
        for(j=1;j<r;j++)//为特定点设为开路
            mase[j][1]=0;
        for(j=3;j<l-2;j++)//为特定点设为开路
            mase[5][j]=0;
        for(j=3;j<l-2;j++)//为特定点设为开路
            mase[j][2]=0;
        mase[6][l/2]=1;
        mase[4][8]=1;
        mase[3][l]=1;
        mase[r/2][l/2]=1;
        mase[8][1]=1;
        mase[r][l-1]=0;
        mase[r-1][l]=0;
        mase[r/3][l/4]=1;
        mase[r-1][l-1]=0;//为特定点设为开路
        cout<<"迷宫路线如下："<<endl;
        for(i=0;i<R;i++)//输出迷宫地图
        {  
            for(j=0;j<L;j++)
         {
                cout<<mase[j]<<" ";
         }
           
        cout<<endl;
         
        }
    }
    catch(char)
        {
            cout<<"throw a exeception! "<<endl;
        }
    }
private:
bool gotoSouth(int& i,int& j )//向南走
{
    if(mase[i+1][j]==0)
    {
        i=i+1;
        cout<<"向南走..";//<<endl;
        stept++;
        return true;
    }
    else 
        return false;
}
bool gotoNorth(int& i,int& j)//向北走
{
    if(mase[i-1][j]==0)
    {
        i=i-1;
        cout<<"向北走..";//<<endl;
        stept++;
        return true;
    }
    else 
        return false;
}
bool gotoEast(int& i,int& j)//向东走
{
    if(mase[j+1]==0)
    {
        j=j+1;
        cout<<"向东走..";//<<endl;
        stept++;
        return true;
    }
    else 
        return false;
}
bool gotoWest(int& i,int &j)//向西走
{
    if(mase[j-1]==0)
    {
        j=j-1;
        cout<<"向西走..";//<<endl;
        stept++;
        return true;
    }
    else 
        return false;
}
};
void main()
{RatInMase rat;
int i=1,j=1,seed;
label://跳转标志
i=1;
j=1;
rat.initMase();//将老鼠走的步数初始为0
cout<<"请输入迷宫地图随机种子(必须是数字 嘿嘿...)：";
cin>>seed;
cout<<endl;
rat.setSeed(seed);
rat.createMap();
  cout<<"正在查找请等待......."<<endl;
   cout<<"老鼠的行踪如下："<<endl;
if(rat.searchPath(i,j))
{
    
     cout<<endl<<" 哈哈 小KISS! 共用了"<<rat.getSteptCount()<<"步就找到出口找到路线了！"<<endl;
     //cout<<"正确的路线的步数是："<<rat.getStackDepth()<<endl;
      rat.print();
}
else 
     cout<<endl<<"靠！什么鬼地图啊！！全是死胡同。白费走了"<<rat.getSteptCount()<<"步都没有找到路线！重来一次吧！"<<endl;

cout<<endl<<"再来一次么？(y/n)";
char c;
cin>>c;
if(c=='y'||c=='Y') goto label;
else 
{  getch();
   exit(1);
}
}
stack.h文件源码如下：
/****************************************************************************************
         程序名称：堆栈类
         功能：封装了关于堆栈的所有操作
   ************************************************************************************
#include<iostream.h>
template <class T>
class stack
{
    private:
    
    
    public:
            int top;
            int max;
            T *element;
        stack(const int m=1000)//构造方法 默认栈元素的个数是1000
     {
            element=new T[m];
            top=0;
            max=m;
     }
        bool isFull(){return top==max;}//判断是否为空
        bool isEmpty(){return top==0;}
        stack& push(T a)//入栈
     {
            if(top==max) {cout<<"栈已经满了！"<<endl;return *this;}
              element[++top]=a;
              return *this;
     }
       stack& pop()//出栈
     {
            if(top<0) {cout<<"栈已经空了"<<endl;return *this;}
            top--;
            return *this;
     }
       T getTopNodeAndPop()//返回栈顶值，且退栈
               {
                    if(top<0) {cout<<"栈已经空了"<<endl;}
            else
                      return element[top--];
               }       
       T getTopNode()  //返回栈顶的值
                 {
                    if(top<0) {cout<<"栈已经空了"<<endl;}
            //top--;
                    else
                      return element[top];
               }       
        T getSecondNode()  //返回次栈顶的值
            {
             if(top<0) 
             {cout<<"栈已经空了"<<endl;
               throw "栈已经空了";
               //return (T)NULL;
          }
            //top--;
                    else
                      return element[top-1];
           }
     
      int getElementCount() //获得入栈的元素个数
      {
          return top;
      }
      void clearStack()//清理栈
      {
          top=0;
      }
      
        ~stack()
        {delete []element;}//析构方法

};

来自pudn的代码

#14

居然还有人贴TC的代码。牛！

#15

我实在 无语

#16

每天回帖即可获得10分可用分！小技巧：教您如何更快获得可用分