数据结构---多出口迷宫找出一条最短路径

前面我们实现了基础版本的迷宫求解，只有一条路径。现在如果有多个出口，我们该如何去找到一条最短的路径。

我们先来思考一下我们是如何在一个数组里找最小值的？
有下面一个数组：

我们可以先把第一个数设为最小值，然后遍历数组，拿它和后面的元素进行比较，把两个数中较小的赋给min,直到遍历完整个数组，min中就是数组中的最小值。

同样的，找最短路径也是一样的思路。我们可以定义两个栈，一个cur_path保存当前路径，一个short_path保存最短路径，每次找到一条路径，将它保存在cur_path里，并和short_path进行比较，将两条路径中较短的路径保存在short_path中，最后打印short_path的内容。

可以看出，黄色圈出来的就是最短路径。
步骤也是和前面大体一致，只是加了一个当前路径cur_path和最短路径short_path的比较,代码中有详解，大家可以参考一下.
话不多说，直接上代码:

//先对迷宫初始化
void MazeShortPathInit(Maze* maze)
{
    int map[MAX_ROW][MAX_COL] = {
        {0,1,0,0,0,0},
        {0,1,1,1,0,0},
        {0,1,0,1,0,0},
        {1,1,0,1,1,1},  
        {0,1,1,0,0,0},
        {0,0,1,0,0,0},
    };
    size_t i = 0;
    for( ;i < MAX_ROW;i++)
    {
        size_t j = 0;
        for( ;j < MAX_COL;j++)
        {
            maze->map[i][j] = map[i][j];
        }
    }
    return;
}
//遍历所有的路径，然后从其中找出一条最短路径
//实现递归版本
void GetShortPath(Maze* maze,Point entry)
{
    //保存着当前路径
    SeqStack cur_path;
    //保存最短路径
    SeqStack short_path;

    SeqStackInit(&cur_path);
    SeqStackInit(&short_path);
    _GetShortPath(maze,entry,entry,&cur_path,&short_path);
    //打印栈里面的内容（通常意义下，栈是不允许遍历的，但是这里仅仅用于调试）
    SeqStackPrintDebug(&short_path,"最短路径是：");
}

void _GetShortPath(Maze* maze,Point cur,Point entry,SeqStack* cur_path,SeqStack* short_path)
{
    //1.判断当前点是否能落脚
    if( !CanStay(maze,cur))
    {
        return;
    }
    //2.如果能落脚，标记当前点并且入栈到cur_path
    Mark(maze,cur);
    SeqStackPush(cur_path,cur);
    //3.判断当前点是否为出口
    if(IsExit(maze,cur,entry))
    {
    //  如果是出口，说明找到了一条路径，拿当前路径和short_path中的路径比较
    //  a)如果当前路径比short_path中路径短或者short_path为空，就用当前路径替换short_path
    //  b)如果当前路径没有short_path中路径短，尝试去找其他的路经（进行回溯），出栈cur_path的栈顶元素
        printf("找到了一条路径\n");
        if(cur_path->size < short_path->size || short_path->size == 0)
        {
            SeqStackAssgin(cur_path,short_path);
        }
        SeqStackPop(cur_path);
        return;
    }
    //4.如果当前点不是出口，尝试顺时针去探测其他四个方向
    Point up = cur;
    up.ROW -= 1;
    _GetShortPath(maze,up,entry,cur_path,short_path);

    Point right = cur;
    right.COL += 1;
    _GetShortPath(maze,right,entry,cur_path,short_path);

    Point down = cur;
    down.ROW += 1;
    _GetShortPath(maze,down,entry,cur_path,short_path);

    Point left = cur;
    left.COL -= 1;
    _GetShortPath(maze,left,entry,cur_path,short_path);
    //5.如果四个方向都递归的探测完了，就可以进行出栈(cur_path)，回溯到上一个点
    SeqStackPop(cur_path);
}

这里用到的辅助函数打印栈信息SeqStackPrintDebug（）和栈替换SeqStackAssgin（）如下，而判断当前点能不能落脚CanStay（）函数，判断是否是出口IsExit（）函数和标记Mark（）函数在之前博客中（基础版迷宫求解）写过，这里就不做具体介绍。

void SeqStackAssgin(SeqStack* from,SeqStack* to)
{
    //为了保证to里面的内存能够足够的容纳from中的元素
    //采用以下策略：
    //1.释放to中的原有内存
    SeqStackDestroy(to);
    //2.根据from中的元素个数，确定内存申请的大小
    to->size = from->size;
    to->capacity = from->capacity;
    //3.给to申请一个足够的内存
    to->data = (SeqStackType*)malloc(to->capacity*sizeof(SeqStackType));
    //4.最后进行数据的拷贝
    size_t i = 0;
    for( ;i < from->size;i++)
    {
        to->data[i] = from->data[i];
    }
    return;
}
void SeqStackPrintDebug(SeqStack* stack,char* msg)
{
    printf("[%s]\n",msg);
    size_t i = 0;
    for( ;i < stack->size;i++)
    {
        printf("(%d,%d)\n",stack->data[i].ROW,stack->data[i].COL);
    }
    printf("\n");
}

结果如下图：