迷宫问题(回溯法)

--------------------------------写在前面----------------------------------------

作为初学者的我表示这个程序真心不能自己写出来，花了一些时间才看懂@JackyBing写的这段代码，并改了一些东西

感谢@JackyBing的代码，书上的真心没看懂，现在理解了，

呜呜呜，感觉自己好弱呀，这都看了这么久，还是得像大神看齐。

一起学习，共同进步！

--------------------------------核心算法----------------------------------------

do

{

if(当前的路径可以通过）

{

留下足迹；

将当前位置保存并入栈

if（判断当前路径是否为最终路径）

{

退栈，并修改迷宫的数据，记录所走的路线

并返回 1；

}

当前步数增一；

获取下一位置；

}

else//当前位置走不通

{

if（当前栈不为空）

{

退栈；

while（当前位置的所走方向为4并且当

当前栈不为空）

{

记录当前位置不为走不通；

退栈处理；

当前步数减一；

}

if（当前的位置所走方向小于4)

{

将当前位置的方向增一；

将当前位置重新进栈；

获取下一将要通过的位置；

}

}

}

}

--摘自http://www.cnblogs.com/JackyTecblog/archive/2011/02/20/1958880.html

#include<iostream>
#include<stdlib.h>

using namespace std;

#define STACK_INIT_SIZE 100
#define STACKINCREASE 10
#define MAZESIZE 10


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


typedef struct
{
    Postion pos;//通道块在迷宫中的“坐标位置”
    int curstep;//通道块在路径中的“序号”
    int dir;//从此通道块走向下一通道块的“方向”
}mazenode;


typedef struct
{
    mazenode *base;
    mazenode *top;
    int stacksize;
}SqStack,*LinkStack;


int InitStack(LinkStack &S)
{
    S->base=(mazenode *)malloc(STACK_INIT_SIZE*sizeof(mazenode));
    if(!S->base)
    {
        cout<<"分配空间失败!";
        exit(-1);
    }
    S->top=S->base;
    S->stacksize=STACK_INIT_SIZE;
    return 0;
}


int Push(LinkStack &S,mazenode *e)
{
    if((S->top-S->base)>=STACK_INIT_SIZE)
    {
        S->base=(mazenode *)realloc(S->base,(STACK_INIT_SIZE+STACKINCREASE)*sizeof(mazenode));
        if(!S->base)
        {
           cout<<"分配空间失败!";
            exit(-1);
        }
        S->top=S->base+STACK_INIT_SIZE;
        S->stacksize=STACK_INIT_SIZE+STACKINCREASE;
    }
    *(S->top)=*e;//结构体
    S->top++;
    return 0;
}


int Pop(LinkStack &S,mazenode *e)
{
    if(S->base==S->top)
    {
        cout<<"栈为空!";
        exit(0);
    }
    S->top--;
    *e=*(S->top);
    return 0;
}


int GetTop(LinkStack &S,mazenode *e)
{
    if(S->base==S->top)
    {
        cout<<"栈为空!";
        return 0;
    }
    else
    {
        *e=*(S->top-1);
        return 1;
    }
}


int EmptyStack(LinkStack &S)
{
    if(S->base==S->top) return 1;//stack is empty!
    else return 0;//stack is not empty!
}


int Pass(Postion pos,int array[MAZESIZE][MAZESIZE])//判断pos位置是否可通
{
    if(array[pos.x][pos.y]!=0&&array[pos.x][pos.y]!=-1) return 1;//indicate the way can pass
    else return 0;//indicate the way can not pass
}


Postion NextPos(Postion pos,int dir)//结构体函数,返回当前位置下一个待判断位置的坐标，顺时针旋转(东->南->西->北)
{
    switch(dir)
    {
        case 1:pos.y+=1;break;
        case 2:pos.x+=1;break;
        case 3:pos.y-=1;break;
        case 4:pos.x-=1;break;
        default:break;
    }
    return pos;
}


int MarkFoot(int arr[MAZESIZE][MAZESIZE],Postion pos)//标记已经走过了
{
    arr[pos.x][pos.y]=0;//have pass by the way
    return 0;
}

int MarkBlock(int arr[MAZESIZE][MAZESIZE],Postion pos)
{
    arr[pos.x][pos.y]=-1;//do not pass by the postion
    return 0;
}


int MazePath(int arr[MAZESIZE][MAZESIZE],Postion start,Postion ending)
{
    LinkStack s;
    mazenode *p=(mazenode*)malloc(sizeof(mazenode));
    mazenode *nodelist=(mazenode *)malloc(100*sizeof(mazenode));//记录成功路径
    int curstep=1,flag=0;//设定入口位置为路径中的第一个位置
    Postion curpos=start,temp;//设定当前位置为入口位置
    InitStack(s);
    do
    {
        if(Pass(curpos,arr))//当前位置可通
        {
            MarkFoot(arr,curpos);//很关键,标记在当前位置上的通道不能再往回走了
            nodelist[flag].pos=curpos;//将当前位置的内容复制到nodelist数组的相应元素
            nodelist[flag].curstep=curstep;
            nodelist[flag].dir=1;//towards east
            Push(s,nodelist+flag);//将nodelist数组的相应元素压入s栈中
            flag++;
            if(curpos.x==ending.x&&curpos.y==ending.y)//如果当前位置是终点，则依次将栈中元素的位序赋给它在数组中的相应位置
            {
                while(!EmptyStack(s))
                {
                    Pop(s,p);//p为当前路径上最后一个位置
                    arr[p->pos.x][p->pos.y]=p->curstep;
                }
                return 1;//结束
            }
            curstep++;
            curpos=NextPos(curpos,1);//towards east
        }
        else//当前位置不可通
        {
            if(!EmptyStack(s))
            {
                Pop(s,p);
                while(p->dir==4&&!EmptyStack(s))
                {
                    MarkBlock(arr,p->pos);//mark that the way is not passed
                    Pop(s,p);
                    curstep--;
                }
                if(p->dir<4)
                {
                    p->dir++;
                    Push(s,p);
                    temp=p->pos;
                    curpos=NextPos(temp,p->dir);
                }
            }
        }
    }while(!EmptyStack(s));
    return 0;//failure
}



int main()
{
    int maze[MAZESIZE][MAZESIZE]={
        {0,0,0,0,0,0,0,0,0,0},
        {0,1,1,0,1,1,1,0,1,0},
        {0,1,1,0,1,1,1,0,1,0},
        {0,1,1,1,1,0,0,1,1,0},
        {0,1,0,0,0,1,1,1,1,0},
        {0,1,1,1,0,1,1,1,1,0},
        {0,1,0,1,1,1,0,1,1,0},
        {0,1,0,0,0,1,0,0,1,0},
        {0,0,1,1,1,1,1,1,1,0},
        {0,0,0,0,0,0,0,0,0,0}},i,j,flag;
    Postion start,ending;
    start.x=1;start.y=1;
    ending.x=8;ending.y=8;
    cout<<"primative maze:"<<endl;
    for(i=0;i<MAZESIZE;i++)
    {
        for(j=0;j<MAZESIZE;j++) cout<<maze[i][j]<<"	";
        cout<<endl<<endl;
    }
    flag=MazePath(maze,start,ending);
    if(flag==1)
    {
        cout<<"maze processing success!"<<endl;
        cout<<"processed maze:"<<endl;
        for(i=0;i<MAZESIZE;i++)
        {
            for(j=0;j<MAZESIZE;j++) cout<<maze[i][j]<<"	";
            cout<<endl<<endl;
        }
    }
    else cout<<"maze processing fail"<<endl;
    return 0;
}