迷宫求解的过程演示

最新推荐文章于 2023-01-10 08:54:56 发布
最新推荐文章于 2023-01-10 08:54:56 发布
阅读量1.5k 收藏 1
点赞数
文章标签： delete null class list file 作业
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gfh21cn/article/details/12505
版权

前些日子，帮一个朋友做了个作业，是关于迷宫求解的演示

迷宫求解是个很经典的问题，这个我想不是讨论的问题

我想让大家看看我的思路，提提意见

下面是程序

//头文件

#ifndef Labyrinth_StructH
#define Labyrinth_StructH

#include <vcl.h>
#pragma hdrstop
typedef void __fastcall (__closure *TMyEvent)(int ID);

const int EVENT_PAINT=0;
const int EVENT_BACKDATE=1;
const int EVENT_OK=3;

const int STATE_ERROR=-1;
const int STATE_PASS=0;//可以通过
const int STATE_PASSED=1; //标记已经通过
const int STATE_CANNOTPASS=2;//不能通过
const int STATE_ENTRY=3; //入口点
const int STATE_END=4; //出口点

class SPoint
{
public:

  __fastcall ~SPoint()
  {

  }
  __fastcall SPoint()
  {
   PriorityDirection=1;
   Count=-1;
  }
  __fastcall SPoint(TPoint tPoint)
  {
   PriorityDirection=1;
   Count=-1;
   X=tPoint.x;
   Y=tPoint.y;
  }
  __fastcall SPoint(int tX,int tY)
  {
   PriorityDirection=1;
   Count=-1;
   X=tX;
   Y=tY;
  }
 int operator==(const SPoint& Source)
  {
   return(Source.X==X&&Source.Y==Y);
  }
 int operator!=(const SPoint& Source)
  {
   return(Source.X!=X||Source.Y!=Y);
  }

int X;
int Y;
int Count;
int PriorityDirection;//一个优先方向另加四个方向
};


template<class T>class CShed //栈
{
public:
  TList *List;
  __fastcall CShed();
  __fastcall ~CShed();
  T *Pop();
  void Push(T *point);

};

 

class CLabyrinth
  {
      TCanvas *LabyrinthCanvas;
      int ImageHeight;
      int ImageWidth;

      int LabyrinthHeight;
      int LabyrinthWidth;

      int LabyrinthCol;
      int LabyrinthRow;

      int UnitHeight;
      int UnitWidth;

      int LeftSpace;
      int TopSpace;

      TStringList *AlreadPassList;
      int *LabyrinthData;

      Graphics::TBitmap *Bitmap_STATE_PASS;
      Graphics::TBitmap *Bitmap_STATE_PASSED;
      Graphics::TBitmap *Bitmap_STATE_CANNOTPASS;
      Graphics::TBitmap *Bitmap_STATE_ENTRY;
      Graphics::TBitmap *Bitmap_STATE_END;
      void SetMemory();
      void SetRowCol(int tRow,int tCol);
      bool GetNewPoint(int Direction,int &tRow,int &tCol,int &tState);
      void SetState(int tRow,int tCol,int tState);
    public:
      __fastcall CLabyrinth(AnsiString FileName);
      __fastcall CLabyrinth(int tWidth,int tHeight,TCanvas *tCanvas=NULL);
      __fastcall ~CLabyrinth();
      void __fastcall Assin(const CLabyrinth& Source)
      {
       LabyrinthCol=Source.LabyrinthCol;
       LabyrinthRow=Source.LabyrinthRow;
       LabyrinthData=new int[LabyrinthRow*LabyrinthCol];
        for(int k=0;k<LabyrinthRow*LabyrinthCol;k++)
           LabyrinthData[k]=Source.LabyrinthData[k];
      }

    public:
      void ChangRowCol(int tRow,int tCol);
      void GetRowCol(int &tRow,int &tCol);
      void Updata();

      void SetSize(int tWidth,int tHeight);
      void GetSize(int &tWidth,int &tHeight);
      void GetSpace(int &tLeftSpace,int &tTopSpace);
      void SetCanvas(TCanvas *tCanvas);
      void Refresh();//整个画板进行刷新
      void Refresh(TRect rect,int tState=-1);
      void Refresh(TPoint point,int tState=-1);
      void Refresh(int tRow,int tCol,int tState=-1);
      void SaveToFile(AnsiString tFileName="");
      bool LoadFromFile(AnsiString tFileName="");
      int ConvertRC(int tRow,int tCol);
      int GetState(int tRow,int tCol);
      int GetState(TPoint tPoint);
      void ChangeState(int OldState,int NewState,int Times=-1);
      void FindResult(TPoint *StartPoint=NULL);
    public:
      bool PowerExit;
      bool IsChange;
      AnsiString FileName;

      TMyEvent FMyEvent;

  };

 


