数据结构之迷宫问题

定义了一个N*N的矩阵为迷宫，其中1为迷宫的墙，0为迷宫的路，即遇到0可以前进，遇到1不能继续前进。迷宫不能出界，因此初始设计迷宫时候利用1封闭迷宫（一个简单的避免出界的好方法）。迷宫入口和出口的定义就是矩阵的（1，1）位置和（N-1,N-1）位置。

主要利用栈的数据结构和递归的思想。可以让程序通过进栈出栈的尝试遍历所有从起点到终点的可能，找到所有可能路径。

#include<iostream>
using namespace std;

#define C 9
#define H 10
int num = 0;

int  maze[C][H] = {   { 1,1,1,1,1,1,1,1,1,1 },
                      { 1,0,0,1,1,1,0,0,0,1 },
                      { 1,1,0,0,0,0,0,0,0,1 },
                      { 1,0,0,1,0,1,0,1,0,1 },
                      { 1,0,1,1,0,1,1,1,0,1 },
                      { 1,0,0,0,0,0,0,0,0,1 },
                      { 1,1,1,1,1,1,1,0,0,1 },
                      { 1,1,1,1,1,1,1,0,0,1 },
                      { 1,1,1,1,1,1,1,1,1,1 }   };

struct Road {//路线信息结构体
    int x;
    int y;
}R[100];


struct stack{//路线信息存放栈
    Road  road[100];
    int top;//栈顶指针
}s[100];

bool isempty(stack* st) {//判断栈是不是空栈
    if (st->top == -1)
        return true;
    return false;
}

void instack(stack *st,Road &r ) {//进栈操作
    st->top++;
    st->road[st->top] = r;
}


void outstack(stack *st,Road &r) {//结点出栈操作
     r = st->road[st->top] ;
     st->top--;
}


void freestack(stack* st) {//释放栈
    st->top--;
}


int findroad(int x, int y, stack st) {//寻找迷宫通路，0可走，1不可走，（1，1）起点（C-1,H-1）终点
    Road r,temp,record[100];
    r.x = x;
    r.y = y;//给信息结构体赋值
    int nx, ny, n;
    nx = x;
    ny = y;
    n = -1;
    if (x == 7 && y == 8) {//结束递归调用的判断条件
        num ++;//计数，一共有几个栈，方便下面比较
        s[num-1] = st;//栈数组，用于判断最短路径

        //出栈
        while (!isempty(&st)) {
            outstack(&st, r);
            n++;
            record[n] = r;
            
        }
        printf("第%d条迷宫路径为：(1,1)->",num);
        for (; n >= 0; n--) {
                cout<<"("<< record[n].x<<","<< record[n].y<<")";
                if (n)cout<<"->";
        }
        cout<<"\n";
        return num;
           
    }

    else {
        for (int v = 0; v < 4; v++) {//4个方向循环执行，寻找可行路径
            switch (v) {
            case 0: { nx = x;  ny = y + 1;  break; }
            case 1: { nx = x;  ny = y - 1;  break; }
            case 2: { nx = x + 1; ny = y;  break;  }
            case 3: { nx = x - 1; ny = y;  break;  }
            }
        if (maze[nx][ny] == 0) {//递归调用核心
               temp.x = nx;
               temp.y = ny;
                maze[nx][ny] = 1;
               instack(&st, temp);//已经确定是可以通过的地方先入栈
               findroad(nx, ny, st);//递归调用findroad函数，下一层寻找结点
               maze[nx][ny] = 0;
               freestack(&st);
            }
        }
    }
    return num;//若没有通路直接返回0，有通路法返回通路条数
}

    int main(){
        for (int i = 0; i < C; i++) {
            for (int j = 0; j < H; j++) {
                cout << maze[i][j]<<' ';
            }
            cout << '\n';
        }
        int a;
        stack *t,temp;
        t = new stack;
        temp .top=0;
        t->top = -1;
        a=findroad(1,1,*t);
        if (a == 0)
            cout<<"无路可走";        
        else if(a!=0){
            for (int i = 0; i < a; i++)//寻找最短路径（top数值最小的栈）
            {
                for (int j = i + 1; j < a; j++) {
                    if (s[i].top > s[j].top) {
                        temp = s[i];
                        s[i] = s[j];
                        s[j] = temp;
                    }
                }
            }
            cout<<"\n最短路径为：";
            cout<<"(1,1)->";
            for (int i = 0; i < s[0].top + 1; i++) {
                cout<< "("<<s[0].road[i].x<<"," <<s[0].road[i].y<<")";
                if (i != s[0].top) cout<<"->";
            }
        }
            return 0;
    }

 运行截图：