c语言-智障走迷宫

题目

最近在学习数据结构，老师给了一个这样的题。让我们使用c语言走迷宫。猛地一看好像有点迷。那就继续往下喽。

思路

一种比较智障的办法就是我们就让人一直朝着一个方向走，当无路可走时，我们就往后退。
比如我们一直往下走，当无路可走时，就往后退，退到有多个选择的路口，

然后我们将这条死路封住，继续按照（下、右、上、左）的顺序，只要不是思路我们就一直往下走，直到找到出口，或是遇到死路。

那么有一个问题就是，我们如何判断是否是死路呢？

观察一下，当我们走到死胡同时，我们的下一步只有一个选择，比如：

在如图位置时，我们只能选择往上走，故我们判断这条路为死路。因此我们应该回到上一个路口，并把这条死路给堵住。如下：

这样我们又可以继续走了，最终我们找到出口。

再整理下思路。我们就让它随意的走，要求不能走重复的地方，如果是死路我们就回到路口，并把死路给封上。
接下来就上代码吧。

代码

这是我们的结果，我用符号简单输出了一个图。其中"#“表示墙壁，”$“表示终点，”*"表示足迹。
吐槽下，这图好丑。哈哈。
不多说了，上代码。

//the solution of migong
#include<stdio.h>
#include<malloc.h>
#define max_size 100

typedef struct
{
	int *base;
	int *top;
	int sq_stack_size;
}SqStack;

//初始化 
void init_Stack(SqStack *p)
{
	
	p->base=(int *)malloc(sizeof(int)*max_size);
	
	p->top=p->base;
	p->sq_stack_size=max_size;
	
}

//入栈 
int pop_Stack(SqStack *p,int mat[2])
{
	if((p->top-p->base)==max_size)
	{
		return 0;
	}
	*(p->top)=mat[0];
	p->top++;
	*(p->top)=mat[1];
	p->top++;
}

//出栈 
int out_Stack(SqStack *p)
{
	if((p->top-p->base)==0)
	{
		return 0;
	}
	printf("路线坐标：");
	printf("%d",*(p->top-2));
	
	printf("%d",*(p->top-1));
	printf("\n");
	p->top=p->top-2;
	return 1;
}

//出栈到指定位置
void out_Stack_p(SqStack *p,int *position)
{
	p->top=position;
}

//查看栈顶元素
int look_Stack_top(SqStack *p,int top_value[2])
{
	top_value[0]=*(p->top-2);
	top_value[1]=*(p->top-1);
	
}

//创建迷宫矩阵 
void creat_migong(int A[10][10])
{
	int i,j;
	//初始化 全0
	for(i=0;i<10;i++)
	{
		for(j=0;j<10;j++)
		{
			A[i][j]=0;
		}
	 }
	
	
	//创造迷宫墙    1 表示墙      0 表示可走    2 起点    3 终点  走过的路用 2 标记  
	for(i=0;i<10;i++)
	{
		A[0][i]=1;
	}
	for(i=0;i<10;i++)
	{
		A[9][i]=1;
	}
	for(i=1;i<9;i++)
	{
		A[i][0]=1;
		A[i][9]=1;
	}
	A[1][3]=1;
	A[1][7]=1;
	A[2][3]=1;
	A[2][7]=1;
	A[3][5]=1;
	A[3][6]=1;
	A[4][2]=1;
	A[4][3]=1;
	A[4][4]=1;
	A[5][4]=1;
	A[6][2]=1;
	A[7][2]=1;
	A[6][6]=1;
	A[7][3]=1;
	A[7][4]=1;
	A[7][6]=1;
	A[7][7]=1;
	A[8][1]=1;
	
	
	//起点
	A[1][1]=2;
	//终点 
	A[8][8]=3;
}

output_A(int A[10][10])
{
	int i,j;
	for(i=0;i<10;i++)
	{
		for(j=0;j<10;j++)
		{
			if(A[i][j]==1)
			{
				printf("#");
			}
			else if(A[i][j]==0)
			{
				printf(" ");
			}
			else if(A[i][j]==2)
			{
				printf("*");
			}
			else
			{
				printf("$");
			}
		}
		printf("\n");
	}
}

//判断当前位置有几个选择方向 
int how_many_choice(int A[10][10],int now_pos[2])
{
	int choices=0;
	if(A[now_pos[0]+1][now_pos[1]]==0||A[now_pos[0]+1][now_pos[1]]==3)
	{
		choices++;
	}
	if(A[now_pos[0]][now_pos[1]+1]==0||A[now_pos[0]][now_pos[1]+1]==3)
	{
		choices++;
	}
	if(A[now_pos[0]-1][now_pos[1]]==0||A[now_pos[0]-1][now_pos[1]]==3)
	{
		choices++;
	}
	if(A[now_pos[0]][now_pos[1]-1]==0||A[now_pos[0]][now_pos[1]-1]==3)
	{
		choices++;
	}
	
	
	return choices;
	
	
	
}

