迷宫问题提交

/****************************************************
*   Functions to solve mazes.                       *
*                                                   *
*   Datafile must still contain size as first data. *
*                                                   *
*   Four functions are only stubs.                  *
****************************************************/

#include <iostream>
#include <fstream>
#include "Maze.h"
using namespace std;
struct Node
{
 int npi;
 int npos;
 enum Direction nhead;
};
Node nNode[400];
int ni = 0;
// The following enumerated type indicates directions within the maze

enum Direction {DOWN, LEFT, UP, RIGHT};

// This struct is used for locations within the maze

struct Position
{
 int H, V;
};

// The maze itself is indicated by # for the walls
// All other locations in the maze can be any other character
// Global variables defining the maze to be solved
int mazeWidth, mazeHeight;
char* maze;

int* posi;
int i=0;
//int sameposi[17 * 17] = { 0 };

// These functions provide access to the maze
// as well as provide manipulation of direction
// of motion and maze location
// See implementation for details

void FindEntrance(int&);
bool AtExit(int);
void ReportPosition(int);
void WheresRight(int,Direction,int&);
bool Wall(int);
void TurnRight(Direction&);
void TurnBack(Direction&);
void MoveForward(int&,Direction);
void WheresAhead(int,Direction,int&);
void TurnLeft(Direction&);
bool is_DeadEnd(int);
//void BackToNode(int&,Direction&);
bool is_node(int);
void RememberNode(int, Direction);
//bool is_nsame(int);
//void issame(int);
void DeleteNode(void);
// This function loads the maze from the specified file
// returning the maze and its dimensions
// The height of the maze is not actually used anywhere but here

bool LoadMaze(const char fname[])
{
 ifstream ifs(fname);//这里是先输入文件的属性中的地址加上文件名字和类型 如C:\maze1.txt
 
 if (ifs.good())//ifs.good是判断文件是否为无错误的文件
 {
  ifs >> mazeWidth >> mazeHeight;
  maze = new char[mazeHeight*mazeWidth + 1];
  for (int i=0;i<mazeHeight;i++)
   for (int j=0;j<mazeWidth;j++)
    ifs >> maze[i*mazeWidth+j];
  ifs.close();
  return true;
 }
 else
 {
  cerr << "File not found." << endl;
  return false;
 }
}

// This function solves the maze using the 'hand on left wall'
// rule, printing the maze position as it proceeds

void SolveMaze()
{ 
 int pos, other;
 Direction heading;
 posi = new int[mazeHeight*mazeWidth + 1];
 FindEntrance(pos);
 heading = DOWN;
 while (!AtExit(pos))
 {
  //ReportPosition(pos);
  posi[i] = pos;
  i++;
  //issame(pos);
  if (is_node(pos))
  {
   
                RememberNode(pos, heading);//后进先出
   
  }
  if(i>=mazeWidth*mazeHeight)
  {
   cout<<"array too small\n";
   system("pause");
   abort();
  }
  WheresRight(pos,heading,other);
  if (!Wall(other))
  {
   TurnRight(heading);
   MoveForward(pos,heading);
  }
  else
  {
   WheresAhead(pos,heading,other);
   if (!Wall(other))
    MoveForward(pos,heading);
   else
   {
    if (is_DeadEnd(pos))
    {
     TurnBack(heading);
    }
    else
    {
     TurnLeft(heading);
     MoveForward(pos, heading);
    }
   }
    
  }
 }
 posi[i]=pos;
 i++;
 DeleteNode();
 if(i>=mazeHeight*mazeWidth)
 {
  cout<<"array too small\n";
  abort();
 }
 int counter=0;
 for(int j=0;j<i;j++)
 {
  if(posi[j]<0)
   continue;
  cout << "Current position: (" << posi[j]/mazeWidth << ',' << posi[j]%mazeWidth << ')' <<posi[j]<< endl;
  counter++;
 }
 cout<<"total steps:"<<counter<<endl;
 cout << "Maze solved" << endl;
 delete[] posi;
 delete[] maze;
 //system("pause");//调试的时候自己去掉吧
}

// This function scans the maze array for the first non-wall item
// It assumes that the entrance is in the top row of the maze array
 
void FindEntrance(int& pos)
{
 pos= 0; 
 while (Wall(pos)) pos++;
}

// This function returns true if the maze position is the exit
// identified by being in the last row of the array

bool AtExit(int pos)
{
 return (pos >= (mazeHeight-1)*mazeWidth);
}

// This function displays the position in the maze
// At this time it specifies row and column of the array

void ReportPosition(int pos)
{
 cout << "Current position: (" << pos/mazeWidth << ',' << pos%mazeWidth << ')' << endl;
}

