迷宫问题(C语言实现)

版权声明:本文为博主原创文章,遵循 CC 4.0 by-sa 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/weixin_42250655/article/details/81294176

问题描述

定义一个二维数组:

int maze[5][5] = {

0, 1, 0, 0, 0,

0, 1, 0, 1, 0,

0, 0, 0, 0, 0,

0, 1, 1, 1, 0,

0, 0, 0, 1, 0,

};

它表示一个迷宫,其中的1表示墙壁,0表示可以走的路,只能横着走或竖着走,不能斜着走,要求编程序找出从左上角到右下角的最短路线。
Input
一个5 × 5的二维数组,表示一个迷宫。数据保证有唯一解。
Output
左上角到右下角的最短路径,格式如样例所示。
Sample Input
0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0

思路(DFS寻路)

  • 首先将迷宫存在一个二位数组中,然后遍历数组,遇到1则改变方向,遇到0接着向下走,将此点存入栈中,如果无路,则返回上一结点,将此结点移出栈,并将此点的数组值更改为1,防止死循环。直至找到出口。
struct path
{
	int x;            //横座标
	int y;  		  //纵座标
	struct path *next;
};

typedef struct Link
{
	struct path *head;
}link;

//此处已将队列更换为栈,因为之前的队列删除尾节点会将队列结构完全破坏,而造成队列不能正确工作,sorry!!!


//模拟为栈
void push(link *que, int x, int y)
{
	struct path *p;
	p = (struct path*)malloc(sizeof(struct path));
	p->x = x;
	p->y = y;
	p->next = que->head;;
	que->head = p;
/*
	que->rear->next = p;
	que->rear = p;
	que->rear->next = NULL;
*/
}

void pop(link *que)
{
	//如果不合适将刚入栈的节点删除
	que->head = que->head->next;  //删除栈的头结点就会变得很简单
}

//此处已经不需要这个函数,太多余!
/*
void pop2(link *que, int *x, int *y)
{
	struct path *temp;
	temp = que->head->next;
	que->head->next = temp->next;      //将temp结点出队
	*x = temp->x;
	*y = temp->y;
	free(temp);
}
*/
  • 写好队列的实现后,我们来实现对迷宫的分析,此处没有更正,递归是正确的!
/*用递归对迷宫进行遍历*/
void r(int a[5][5], int x, int y, link *que)
{   
    if( x < 5 && x >= 0 && y < 5 && y >= 0)
    {
        if(x == 4 && y == 4)  //到达迷宫出口
            return;
        /*首先判断右边下一个点是否可以走*/
        if(a[x][y + 1] == 0 && (y + 1) < 5) //此处为了防止数组越界
        {
            y++;
            push(que, x, y);   //可以走就将该结点入队
            r(a, x, y, que);   //递归下一个座标
            return;
        }
        /*上一个条件不满足就判断其向下是否能走*/
        if(a[x + 1][y] == 0 && (x + 1) < 5)//防止数组越界
        {
            x++;
            push(que, x, y);       //入队
            r(a, x, y, que);       //递归
            return;
        }
        /*无路可走,就返回上一个座标*/
        if(a[x - 1][y] == 0 && x - 1 >= 0)
        {
            a[x][y] = 1; //并将该点设为1,防止死循环
            pop(que);    //将该座标移出队列
            x--;
            r(a, x, y, que);
            return;
		 }
        if(a[x][y - 1] == 0 && y - 1 >= 0)
        {
            a[x][y] = 1;
            pop(que); //移出队列
            y--;
            r(a, x, y, que);
            return;
        }
    }
}   

总结

1、用到递归和栈的思想,将迷宫当作矩阵,遍历,判断下一个座标是否可以通过,如果不行则换方向,如果无路可走则退格。
2、自己今天有很多思想没有思考到,写一篇博客加深一下印象。

博客如有错误,欢迎大家评论指出,一起探讨一起进步。感谢!!

完整代码

#include<stdio.h>
#include<stdlib.h>

//迷宫问题

struct path
{
	int x;            //横座标
	int y;  		  //纵座标
	struct path *next;
};

typedef struct Link
{
	struct path *head;
}link;


//模拟为栈
void push(link *que, int x, int y)
{
	struct path *p;
	p = (struct path*)malloc(sizeof(struct path));
	p->x = x;
	p->y = y;
	p->next = que->head;;
	que->head = p;
/*
	que->rear->next = p;
	que->rear = p;
	que->rear->next = NULL;
*/
}

void pop(link *que)
{
	//如果不合适将刚入栈的节点删除
	que->head = que->head->next;
}

/*
void pop2(link *que, int *x, int *y)
{
	struct path *temp;
	temp = que->head->next;
	que->head->next = temp->next;      //将temp结点出队
	*x = temp->x;
	*y = temp->y;
	free(temp);
}
*/

void r(int a[5][5], int x, int y, link *que)
{
	if( x < 5 && x >= 0 && y < 5 && y >= 0)
	{
		if(x == 4 && y == 4)
			return;
		if(a[x][y + 1] == 0 && (y + 1) < 5)
		{
			y++;
			push(que, x, y);
			r(a, x, y, que);
			return;
		}
	    if(a[x + 1][y] == 0 && (x + 1) < 5)
		{
			x++;
			push(que, x, y);
			r(a, x, y, que);
			return;
		}
	    if(a[x - 1][y] == 0 && x - 1 >= 0)
		{
			a[x][y] = 1;
			pop(que);
			x--;
			r(a, x, y, que);
			return;
		}
	    if(a[x][y - 1] == 0 && y - 1 >= 0)
		{
			a[x][y] = 1;
			pop(que);
			y--;
			r(a, x, y, que);
			return;
		}
	}
}

int main(void)
{
	int a[5][5];
	int i, j;
	int x, y;
	for(i = 0; i < 5; i++)
	{
		for(j = 0; j < 5; j++)
		{
			scanf("%d", &a[i][j]);
		}
	}
	link *top, *temp;
	top = temp = (link *)malloc(sizeof(link));
	top->head = (struct path *)malloc(sizeof(struct path));
	r(a, 0, 0, top);
	printf("(0, 0)\n");
	//此处数组是为了存储路径,因为使用的是栈结构,所以存储的路径必然是倒序!
	int PATH[25] = {0};
	int count = 0;

	//将栈倒序的路径存储进数组中,二维数组太占用空间所以此处我们使用一维数组,并使用数学方法存储!!
	while(top->head->next != NULL)
	{
		PATH[count] = top->head->x *10 + top->head->y;
		++count;
		top->head = top->head->next;
	}
	for(i = count - 1; i >= 0; --i)
	{	
		int num_x = PATH[i] / 10;  //从数据中提取出X
		int num_y = PATH[i] % 10; //从数组中提取出Y
		//打印路径
		printf("(%d, %d)\n", num_x, num_y);
	}
	return 0;
}                                                                                                         
展开阅读全文

没有更多推荐了,返回首页