我要走迷宫！！
刚学完数据结构，老师让做几个小东西，包括求迷宫最短路径，太简单怎么办，自己给自己加需求咯
首先，求迷宫最短路径，先得要有迷宫吧，不过，手动输入迷宫是不是有点太捞了？
//随机产生迷宫
71 void Readfile_rand(unsigned int seed)
72 {
73
74 //初始化存储迷宫信息的数组
75 for(int i = 0;i < L+2;++i)
76 for(int j = 0;j < L+2;++j) {
77 ar[i][j].property = 1;
78 ar[i][j].access = false;
79 }
80 srand(unsigned(seed));
81 for(int i = 1;i < L+1;++i)
82 for(int j = 1;j < L+1;++j) {
83 ar[i][j].x = 0;
84 ar[i][j].y = 0;
85 ar[i][j].property = (rand())%2 + '0';
86 }
87 ar[1][1].property = '0';
88
89
90 }
利用随机数自己生成迷宫，多帅啊
那么问题来了，怎么能确保生成的迷宫有解呢？
毕竟是随机生成的，有解的可能性不太高，只能用笨方法，
通过不断改变种子，生成多个迷宫，直至找到有解的那个为止
//随机生成可以通过的迷宫
270 for(int i = rand()%1000;i < 10000;++i) {
271 Init();
272 Readfile_rand(i);
273 if(Findway() == 1) {
274 break;
275 }
276 }
终于到了老师要求的部分了，论迷宫找路
//非递归遍历迷宫找到出路
struct data{
int x;
int y;
};
int Findway()
{
list lst;
lst.push_back({1,1});
ar[1][1].access = true;
while(ar[L][L].access == false && !lst.empty()) {
auto p = lst.begin();
int x = p->x;
int y = p->y;
if(ar[x][y-1].property == '0' && ar[x][y-1].access == false) {
lst.push_back({x,y-1});
ar[x][y-1].x = x;
ar[x][y-1].y = y;
ar[x][y-1].access = true;
}
if(ar[x][y+1].property == '0' && ar[x][y+1].access == false) {
lst.push_back({x,y+1});
ar[x][y+1].x = x;
ar[x][y+1].y = y;
ar[x][y+1].access = true;
}
if(ar[x-1][y].property == '0' && ar[x-1][y].access == false) {
lst.push_back({x-1,y});
ar[x-1][y].x = x;
ar[x-1][y].y = y;
ar[x-1][y].access = true;
}
if(ar[x+1][y].property == '0' && ar[x+1][y].access == false) {
lst.push_back({x+1,y});
ar[x+1][y].x = x;
ar[x+1][y].y = y;
ar[x+1][y].access = true;
}
lst.pop_front();
}
//输出迷宫出路路径
if(ar[L][L].access == true) {
for(int i = 1;i < L+1;++i)
for(int j = 1;j < L+1;++j)
ar[i][j].access = false;
int i = L,j = L;
while(1) {
ar[i][j].access = true;
int x = ar[i][j].x;
int y = ar[i][j].y;
i = x;
j = y;
if(i == 1 && j == 1)
break;
}
ar[1][1].access = true;
return 1;
}
else
return 0;
} 关于中间四个if,其实可以省略为一个，不过为了方便（其实是懒得搞），就这样了
算法其实也没什么好讲的，这里使用了双向链表代替了队列的作用
１．头结点入队
２．队头结点四个方向可以走的位置全部入队
３．队头结点出队
４．执行２步骤，直到我们的终点标记为已访问或队列为空
就是简单的非递归实现ＢＦＳ
那么我的需求加在哪里了呢，在这儿
void Stand_Alone(char diff)
217 {
218 //从0,0开始
219 ar[0][0].access = true;
220 int x = 1;
221 int y = 1;
222 char choice;
223 Print_alone(1,1,diff);
224 while(ar[L][L].access != true && (choice = getch())) {
225 if(choice == 65 && x-1 >= 1 && ar[x-1][y].property == '0') {
226 ar[x][y].access = false;
227 x -= 1;
228 }
229 if(choice == 66 && x+1 <= L && ar[x+1][y].property == '0') {
230 ar[x][y].access = false;
231 x += 1;
232
233 }
234 if(choice == 67 && y+1 <= L && ar[x][y+1].property == '0') {
235 ar[x][y].access = false;
236 y += 1;
237 }
238 if(choice == 68 && y-1 >= 1 && ar[x][y-1].property == '0') {
239 ar[x][y].access = false;
240 y -= 1;
241 }
242 if(choice == 't') {
243 system("clear");
244 Init();
245 Findway();
246 Print();
247 }
248 ar[x][y].access = true;
249 system("clear");
250 Print_alone(x,y,diff);
251 cout << x << "," << y << " " << "终点:" << L << "," << L << endl;
252 cout << "t.提示" << endl;
253 }
254
255 system("clear");
256 Print();
257 cout << "成功！！！" << endl;
258 }
初始位置为１，１ 为了到达终点，需要自己控制上下左右，也就是说是个一般的迷宫游戏，到达终点则游戏结束
不过要是一般的简单迷宫，不夸张的说，眼睛遍历都给它能遍历出出路，所以，又加了一点点难度选项’
正如上面看到的那样，函数参数用于控制游戏难度，难度具体体现在哪些方面呢
void Print_alone(int x,int y,char diff)
194 {
195 for(int i = 1;i < L+1;++i) {
196 for(int j = 1;j < L+1;++j) {
197 if(i >= x+'a'-diff && i <= x-'a'+diff && j >= y+'a'-diff && j <= y-'a'+diff) {
198
199 if(ar[i][j].access == true)
200 cout << "_";
201 else {
202 if(ar[i][j].property == '0')
203 cout << "@";
204 else
205 cout << "#";
206
207 }
208 }
209 else
210 cout << " ";
211 }
212 cout << endl;
213 }
214 }
这个函数用来显示此时“行走"的情况，若参数为困难，则每次只会显示出玩家当前所在格，其他整个迷宫则都为空
中等的话是会显示出玩家所在九宫格，而随机生成的迷宫，要求应该是不低于16*16的
没有学习过图形库，纯字符界面确实丑陋，试着看能不能加上去
其实也是为了好玩，毕竟纯粹只按老师说的搞太无趣了
下面是整个的源代码，感觉还可以抢救一下
#include
#include
#include
#include
#include
#include
#include
#define L 16
using namespace std;
typedef struct{
char property; //结点属性
bool access; //结点是否被访问
int x; //上一个结点的坐标
int y;
}Maze;
#include
int getch(void)
{
struct termios tm, tm_old;
int fd = 0, ch;
if (tcgetattr(fd, &tm) < 0) {//保存现在的终端设置
return -1;
}
tm_old = tm;
cfmakeraw(&tm);//更改终端设置为原始模式，该模式下所有的输入数据以字节为单位被处理
if (tcsetattr(fd, TCSANOW, &tm) < 0) {//设置上更改之后的设置
return -1;
}
ch = getchar();
if (tcsetattr(fd, TCSANOW, &tm_old) < 0) {//更改设置为最初的样子
return -1;
}
return ch;
}
Maze ar[L+2][L+2];
void Init()
{
//初始化迷宫数组
for(int i = 0;i < L+2;++i)
for(int j = 0;j < L+2;++j)
ar[i][j].access = false;
}
void Print()
{
for(int i = 1;i < L+1;++i) {
for(int j = 1;j < L+1;++j)
if(ar[i][j].property == '0') {
if(ar[i][j].access == false)
cout << "@";
else
cout << "_";
}
else
cout << "#";
cout << endl;
}
}
//随机产生迷宫
void Readfile_rand(unsigned int seed)
{
//初始化存储迷宫信息的数组
for(int i = 0;i < L+2;++i)
for(int j = 0;j < L+2;++j) {
ar[i][j].property = 1;
ar[i][j].access = false;
}
srand(unsigned(seed));
for(int i = 1;i < L+1;++i)
for(int j = 1;j < L+1;++j) {
ar[i][j].x = 0;
ar[i][j].y = 0;
ar[i][j].property = (rand())%2 + '0';
}
ar[1][1].property = '0';
}
void Readfile()
{
//初始化存储迷宫信息的数组
for(int i = 0;i < L+2;++i)
for(int j = 0;j < L+2;++j) {
ar[i][j].property = '1';
ar[i][j].access = false;
}
fstream ifile("maze.txt");
string data;
int i = 1,j;
while(getline(ifile,data)) {
j = 1;
for(char c : data) {
ar[i][j].x = 0;
ar[i][j].y = 0;
if(c == '@')
ar[i][j++].property = '0';
else
ar[i][j++].property = '1';
}
i++;
}
ifile.close();
}
//非递归遍历迷宫找到出路
struct data{
int x;
int y;
};
int Findway()
{
list lst;
lst.push_back({1,1});
ar[1][1].access = true;
while(ar[L][L].access == false && !lst.empty()) {
auto p = lst.begin();
int x = p->x;
int y = p->y;
if(ar[x][y-1].property == '0' && ar[x][y-1].access == false) {
lst.push_back({x,y-1});
ar[x][y-1].x = x;
ar[x][y-1].y = y;
ar[x][y-1].access = true;
}
if(ar[x][y+1].property == '0' && ar[x][y+1].access == false) {
lst.push_back({x,y+1});
ar[x][y+1].x = x;
ar[x][y+1].y = y;
ar[x][y+1].access = true;
}
if(ar[x-1][y].property == '0' && ar[x-1][y].access == false) {
lst.push_back({x-1,y});
ar[x-1][y].x = x;
ar[x-1][y].y = y;
ar[x-1][y].access = true;
}
if(ar[x+1][y].property == '0' && ar[x+1][y].access == false) {
lst.push_back({x+1,y});
ar[x+1][y].x = x;
ar[x+1][y].y = y;
ar[x+1][y].access = true;
}
lst.pop_front();
}
//输出迷宫出路路径
if(ar[L][L].access == true) {
for(int i = 1;i < L+1;++i)
for(int j = 1;j < L+1;++j)
ar[i][j].access = false;
int i = L,j = L;
while(1) {
ar[i][j].access = true;
int x = ar[i][j].x;
int y = ar[i][j].y;
i = x;
j = y;
if(i == 1 && j == 1)
break;
}
ar[1][1].access = true;
return 1;
}
else
return 0;
}
void Print_alone(int x,int y,char diff)
{
for(int i = 1;i < L+1;++i) {
for(int j = 1;j < L+1;++j) {
if(i >= x+'a'-diff && i <= x-'a'+diff && j >= y+'a'-diff && j <= y-'a'+diff) {
if(ar[i][j].access == true)
cout << "_";
else {
if(ar[i][j].property == '0')
cout << "@";
else
cout << "#";
}
}
else
cout << " ";
}
cout << endl;
}
}
void Stand_Alone(char diff)
{
//从0,0开始
ar[0][0].access = true;
int x = 1;
int y = 1;
char choice;
Print_alone(1,1,diff);
while(ar[L][L].access != true && (choice = getch())) {
if(choice == 65 && x-1 >= 1 && ar[x-1][y].property == '0') {
ar[x][y].access = false;
x -= 1;
}
if(choice == 66 && x+1 <= L && ar[x+1][y].property == '0') {
ar[x][y].access = false;
x += 1;
}
if(choice == 67 && y+1 <= L && ar[x][y+1].property == '0') {
ar[x][y].access = false;
y += 1;
}
if(choice == 68 && y-1 >= 1 && ar[x][y-1].property == '0') {
ar[x][y].access = false;
y -= 1;
}
if(choice == 't') {
system("clear");
Init();
Findway();
Print();
}
ar[x][y].access = true;
system("clear");
Print_alone(x,y,diff);
cout << x << "," << y << " " << "终点:" << L << "," << L << endl;
cout << "t.提示" << endl;
}
system("clear");
Print();
cout << "成功！！！" << endl;
}
int main()
{
char choice;
cout << "a.单机模式"<< endl;
cout << "q.退出" << endl;
srand(time(NULL));
while(cin >> choice && choice != 'q') {
switch(choice) {
case 'a':
//随机生成可以通过的迷宫
for(int i = rand()%1000;i < 10000;++i) {
Init();
Readfile_rand(i);
if(Findway() == 1) {
break;
}
}
Init();
char diff;
cout << "选择难度(a.困难 b.中等 c.简单)" << endl;
cin >> diff;
Stand_Alone(diff);
break;
}
cout << "a.单机模式" << endl;
cout << "q.退出" << endl;
}
return 0;
}