迷宫问题

1. 问题描述
   定义一个二维数组：
   int maze[5][5] = {

   0, 1, 0, 0, 0,

   0, 1, 0, 1, 0,

   0, 0, 0, 0, 0,

   0, 1, 1, 1, 0,

   0, 0, 0, 1, 0,

};

它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。

1. 问题分析
   在这个问题中，从开始位置按照4个方向进行搜索，当这个点没被访问过，或者这个点能够走通，此时将这个点加入到栈当中，每次加入栈中的只是该节点的下一个节点，直到找到目标节点为止，当走到死胡同时候即4个方向都不能走通此时将这个点从栈中删除，弹出下一个顶点。当找到目标节点时，此时栈中的元素，即为从开始节点到目标节点的路径。

2. 问题优化
   在随意给定目标节点以及开始节点时，此时可以根据两个节点的位置，设置有限搜索的方向，例如上一个例子，假设开始节点为（0，0），目标节点（4，4），此时可以有限朝右，下方向搜索。

   1. 代码

#include<iostream>
#include<stack>
#include<cstring>
#define Max_row 100
#define Max_col 100
using namespace std;
int matrix[Max_row][Max_col];

void maze(int begin_row,int begin_col,int target_row,int target_col,int row,int col)
{
    stack<int> Stack,out_stack;
    int visit[Max_row][Max_col],h,r,c,Max_length;
    memset(visit,0,sizeof(visit));
    Max_length=row*col;
    Stack.push(begin_row*10+begin_col);
    visit[begin_row][begin_col]=1;
    while(!Stack.empty())
    {
        h=Stack.top();
        r=h/10;  c=h%10;
        if(r==target_row&&c==target_col)    //找到目标节点时，输出路径
        {
            if(!out_stack.empty())
            {
                out_stack.pop();
            }
            stack<int> S(Stack);
            if(Stack.size()<Max_length)
            {
                Max_length=Stack.size();
                while(!S.empty())
                {
                    out_stack.push(S.top());
                    S.pop();
                }
            }
            Stack.pop();
            continue;
        }
        if(matrix[r+1][c]!=1&&r+1<row&&visit[r+1][c]==0) //向下搜
        {
            Stack.push((r+1)*10+c);
            visit[r+1][c]=1;
        }
        else if(matrix[r-1][c]!=1&&r-1>=0&&visit[r-1][c]==0)//向上搜
        {
            Stack.push((r-1)*10+c);
            visit[r-1][c]=1;
        }
        else if(matrix[r][c+1]!=1&&c+1<col&&visit[r][c+1]==0)//向右搜
        {
            Stack.push(r*10+c+1);
            visit[r][c+1]=1;
        }
        else if(matrix[r][c-1]!=1&&c-1>=0&&visit[r][c-1]==0)向左搜
        {
            Stack.push(r*10+c-1);
            visit[r][c-1]=1;
        }
        else                          //遇到死角的时候，回溯到上一个节点                      
        {
            Stack.pop();
        }
    }
    while(!out_stack.empty())
    {
        h=out_stack.top();
        cout<<"("<<h/10<<","<<h%10<<")"<<endl;
        out_stack.pop();
    }
}
int main()
{
    int col,row,begin_row,begin_col,target_row,target_col;
    cout<<"输入矩阵的行和列：\n";
    cin>>row>>col;
    for(int i=0;i<row;i++)
        for(int j=0;j<col;j++)
        cin>>matrix[i][j];
        cout<<"输入开始坐标：\n";
        cin>>begin_row>>begin_col;
        cout<<"输入目标坐标：\n";
        cin>>target_row>>target_col;
        maze(begin_row,begin_col,target_row,target_col,row,col);
        return 0;
}