// This function takes a maze position and a heading and determines
// the position to the right of this position

void WheresRight(int pos, Direction heading, int& right)
{
 right=pos;
 switch (heading)
 {
 case DOWN:
  {
   right--;
   break;
  }
 case LEFT:
  {
   right-=mazeWidth;
   break;
  }
 case UP:
  {
   right++;
   break;
  }
 case RIGHT:
  {
   right+=mazeWidth;
  }
 }

}

// This function returns true if maze position is wall

bool Wall(int pos)
{
 return (maze[pos] == '#');
}

// This function changes heading by turning right
// Take current heading and adjust so that direction is to the right

void TurnRight(Direction& heading)
{
 //to be finished.
 switch (heading)
 {
 case DOWN:
  heading = LEFT;
  break;
 case LEFT:
  heading = UP;
  break;
 case UP:
  heading = RIGHT;
  break;
 case RIGHT:
  heading = DOWN;
  break;
 }
}

void TurnBack(Direction& heading)
{
 //to be finished.
 switch (heading)
 {
 case DOWN:
  heading = UP;
  break;
 case LEFT:
  heading = RIGHT;
  break;
 case UP:
  heading =DOWN;
  break;
 case RIGHT:
  heading = LEFT;
  break;
 }
}

// This function changes position in the maze by determining
// the next position in the current direction

void MoveForward(int& pos, Direction heading)
{
 //to be finished.
 switch (heading)
 {
 case DOWN:
  pos+=mazeWidth;
  break;
 case LEFT:
  pos--;
  break;
 case UP:
  pos-=mazeWidth;
  break;
 case RIGHT:
  pos++;
  break;
 }
}

// This function determines the position in the direction
// currently heading

void WheresAhead(int pos, Direction heading, int& ahead)
{
 //to be finished.
 ahead = pos;
 switch (heading)
 {
 case DOWN:
  ahead += mazeWidth;
  break;
 case LEFT:
  ahead--;
  break;
 case UP:
  ahead -=mazeWidth;
  break;
 case RIGHT:
  ahead++;
  break;
 }
}

// This function changes heading by turning left

void TurnLeft(Direction& heading)
{
 //to be finished.
 switch (heading)
 {
 case DOWN:
  heading = RIGHT;
  break;
 case LEFT:
  heading = DOWN;
  break;
 case UP:
  heading = LEFT;
  break;
 case RIGHT:
  heading = UP;
  break;
 }
}

bool is_node(int pos)
{
 int r_num = 0;
 if (!Wall(pos + 1))  r_num++;
 if (!Wall(pos - 1))  r_num++;
 if (!Wall(pos + mazeWidth)) r_num++;
 if (!Wall(pos - mazeWidth)) r_num++;
 if (r_num > 2) return 1;
 return 0;
}
/*
void BackToNode(int& pos,Direction& heading)
{
 i = nNode[ni].npi;
 switch (nNode[ni].nhead)//模拟从死胡同走出来的情况
 {
 case DOWN:
  heading = UP;
  break;
 case LEFT:
  heading=RIGHT;
  break;
 case UP:
  heading=DOWN;
  break;
 case RIGHT:
  heading=LEFT;
  break;
 }
 posi[i-1] = nNode[ni].npos;
 pos = nNode[ni].npos;
 ni--;
}

bool is_nsame(int pos)
{
 for (int j = 1; j <= ni; j++)
 {
  if (nNode[j].npos == pos&&(ni!=j))
  {
   return 1;
  }
 }
 return 0;
}*/

/*void issame(int pos)
{
 for (int j = 0; j < i-1; j++)
 {
  if (j!=i&&posi[j] == pos)
  {
   posi[j] = -1;
   posi[i - 1] = -1;
   sameposi[pos] = 1;
   break;
  }
 }
}*/
bool is_DeadEnd(int pos)
{
 int pwall = 0;
 if (Wall(pos + 1)) pwall++;
 if (Wall(pos - 1)) pwall++;
 if (Wall(pos + mazeWidth)) pwall++;
 if (Wall(pos - mazeWidth)) pwall++;
 if (pwall == 3) return 1;
 return 0;
}

void RememberNode(int pos, Direction heading)
{
 nNode[ni].npos = pos;
 nNode[ni].nhead = heading;
 nNode[ni].npi = i-1;
 ni++;
}

void DeleteNode()
{
 for (int j = 0; j < ni; j++)
 {
  for (int z = 0; z < j; z++)
  {
   if (nNode[j].npos == nNode[z].npos&&j != z)
   {
    for (int k = nNode[z].npi; k < nNode[j].npi; k++)
    {
     posi[k] = -1;
    }
   }
  }
 }
}