#endif

//下面是实现部分

#include <stdio.h>
#pragma hdrstop
#include "Labyrinth_Struct.h"


__fastcall CLabyrinth::CLabyrinth(AnsiString FileName)
{
 LoadFromFile(FileName);
}
void CLabyrinth::Updata()
{
 UnitHeight=ImageHeight/LabyrinthRow;
 UnitWidth=ImageWidth/LabyrinthCol;

 LabyrinthHeight=UnitHeight*LabyrinthRow;
 LabyrinthWidth=UnitWidth*LabyrinthCol;

 LeftSpace=(ImageWidth-LabyrinthWidth)/2;
 TopSpace=(ImageHeight-LabyrinthHeight)/2;

}

__fastcall CLabyrinth::CLabyrinth(int tWidth,int tHeight,TCanvas *tCanvas)
{
 LabyrinthData=NULL;
 PowerExit=false;
 AlreadPassList=new TStringList();
 Bitmap_STATE_PASS=new Graphics::TBitmap();
 Bitmap_STATE_PASSED=new Graphics::TBitmap();
 Bitmap_STATE_CANNOTPASS=new Graphics::TBitmap();
 Bitmap_STATE_ENTRY=new Graphics::TBitmap();
 Bitmap_STATE_END=new Graphics::TBitmap();
 Bitmap_STATE_PASS->LoadFromResourceName((int)HInstance, "PASSNUNLL");
 Bitmap_STATE_PASSED->LoadFromResourceName((int)HInstance, "PASS");
 Bitmap_STATE_CANNOTPASS->LoadFromResourceName((int)HInstance, "CANNOTPASS");
 Bitmap_STATE_ENTRY->LoadFromResourceName((int)HInstance, "STATE_ENTRY");
 Bitmap_STATE_END->LoadFromResourceName((int)HInstance, "STATE_END");
 IsChange=false;
 LabyrinthData=NULL;
 LabyrinthCol=40;
 LabyrinthRow=40;
 LabyrinthCanvas=tCanvas;
 ImageHeight=tHeight;
 ImageWidth=tWidth;
 SetRowCol(LabyrinthRow,LabyrinthCol);
}
__fastcall CLabyrinth::~CLabyrinth()
{
 delete Bitmap_STATE_PASS;
 delete Bitmap_STATE_PASSED;
 delete Bitmap_STATE_CANNOTPASS;
 delete Bitmap_STATE_ENTRY;
 delete Bitmap_STATE_END;

 if(LabyrinthData)
  {
  delete []LabyrinthData;
  LabyrinthData=NULL;
  }
}


