在学校项目中,我们通过程序参数解决了迷宫问题。为此,我们需要使用深度优先搜索算法。
我已经能够找到DFS算法的伪代码,甚至可以使用C重新编码。算法能够找到退出,但是现在我正在寻找一种方法来获取路径。开始到迷宫的尽头。
每个迷宫的开头是左上角,而末端是右下角。
初始迷宫(X =墙壁; * =自由空间):
*****XX****X********XXXX
XX******XX***XXXXX***XXX
XX***XXXX**XXXXX****XXXX
XX***XXXXXXXXXXXXXX****X
*****XXXXXX****XX***XXXX
XX*************XXXX*****
解决迷宫(o =从开始到结束的路径):
oooooXXooooXooooooooXXXX
XX**ooooXXoooXXXXX*o*XXX
XX***XXXX**XXXXX***oXXXX
XX***XXXXXXXXXXXXXXo***X
*****XXXXXX****XX**oXXXX
XX*************XXXXooooo
以下是我迄今为止能够制作的代码:
#include "../include/depth.h"
static t_bool stack_push(t_list **stack, int x, int y)
{
t_cell *cell;
if (!(cell = malloc(sizeof(t_cell))))
return (FALSE);
cell->coord.x = x;
cell->coord.y = y;
if (!my_list_push(stack, cell))
{
free(cell);
return (FALSE);
}
return (TRUE);
}
static t_bool is_colored(const t_list *colored, int x, int y)
{
while (colored != NULL)
{
if (((t_cell *) colored->elm)->coord.x == x &&
((t_cell *) colored->elm)->coord.y == y)
return (TRUE);
colored = colored->next;
}
return (FALSE);
}
static t_bool push_edges(t_map *map, t_stack *stack, int x, int y)
{
if (x - 1 >= 0 && !is_colored(stack->colored, x - 1, y))
stack_push(&stack->stack, x - 1, y);
if (x + 1 < map->sz.x && !is_colored(stack->colored, x + 1, y))
stack_push(&stack->stack, x + 1, y);
if (y - 1 >= 0 && !is_colored(stack->colored, x, y - 1))
stack_push(&stack->stack, x, y - 1);
if (y + 1 < map->sz.y && !is_colored(stack->colored, x, y +1))
stack_push(&stack->stack, x, y + 1);
return (TRUE);
}
static t_bool exit_properly(t_stack *stack, void *curr)
{
my_list_destroy(&stack->stack, LIST_FREE_PTR, NULL);
my_list_destroy(&stack->colored, LIST_FREE_PTR, NULL);
free(curr);
return (TRUE);
}
t_bool depth(t_map *map)
{
t_stack stack;
t_cell *curr;
stack.colored = stack.stack = NULL;
stack_push(&stack.stack, MAP_START_X, MAP_START_Y);
while (stack.stack != NULL)
{
curr = stack.stack->elm;
my_list_pop(&stack.stack, &stack.stack);
if (curr->coord.x == map->sz.x - 1 &&
curr->coord.y == map->sz.y - 1)
return (exit_properly(&stack, curr));
if (!is_colored(stack.colored, curr->coord.x, curr->coord.y))
{
stack_push(&stack.colored, curr->coord.x, curr->coord.y);
push_edges(map, &stack, curr->coord.x, curr->coord.y);
}
free(curr);
}
return (TRUE);
}
初始算法:
1 procedure DFS-iterative(G,v):
2 let S be a stack
3 S.push(v)
4 while S is not empty
5 v = S.pop()
6 if v is not labeled as discovered:
7 label v as discovered
8 for all edges from v to w in G.adjacentEdges(v) do
9 S.push(w)
感谢。
注意:t_list类型包含通用链表。
答案 0 :(得分:1)
假设您的输入数据采用矩阵形式:
使用以下定义创建结构
struct parent {
int x, y;
};
使用上述结构作为数据类型创建一个二维矩阵,并且与输入矩阵具有相同的维数。
struct parent ** parent_info = (struct parent **)malloc(ROW_SIZE * sizeof(struct parent* ));
int i = 0;
for (i = 0; i < ROW_SIZE; i++) {
parent_info[i] = (struct parent *)malloc(COLUMN_SIZE * sizeof(struct parent));
}
其中ROW)_SIZE和COLUMN_SIZE分别是输入矩阵中的行数和列数。
现在每次在堆栈中推送新的图形节点(矩阵单元格)(伪代码行9)时,在parent_info矩阵中设置父细节(例如,在伪代码中,设置&#39; v&#39; as是&#39;的父母。
例如,您从(0,0)移动到(0,1)然后设置
parent_info[0][1].x = 0;
parent_info[0][1].y = 0;
最后,为了检索路径,递归地遵循parent_info矩阵中的坐标,从迷宫终点的父坐标开始。