迷宫最短路径（DFS）

　　前面的《顺序栈和迷宫求解》中已经提到，用栈DFS的方法求得的路径是非最短路径。如果要求得最短路径需要进一步处理。

　　1. 增加一个全局数组（PrintType **g_MazeFootPrint），用来存放到某个节点的最短路径长度（shorteststep）和到达该节点的上一个节点位置（parent）。

typedef struct
{
    PosType parent;
    int shorteststep;
}PrintType;
PrintType **g_MazeFootPrint;

　　2. 修改“是否可走”的条件，即修改如下函数：

Status MazePass(PosType pos, int x, int y)
{
    if(pos.x>=0 && pos.y>=0 && pos.x<g_m && pos.y<g_n 
    && (g_MazeMap[pos.y][pos.x] == 0 || g_MazeFootPrint[y][x].shorteststep + 1 < g_MazeFootPrint[pos.y][pos.x].shorteststep))
    {
        return OK;
    }
    return ERROR;
}

　　增加了一个判断条件，当到达目前节点的路径小于原有路径时，可重走此节点。同时修改到达当前节点的路径大小。

　　3. 当找到出口时不立即返回，而继续搜索；

　　代码如下：

　define.h

// define.h
#ifndef __MENGQL_DEFINE__
#define __MENGQL_DEFINE__

#define C_LOG_DBG(format, ...) 
//printf("[%s@%s,%d] " format ,__FUNCTION__, __FILE__, __LINE__, ##__VA_ARGS__);
#define C_LOG_ERR(format, ...) printf("[%s@%s,%d] " format ,__FUNCTION__, __FILE__, __LINE__, ##__VA_ARGS__);
typedef enum EStatus {ERROR, OK} Status;

#endif

　SqStack.h

// SqStack.h
#ifndef __SQ_STACK_H__
#define __SQ_STACK_H__
#include "define.h"

typedef struct
{
    int x;
    int y;
}PosType;

typedef struct
{
    PosType seat;
    int di;
}SElemType;

#define STACK_INIT_SIZE 100
typedef struct 
{
    SElemType* base;
    SElemType* top;
    int stacksize;
}SqStack;

extern Status InitStack(SqStack *S);
extern Status GetTopStack(SqStack S, SElemType *e);
extern Status PushStack(SqStack *S, SElemType e);
extern Status PopStack(SqStack *S, SElemType *e);
extern Status StackEmpty(SqStack *S);
extern Status DestoryStack(SqStack *S);
#endif

 MazeShortPath.c

// MazeShortPath.c
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include "define.h"
#include "SqStack.h"


typedef struct
{
    PosType parent;
    int shorteststep;
}PrintType;

PrintType **g_MazeFootPrint;
int **g_MazeMap;
int g_m, g_n;//g_m:列数 g_n:行数

#define FAILEDPOS 5
#define FOOTPRINT 2

void MazePrintRes(PosType *start, PosType *end)
{
    PosType p;
    if(end->x == start->x && end->y == start->y)
    {
        printf("[%d, %d]\n", start->x, start->y);
        return;
    }
    else
    {
        p.x = g_MazeFootPrint[end->y][end->x].parent.x;
        p.y = g_MazeFootPrint[end->y][end->x].parent.y;
        MazePrintRes(start, &p);
        printf("[%d, %d]\n", end->x, end->y);
        return;
    }
}
Status MazePass(PosType pos, int x, int y)
{
    if(pos.x>=0 && pos.y>=0 && pos.x<g_m && pos.y<g_n 
    && (g_MazeMap[pos.y][pos.x] == 0 || g_MazeFootPrint[y][x].shorteststep + 1 < g_MazeFootPrint[pos.y][pos.x].shorteststep))
    {
        return OK;
    }
    return ERROR;
}
void MazeFootPrint(PosType pos)
{
    g_MazeMap[pos.y][pos.x] = FOOTPRINT;
}
void MarkPrint(PosType pos)
{
    g_MazeMap[pos.y][pos.x] = FAILEDPOS;
}
void NextPos(PosType *pos, int di)
{
    switch(di)
    {
        case 1:
            pos->y = pos->y-1;
            break;
        case 2:
            pos->x = pos->x-1;
            break;
        case 3:

            pos->y = pos->y+1;
            break;
        case 4:
            pos->x = pos->x+1;
            break;
        defult:
            break;
    }
}
Status MazeShortPath(PosType *start, PosType *end)
{
    SqStack S;
    int nCurStep = 0;
    PosType curPos;
    SElemType e;
    int nPrevX = 0;
    int nPrevY = 0;
    Status ERes = ERROR;
    
    curPos.x = start->x;
    curPos.y = start->y;
    if(InitStack(&S) != OK)
    {
        return ERROR;
    }
    do
    {
        if(MazePass(curPos, nPrevX, nPrevY) == OK)
        {
            g_MazeFootPrint[curPos.y][curPos.x].shorteststep = g_MazeFootPrint[nPrevY][nPrevX].shorteststep + 1;
            g_MazeFootPrint[curPos.y][curPos.x].parent.x = nPrevX;
            g_MazeFootPrint[curPos.y][curPos.x].parent.y = nPrevY;
            
            e.di = 1;
            e.seat.x = curPos.x;
            e.seat.y = curPos.y;
            
            MazeFootPrint(curPos);
            PushStack(&S, e);
            
            if(curPos.x == end->x && curPos.y == end->y)
            {
                ERes = OK;
            }
            nPrevX = e.seat.x;
            nPrevY = e.seat.y;
            NextPos(&curPos, e.di);
        }
        else
        {
            if(StackEmpty(&S) != OK)
            {
                PopStack(&S, &e);
                while(e.di>=4 && StackEmpty(&S)!=OK)
                {
                    MarkPrint(e.seat);
                    PopStack(&S, &e);
                    
                }
                if(e.di < 4)
                {
                    e.di++;
                    PushStack(&S, e);
                    nPrevX = e.seat.x;
                    nPrevY = e.seat.y;
                    NextPos(&e.seat, e.di);
                    
                    curPos.x = e.seat.x;
                    curPos.y = e.seat.y;
                }
            }
        }
    }while(StackEmpty(&S) != OK);
    DestoryStack(&S);
    return ERes;
}
int main()
{
    PosType start;
    PosType end;
    int i, j;
    
    scanf("%d %d", &g_m, &g_n);
    start.x = 0;
    start.y = 0;
    end.x = g_m-1;
    end.y = g_n-1;
    
    g_MazeMap = (int**)malloc(g_m*sizeof(int*));
    g_MazeFootPrint = (PrintType**)malloc(g_m*sizeof(PrintType*));
    for(i=0; i<g_m; ++i)
    {
        g_MazeMap[i] = (int*)malloc(g_n*sizeof(int));
        g_MazeFootPrint[i] = (PrintType*)malloc(g_n*sizeof(PrintType));
    }
    
    for(i=0; i<g_m; ++i)
    {
        for(j=0; j<g_n; ++j)
        {
            scanf("%d", &g_MazeMap[i][j]);
        }
    }
    if(MazeShortPath(&start, &end) == OK)
    {
        MazePrintRes(&start, &end);
    }
    else
    {
        printf("no way!\n");
    }
    return 0;
}