void CLabyrinth::SetMemory()
{
 if(LabyrinthData)
  {
  delete []LabyrinthData;
  LabyrinthData=NULL;
  }

 LabyrinthData=new int[LabyrinthRow*LabyrinthCol];
 for(int k=1;k<LabyrinthRow*LabyrinthCol;k++)
    LabyrinthData[k]=STATE_PASS;
 LabyrinthData[0]=STATE_ENTRY;
 LabyrinthData[LabyrinthRow*LabyrinthCol-1]=STATE_END;
}
void CLabyrinth::SetRowCol(int tRow,int tCol)
{
 LabyrinthCol=tCol;
 LabyrinthRow=tRow;
 Updata();
 SetMemory();
}
void CLabyrinth::SetCanvas(TCanvas *tCanvas)
{
 LabyrinthCanvas=tCanvas;
}
void CLabyrinth::Refresh()
{
 if(LabyrinthCanvas!=NULL)
  {
  LabyrinthCanvas->Brush->Color=clBlack;
  LabyrinthCanvas->FillRect(Rect(0,0,ImageWidth,ImageHeight));
  }
 for(int k=0;k<LabyrinthRow;k++)
   for(int l=0;l<LabyrinthCol;l++)
    Refresh(k+1,l+1);
}
void CLabyrinth::Refresh(TRect rect,int tState)
{
 int tLeft,tTop,tRight,tBottom;
 tLeft=rect.Left-LeftSpace;
 tTop=rect.Top-TopSpace;
 tBottom=rect.Bottom-TopSpace;
 tRight=rect.Right-LeftSpace;

 int tLeftCol=tLeft/UnitWidth+1;
 int tLeftRow=tTop/UnitHeight+1;
 int tRightCol=tRight/UnitWidth;
 int tRightRow=tBottom/UnitHeight;
 tRightCol+=tRight%UnitWidth>0?1:0;
 tRightRow+=tBottom%UnitHeight>0?1:0;
 for(int k=tLeftRow;k<=tRightRow;k++)
  for(int l=tLeftCol;l<=tRightCol;l++)
    Refresh(k,l,tState);

}
void CLabyrinth::Refresh(TPoint point,int tState)
{
  int tCol=(point.x-LeftSpace)/UnitWidth;
  int tRow=(point.y-TopSpace)/UnitHeight;
  tCol+=point.x%UnitWidth>0?1:0;
  tRow+=point.y%UnitHeight>0?1:0;
  Refresh(tRow,tCol,tState);

}
void CLabyrinth::Refresh(int tRow,int tCol,int tState)
{
 if(LabyrinthCanvas==NULL)
   return;
 if(tRow<0||tCol<0||tRow>LabyrinthRow||tCol>LabyrinthCol)
   return;
 int OldState=LabyrinthData[ConvertRC(tRow,tCol)];
 if(tState!=-1)
  {
  if(OldState==STATE_ENTRY||OldState==STATE_END)
    return;
  LabyrinthData[ConvertRC(tRow,tCol)]=tState;
  IsChange=true;
  }
  else
    tState=OldState;

 switch(tState)
 {
  case STATE_PASS: LabyrinthCanvas->StretchDraw(Rect(UnitWidth*(tCol-1)+LeftSpace,UnitHeight*(tRow-1)+TopSpace,UnitWidth*tCol+LeftSpace,UnitHeight*tRow+TopSpace),Bitmap_STATE_PASS);break;
  case STATE_PASSED:LabyrinthCanvas->StretchDraw(Rect(UnitWidth*(tCol-1)+LeftSpace,UnitHeight*(tRow-1)+TopSpace,UnitWidth*tCol+LeftSpace,UnitHeight*tRow+TopSpace),Bitmap_STATE_PASSED); break;
  case STATE_CANNOTPASS:LabyrinthCanvas->StretchDraw(Rect(UnitWidth*(tCol-1)+LeftSpace,UnitHeight*(tRow-1)+TopSpace,UnitWidth*tCol+LeftSpace,UnitHeight*tRow+TopSpace),Bitmap_STATE_CANNOTPASS); break;
  case STATE_ENTRY:LabyrinthCanvas->StretchDraw(Rect(UnitWidth*(tCol-1)+LeftSpace,UnitHeight*(tRow-1)+TopSpace,UnitWidth*tCol+LeftSpace,UnitHeight*tRow+TopSpace),Bitmap_STATE_ENTRY); break;
  case STATE_END:LabyrinthCanvas->StretchDraw(Rect(UnitWidth*(tCol-1)+LeftSpace,UnitHeight*(tRow-1)+TopSpace,UnitWidth*tCol+LeftSpace,UnitHeight*tRow+TopSpace),Bitmap_STATE_END); break;
  default: break;
 }


}
int CLabyrinth::ConvertRC(int tRow,int tCol)
{
 return((tRow-1)*LabyrinthCol+tCol-1);

}