//主函数 
int main()
{
	int A[10][10];
	int now_pos[2];
	int choice;
	int *p;//代表分散节点
	int feng_d[2];
	int i;
	creat_migong(A);//创造迷宫 
	
	output_A(A);//输出迷宫 
	
	SqStack *res;//结果栈存储 
	res=(SqStack *)malloc(sizeof(int)*5);//申请空间 
	init_Stack(res);//初始化 
	
	SqStack *node;//路口节点存储
	node= (SqStack *)malloc(sizeof(int)*5);//申请空间 
	init_Stack(node);//初始化 
	
	int origin[2]={1,1};//起点 
	pop_Stack(res,origin);//起点入栈 
	
	
	
	printf("开始!\n");
	for(i=0;i<40;i++)
	{
		output_A(A);//输出迷宫 
		//查看当前位置 
		look_Stack_top(res,now_pos);
		//当前位置记录足迹
		A[now_pos[0]][now_pos[1]]=2;
		
		
		
		if(A[now_pos[0]+1][now_pos[1]]==0||A[now_pos[0]+1][now_pos[1]]==3)
		{
			
			now_pos[0]=now_pos[0]+1;
			
			pop_Stack(res,now_pos);
			choice=how_many_choice(A,now_pos);
			
			//是否为终点 
			if(A[now_pos[0]][now_pos[1]]==3)
			{
				printf("结束！\n");
				break;
			}
			
			//是否为路口 
			if(choice>=2)
			{
				*(node->top)=(res->top-res->base);
				node->top++;
			}
			//是否是死路 
			else if(choice==0)
			{
				p=*(node->top-1)+res->base;
				node->top--;
				out_Stack_p(res,p);
				look_Stack_top(res,now_pos);
			}
			
		}
		else if(A[now_pos[0]][now_pos[1]+1]==0||A[now_pos[0]][now_pos[1]+1]==3)
		{
			now_pos[1]=now_pos[1]+1;
			pop_Stack(res,now_pos);
			choice=how_many_choice(A,now_pos);
			
			//是否为终点 
			if(A[now_pos[0]][now_pos[1]]==3)
			{
				printf("结束！\n");
				break;
			}
			
			//是否为路口 
			if(choice>=2)
			{
				*(node->top)=(res->top-res->base);
				node->top++;
			}
			//是否是死路 
			else if(choice==0)
			{
				p=*(node->top-1)+res->base;
				node->top--;
				out_Stack_p(res,p);
				look_Stack_top(res,now_pos);
			}
			
		}
		else if(A[now_pos[0]-1][now_pos[1]]==0||A[now_pos[0]-1][now_pos[1]]==3)
		{
			now_pos[0]=now_pos[0]-1;
			pop_Stack(res,now_pos);
			choice=how_many_choice(A,now_pos);
			//是否为终点 
			if(A[now_pos[0]][now_pos[1]]==3)
			{
				printf("结束！\n");
				break;
			}
			
			//是否为路口 
			if(choice>=2)
			{
				*(node->top)=(res->top-res->base);
				node->top++;
			}
			//是否是死路 
			else if(choice==0)
			{
				p=*(node->top-1)+res->base;
				node->top--;
				out_Stack_p(res,p);
				look_Stack_top(res,now_pos);
			}
			
		}
		else if(A[now_pos[0]][now_pos[1]-1]==0||A[now_pos[0]][now_pos[1]-1]==3)
		{
			now_pos[1]=now_pos[1]-1;
			pop_Stack(res,now_pos);
			choice=how_many_choice(A,now_pos);
			//是否为终点 
			if(A[now_pos[0]][now_pos[1]]==3)
			{
				printf("结束！\n");
				break;
			}
			
			//是否为路口 
			if(choice>=2)
			{
				*(node->top)=(res->top-res->base);
				node->top++;
			}
			//是否是死路 
			else if(choice==0)
			{
				p=*(node->top-1)+res->base;
				node->top--;
				out_Stack_p(res,p);
				look_Stack_top(res,now_pos);
			}
			
		}
		else if(A[now_pos[0]][now_pos[1]]==3)
		{
			printf("结束!!\n");
			break;
		}
		
		
		
	}
	
	while(out_Stack(res))
	{
		continue;
	}
	output_A(A);
	return 0;
	
	
}

这好像有点长，应该是可以简单点的，不过既然是智障走迷宫，就让它看起来智障点吧。其实我们也可以使用强化学习的方法来做，后续会更新的呦。欢迎关注我。