【深度优先_栈】：输出迷宫的所有路径，并求出最短路径长度及最短路径

//要求输出迷宫的所有路径，并求出最短路径长度及最短路径。
//入口坐标设为(1,1),出口坐标设为(4,4）

#include<stdio.h>

#define M 4    //行数
#define N 4     //列数
#define MaxSize    100     //栈最多元素个数

int mg[M+2][N+2]= //一个迷宫，其四周要加上均为1的外框，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}
};

struct migong
{
    int i;      //路径横坐标
    int j;      //路径纵坐标
    int di;     //方向值初始为-1，0,1,2,3分别表示四个要查找的方向
}Stack[MaxSize],Path[MaxSize];      //定义栈和存放最短路径的数组

int top= -1;     //栈顶指针，初始值为-1
int count= 1;    //路径数计数
int minlen=MaxSize;     //最短路径长度

void mgpath() //路径为:(1,1)->(M,N)
{      
    int i,j,di,nextfound,k;
	
	//初始结点进栈
    top++;
	Stack[top].i=1;
	Stack[top].j=1;
	Stack[top].di=-1;  //该点的初始方向值-1，表示还没查找过从此出发的其他4个方向
    mg[1][1]=-1;     //-1表示该节点位置进栈过(最好用其他数组来标示)
	
    while(top> -1) //栈不空时循环
	{     
		//1 -----获取栈顶
        i=Stack[top].i;
		j=Stack[top].j;
		di=Stack[top].di;  //栈顶元素的查找方向
		
		//2 -----如果找到了出口（M,N），则输出查找路径，并退栈，用新的栈顶方向值取代当前的查找方向
        if(i==M && j==N) 
		{       
            printf("M:  ",count++);
            for(k=0;k<=top;k++) //输出路径
			{
                printf("(%d,%d)  ",Stack[k],i,Stack[k].j);
                if((k+1)%5==0)      //输出时每5个结点换一行
                    printf("\n\t");
            }
            printf("\n");
            if(top+1<minlen) //比较输出最短路径
			{       
                for(k=0;k<=top;k++)  
				{
                    Path[k]=Stack[k]; //保存最短路径
				}
                minlen=top+1;
            }
			
            mg[Stack[top].i][Stack[top].j]=0;   //0表示让该位置变为其他路径的可走结点
			
			//让元素出栈
            top--;
            //i=Stack[top].i;
			//j=Stack[top].j;
			di=Stack[top].di;  //记录下一次的查找方向为新栈顶的的查找方向
        }
		
		//3 -------在当前栈顶的基础上找到下一个可走节点，如果当前栈顶的4个方向都走完了，则退栈找新的栈顶
        nextfound=0;
        while(di<4 && nextfound==0) //找下一个可走结点
		{     
            di++; //下一个查找方向
            switch(di) //计算下一个查找方向的坐标
			{
                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(mg[i][j]==0)  //如果下一个可走节点没有进栈过，标记find为1表示找到了下一个可走节点
			{
                nextfound=1;
			}
        }

        if(nextfound == 1) //从当前栈顶上找到了下一个可走结点
		{      
            Stack[top].di=di;   //更新栈顶元素的di值为最新的查找方向
			
			//下一个可走结点进栈
            top++;
            Stack[top].i=i;
            Stack[top].j=j;
            Stack[top].di=-1;
			
            mg[i][j]=-1;
        }
		else  //如果当前栈顶的4个方向都已经查找完
		{
            mg[Stack[top].i][Stack[top].j]=0;   //0表示让该位置变为其他路径的可走结点
            top--;  //当前栈顶已经查找完，让它出栈
        }
    }

    printf("最短路径如下:\n");
    printf("长度:  %d\n",minlen);
    printf("路径:  ");
    for(k=0;k<minlen;k++)
	{
        printf("(%d,%d)  ",Path[k].i,Path[k].j);
        if((k+1)%5==0)      //输出时每5个结点换一行
            printf("\n\t");
    }
    printf("\n");
}

int main()
{
    printf("迷宫所有路径如下:\n");
    mgpath();
    return 0;
}