void CLabyrinth::SetSize(int tWidth,int tHeight)
{
 LabyrinthHeight=tHeight;
 LabyrinthWidth=tWidth;
 UnitHeight=LabyrinthHeight/LabyrinthRow;
 UnitWidth=LabyrinthWidth/LabyrinthCol;
 LabyrinthHeight=UnitHeight*LabyrinthRow;
 LabyrinthWidth=UnitWidth*LabyrinthCol;
 Refresh();


}
void CLabyrinth::GetSpace(int &tLeftSpace,int &tTopSpace)
{
 tLeftSpace=LeftSpace;
 tTopSpace=TopSpace;

}

void CLabyrinth::GetSize(int &tWidth,int &tHeight)
{
 tHeight=LabyrinthHeight;
 tWidth=LabyrinthWidth;

}
int CLabyrinth::GetState(int tRow,int tCol)
{
 if(tRow>0&&tCol>00&&tRow<=LabyrinthRow&&tCol<=LabyrinthCol)
   return(LabyrinthData[ConvertRC(tRow,tCol)]);
   return STATE_ERROR;
}

int CLabyrinth::GetState(TPoint tPoint)
{
  int tCol=tPoint.x/UnitWidth;
  int tRow=tPoint.y/UnitHeight;
  tCol+=tPoint.x%UnitWidth>0?1:0;
  tRow+=tPoint.y%UnitHeight>0?1:0;
  if(tRow>0&&tCol>0&&tRow<=LabyrinthRow&&tCol<=LabyrinthCol)
   return(LabyrinthData[ConvertRC(tRow,tCol)]);
   return STATE_ERROR;

}
void CLabyrinth::SaveToFile(AnsiString tFileName)
{
  if(tFileName.IsEmpty())
    tFileName=FileName;
  if(tFileName.IsEmpty())
    return;
   FILE *in;
 try
 {
 try
 {
   if ((in = fopen(tFileName.c_str(), "w+"))== NULL)
   {
      ShowMessage("不能打开文件！！！");
      throw(0);
   }
   char SMark[5]="Labyr";
   int tEdition=100;
   fprintf(in, " %s ", SMark);
   fprintf(in, " %d ", tEdition);
   fprintf(in, " %d %d ", LabyrinthRow,LabyrinthCol);
   for(int k=0;k<LabyrinthRow*LabyrinthCol;k++)
     fprintf(in, " %d ", LabyrinthData[k]);
   FileName=tFileName;
   IsChange=false;
 }
 __finally
 {
   fclose(in);
 }
 }
 catch(...)
 {
  return;
 }
}
void CLabyrinth::GetRowCol(int &tRow,int &tCol)
{
 tRow=LabyrinthRow;
 tCol=LabyrinthCol;
}
void CLabyrinth::ChangRowCol(int tRow,int tCol)
{
 if(tRow>60||tRow<10||tCol>60||tRow<10)
   {
    ShowMessage("列和行超出边界(60>x>10)");
    return;
   }
 LabyrinthData=NULL;
 LabyrinthCol=tCol;
 LabyrinthRow=tRow;
 SetRowCol(LabyrinthRow,LabyrinthCol);
 IsChange=true;
 Refresh();
}
void CLabyrinth::SetState(int tRow,int tCol,int tState)
{
  if(tRow>0&&tCol>0&&tRow<=LabyrinthRow&&tCol<=LabyrinthCol)
   {
   if(GetState(tRow,tCol)!=STATE_ENTRY&&GetState(tRow,tCol)!=STATE_END)
      LabyrinthData[ConvertRC(tRow,tCol)]=tState;
   }
}

void CLabyrinth::ChangeState(int OldState,int NewState,int Times)
{
 int tCount=0;
 for(int k=0;k<LabyrinthRow*LabyrinthCol;k++)
   {
    if(LabyrinthData[k]==OldState)
     {
      IsChange=true;
      LabyrinthData[k]=NewState;
      tCount++;
      int tCol,tRow;
      tRow=k/LabyrinthCol;
      tCol=k%LabyrinthCol;
      Refresh(tRow+1,tCol+1);
      if(tCount==Times)
        return ;
     }
   }

}

