以矩阵形式表示迷宫。请自行脑补一个二维矩阵。

具体思路：如果当前位置的三个方向（除了来时的方向）至少有一个方向可通，则将此点的坐标个可通的方向存入栈顶，如此重复，直到出口；如果当前位置的三个方向都不可通，则表明从当前位置无法再往前走，此时需要将栈顶元素出栈（当前位置的坐标），再沿原路返回到前一个结点，从该点看是否有其他的可行方向，如果也没有，则再往回退一步；如果有，则沿着新的方向向前探索。

#include <stdio.h>
#include <stdlib.h>
//#include "stdirectiono.h"
#define H 6
#define W 6
#define maximum 20
int map[H][W]=            //二维矩阵，0代表可以通过，1代表是墙壁
{
    {1,1,1,1,1,1},
    {1,0,0,0,1,1},
    {1,0,1,0,0,1},
    {1,0,0,0,1,1},
    {1,1,0,0,0,1},
    {1,1,1,1,1,1},
};
int top=-1;
int mindirections=maximum;     //最短路径长度
struct
{
    int i;
    int j;
    int direction;
}Stack[maximum],Path[maximum];
void maze()
{
    int count=-1;
    int i,j,direction,find;
    top++;
    Stack[top].i=1;Stack[top].j=1;
    Stack[top].direction=-1;
    map[1][1]=-1;
    while(top>-1)
    {
        i=Stack[top].i;j=Stack[top].j;
        direction=Stack[top].direction;
        if(i==H-2 && j==W-2)
        {
            int k;
            for(k=0;k<=top;k++)
            {
                printf("[%d,%d]",Stack[k].i,Stack[k].j);
                if((k+1)%5==0)
                    printf("\n");
            }
            printf("\n");
            if(top+1<mindirections)
            {
                for(k=0;k<=top;k++)
                    Path[k]=Stack[k];
                mindirections=top+1;
            }
            map[Stack[top].i][Stack[top].j]=0;
            top--;
            i=Stack[top].i;
            j=Stack[top].j;
            direction=Stack[top].direction;
        }
        find=0;
        while(direction<4&&find==0)
        {
            direction++;
            switch(direction)
            {
                case  0:i=Stack[top].i-1;j=Stack[top].j;break;
                case  1:i=Stack[top].i;j=Stack[top].j+1;break;
                case  2:i=Stack[top].i+1;j=Stack[top].j;break;
                case  3:i=Stack[top].i;j=Stack[top].j-1;break;
            }
            if(map[i][j]==0) find=1;
        }
        if(find==1)
        {
            Stack[top].direction=direction;
            top++;
            Stack[top].i=i;
            Stack[top].j=j;
            Stack[top].direction=-1;
            map[i][j]=-1;
        }
        else
        {
            map[Stack[top].i][Stack[top].j]=0;
            top--;
        }
    }
    printf("最短路径长度：%d\n",mindirections);
    printf("最短路径：\n");
    int k;
    for(k=0;k<mindirections;k++)
    {
        printf("[%d,%d]",Path[k].i,Path[k].j);
        if((k+1)%4)
            printf("\n");
    }
    printf("\n");
}
int main()
{
    printf("迷宫所有路径：\n");
    maze();
    return 0;
}