bool CLabyrinth::LoadFromFile(AnsiString tFileName)
{
 FILE *in;
 try
  {
 try
 {
   if ((in = fopen(tFileName.c_str(), "r"))== NULL)
   {
      ShowMessage("不能打开文件！！！");
      throw(0);
   }
   rewind(in);
   char  Mark[5];
   AnsiString SMark="Labyr";
   fscanf(in, " %s ", Mark);
   AnsiString tempStr=Mark;
  tempStr=tempStr.SubString(1,5);
   if(tempStr!=SMark)
   {
    ShowMessage("该文件不是迷宫数据文件");
      throw(0);
   }
   int tRow,tCol;
   int tEdition;
   fscanf(in, " %d ", &tEdition);
   fscanf(in, " %d %d ", &tRow,&tCol);
   LabyrinthCol=tCol;
   LabyrinthRow=tRow;

   SetMemory();
   int tState;
   for(int k=0;k<LabyrinthRow*LabyrinthCol;k++)
    {
     if(feof(in))
       {
        ShowMessage("文件被破坏！！！");
      throw(0);
       }
     fscanf(in, " %d ", &tState);
     LabyrinthData[k]=tState;
    }
   FileName=tFileName;
   IsChange=false;


 }
 __finally
 {
   fclose(in);
 }
  }
  catch(...)
  {
   return false;
  }
}


bool CLabyrinth::GetNewPoint(int Direction,int &tRow,int &tCol,int &tState)
{
int OldCol=tCol;
int OldRow=tRow;
switch(Direction)
 {
   case 1: tCol=tCol;tRow=tRow-1;break;
   case 2: tCol=tCol+1;tRow=tRow;break;
   case 3: tCol=tCol;tRow=tRow+1;break;
   case 4: tCol=tCol-1;tRow=tRow;break;
   default :return false;
 }
 tState=GetState(tRow+1,tCol+1);
 if((tState==STATE_PASS||tState==STATE_END)&&AlreadPassList->IndexOf(Format("X:%dY:%d",ARRAYOFCONST((OldCol+1,OldRow+1))))<0)//发现了新的结点
  return true;
 return false;
}
void CLabyrinth::FindResult(TPoint *tStartPoint)
{
  SPoint *StartSPoint;
  SPoint *CurrentSPoint;
  SPoint *StopSPoint;//=new SPoint();
  TPoint StartPoint;
  TPoint StopPoint;
  int tCount=0;
   AlreadPassList->Clear();
  for(int l=0;l<LabyrinthRow;l++)
   for(int k=0;k<LabyrinthCol;k++)
    {
     if(LabyrinthData[l*LabyrinthCol+k]==STATE_ENTRY)
       {
        StartPoint.x=k;
        StartPoint.y=l;
        tCount++;
        break;
       }
     if(LabyrinthData[l*LabyrinthCol+k]==STATE_END)
       {
        StopPoint.x=k;
        StopPoint.y=l;  tCount++;
        break;

       }
     if(tCount==2)
       break;
    }

  if(tStartPoint!=NULL)
    CurrentSPoint=new SPoint(*tStartPoint);
    else
     CurrentSPoint=new SPoint(StartPoint);
  StopSPoint=new SPoint(StopPoint);
  StartSPoint=CurrentSPoint;
  if(CurrentSPoint->X>StopSPoint->X)
    CurrentSPoint->PriorityDirection=4;
    else
     CurrentSPoint->PriorityDirection=2;

  CShed<SPoint>tShed;

  int NowState;
  int CX,CY;
  while(1)
   {
     if(PowerExit)
     break;
    do{
      if(PowerExit)
        break;
      CurrentSPoint->Count++;
      bool tNeedPush;
      CX=CurrentSPoint->X;
      CY=CurrentSPoint->Y;
      switch(CurrentSPoint->Count)
       {
         case 0: tNeedPush=GetNewPoint(CurrentSPoint->PriorityDirection,CY,CX,NowState); break;
         case 1:
         case 2:
         case 3:
         case 4: tNeedPush=GetNewPoint(CurrentSPoint->Count,CY,CX,NowState);break;
         default: tNeedPush=false;
                  SetState(CurrentSPoint->Y+1,CurrentSPoint->X+1,STATE_PASS);
                  Refresh(CurrentSPoint->Y+1,CurrentSPoint->X+1);
                  AlreadPassList->Add(Format("X:%dY:%d",ARRAYOFCONST((CurrentSPoint->X+1,CurrentSPoint->Y+1))));
                  CurrentSPoint=tShed.Pop();
                  if(FMyEvent)
                    FMyEvent(EVENT_BACKDATE);
                  break;
       }
       if(tNeedPush)
       {
       int OldPriorityDirection=CurrentSPoint->PriorityDirection;
       int OldCount=CurrentSPoint->Count;
       SetState(CurrentSPoint->Y+1,CurrentSPoint->X+1,STATE_PASSED);
       Refresh(CurrentSPoint->Y+1,CurrentSPoint->X+1);
       tShed.Push(CurrentSPoint);
        if(FMyEvent)
          FMyEvent(EVENT_PAINT);
       CurrentSPoint=new SPoint(CX,CY);
       if(OldCount==0)
         CurrentSPoint->PriorityDirection=OldPriorityDirection;
         else
          CurrentSPoint->PriorityDirection=OldCount;
        if(NowState==STATE_END)
         {
           MessageDlg("恭喜你!!!", mtInformation, TMsgDlgButtons()<<mbOK, 0);
           ChangeState(STATE_PASSED,STATE_PASS);
           Refresh();
           if(FMyEvent)
             FMyEvent(EVENT_OK);
           return;
         }
       break;
      }
     }while(CurrentSPoint);
    if(CurrentSPoint==NULL)//没有解
        {
           MessageDlg("本迷宫没有通路。", mtWarning, TMsgDlgButtons()<<mbOK, 0);
           if(FMyEvent)
             FMyEvent(EVENT_OK);
        return;
        }
   }

  PowerExit=false;
}

//下面是栈的成员函数
template<class T>
__fastcall CShed<T>::CShed()
{
 List=new TList();
}
template<class T> __fastcall CShed<T>::~CShed()
{
 while(List->Count)
  {
    T *temp=(T *)List->Items[0];
    delete temp;
    List->Delete(0);
  }
}
template<class T> T *CShed<T>::Pop()
{
 if(!List->Count)
   return NULL;

  T *temp=(SPoint *)List->Items[List->Count-1];
  List->Delete(List->Count-1);
  return temp;

 

}
template<class T> void  CShed<T>::Push(T *point)
{
   List->Add(point);

}
///

 

gfh21cn
关注
迷宫通路的图形界面演示程序(栈)
枫叶啦啦的博客
05-03 6370
编制一个求解迷宫通路的图形界面演示程序。 *问题描述： 1） 输入一个任意大小的迷宫，任设起点、终点、障碍，用栈求出一条走 出迷宫的路径，并显示在屏幕上。 2） 根据用户界面提示，用键盘输入。Home 键设置迷宫起点，End 键设终 点，上下左右箭头键移动，Enter 键添加墙，Del 键删除墙，完成后按 F9 键演示，Esc 键退出。 3）橙色的实心小圆圈表示起点，绿色实心圆圈表示终点，空心圆圈...
算法课设之迷宫求解问题
javaPGone的博客
05-18 510
问题描述 迷宫问题求解 • 使用深度优先的方法解决迷宫问题 • 规定迷宫的最外围为一圈墙，给出起点和终点要求输出一条正确的路径，但不要求为最短路径 • 使用opencv实现可视化，演示一个动态求解迷宫的过程 1）在迷宫求解问题上，看似些许有些难度，但是其实很简单，用一种称为广度搜索的算法，将玩家选定的初始点为出发点，向四周搜索可通行的位置，算法的设计：下—>右—>上—>左—>下，根据这个一直搜索下去。直到找到终点，否则，显示错误。 2）为了避免多次检验是否走...
数据结构课程设计 迷宫问题的求解及演示
07-03
数据结构课程设计 迷宫问题的求解及演示 数据结构课程设计 迷宫问题的求解及演示 数据结构课程设计 迷宫问题的求解及演示
用堆栈求解迷宫问题的演示
12-09
用堆栈求解迷宫问题的演示。参考清华大学严蔚敏《数据结构》教材。
基于深度及广度优先搜索的迷宫问题的演示
weixin_30772261的博客
06-23 171
1时间复杂度分析 由于该图采用邻接矩阵存储，整个算法遍历的过程所花费的时间复杂度为该矩阵的N(row*col)。而由于其需要分别访问已经定位，需要进行分别2次操作，如下： visited = new bool[col*row];//访问标记 for (i=0; i<row; i++) for (j=0; j<col; j++) visited[i*co...
走迷宫图解
最新发布
weixin_65259109的博客
01-10 500
本节利用栈的思想用试探法进行了迷宫一条路径的探索。其中主要的操作是找到下一个空格、如果空格不再可行退回上一个格、每走过一个格子将走过的格子标记为-1防止循环走。
数据机构 线性表 单链表 栈 汉诺塔 迷宫求解 等的演示
11-27
在这个演示中，我们将探讨几个重要的数据结构及其应用：线性表、单链表、栈、汉诺塔问题以及迷宫求解。 首先，线性表是一种基本的数据结构，它由具有相同类型元素的有序序列组成。在实际应用中，线性表可以是数组或...
migong.rar_可我还喜欢你_迷宫求解
09-24
但是这对一个演示程序来说是不行的，我们需要演示一个迷宫行走者在迷宫中的行走过程。 因此我们用另外的方式来实现，我们首先要需要一个状态机来记录当前行走者的状态，比如说他是处在行走还是寻找一个新的可以到达...
数据结构-栈的应用-迷宫求解
04-16
在本主题“数据结构-栈的应用-迷宫求解”中，我们将探讨如何利用栈来解决迷宫路径搜索的问题。 首先，迷宫求解是一个典型的图遍历问题，可以通过深度优先搜索（DFS）或广度优先搜索（BFS）等算法来解决。在这里，...
迷宫求解问题
10-07
1.本演示程序中，首先实现一个以链表做存储结构的栈类型，然后编写一个求解迷宫的非递归程序。求得的通路以三元组（i，j，d）的形式输出，其中：（i，j）指示迷宫中的一个坐标的方向。 2.演示程序以用户和计算机的...
C++语言编制一个求解迷宫通路的程序
05-27
这是一个求解迷宫通路的实验报告，里面附有全部源程序和程序结果，希望可以给大家一点启发，谢谢！
编制一个求解迷宫通路的程序
03-18
这是一个用C语言编写的有关迷宫问题的程序，有详细的程序和报告。
用opencv+vs2013做的迷宫求解程序，能自动标记迷宫的最佳路线，附图。opencv的环境需自己配置
11-11
用opencv+vs2013做的迷宫求解程序，能自动标记迷宫的最佳路线，附图。opencv的环境需自己配置。
基于Java的迷宫程序（带界面）
03-23
用Eclipse开发的迷宫程序，附带界面设计，整个程序可跑起来，可附加设置迷宫难度等级。
迷宫求解（包含随机迷宫、求解动画演示）——C语言 数据结构
m0_62038333的博客
01-03 5993
迷宫求解（包含随机迷宫、求解动画演示）——C语言 数据结构。该程序是一项 “迷宫求解” 类问题，主要功能包含： ①25 X 25迷宫的随机生成《随机迷宫》 ②迷宫求解的动画演示（DFS）《动画演示》 完整代码附最后 : )
最简单的迷宫求解
superficial
03-16 1436
使用栈对迷宫进行求解，并且使用了探测法和回溯法。
界面演示
weixin_30653097的博客
05-07 96
新做的界面 转载于:https://www.cnblogs.com/hnxxcxg/archive/2012/05/07/2487440.html
迷宫问题求解（用栈实现）
protecteyesight的博客
07-12 5854
迷宫问题求解 任务：可以输入一个任意大小的迷宫数据，用非递归的方法求出一条走出迷宫的路径，并将路径输出； 要求：在上交资料中请写明：存储结构、基本算法（可以使用程序流程图）、源程序、测试数据和结果、算法的时间复杂度、另外可以提出算法的改进方法； #include #include #include #include #include #include using
经典c程序(0032) ---迷宫可行性分析
NTSK13
07-11 726
/************************************************************************************** * Function : test * Create Date : 2014/07/11 * Author : NTSK13 * Email : beijiwei@qq.com *
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值