设计与算法：迷宫问题

描述

定义一个二维数组： 

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表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。

输入

一个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

样例输出

(0, 0)
(1, 0)
(2, 0)
(2, 1)
(2, 2)
(2, 3)
(2, 4)
(3, 4)
(4, 4)

一个包含指针的结构体，用visited存数据，也把走过的置1，变成墙，判重。

用一个结构体指针存要输出的位置

#include <bits/stdc++.h>//Writed by Wangzhimin Date:2023.12.20
int visited[10][10];//定义一个标志数组，也用在存输入数据 
struct step{//一个结构体，x，y为坐标，steps为步数，p为指针。 
    int x;
    int y;
    step *p;
    int steps;
        };
using namespace std;
step maze[105];//一个一维数据保存gs的数据。 
step *shuchu[105];//为最后输出反序的一个结构体指针。 
int num=0;//一个为指针移动的数 
int main()
{
    int k,i,j;
    step *head,*tail;
    for(i=0;i<5;i++)// 开始输入的数据 
    for(j=0;j<5;j++)
    scanf("%d",&visited[i][j]);
    //memset(visited,0,sizeof(visited));
    visited[0][0]=1; //标志数据第一个置1 
    head=maze;//把第一个放在head指针中
    head->x=0;
    head->y=0;
    head->steps=0;
    head->p=maze;
    tail=maze+10;
    while(head!=tail){//循环开始，看指针头与尾是不是相同 
        step s;
        s=*head; 
        //cout<<s.x<<s.y<<s.step<<endl;
        if(s.x==4&&s.y==4){//用了一个s，其实用指针也可，是否在右下角 
        //    cout<<s.step<<endl;
            for(int i=s.steps;i>=0;i--)//循环放指针，从后到前 
            {
            shuchu[i]=head;
            head=head->p;
             }
             for(int i=0;i<=s.steps;i++)//从前输出指针指到的位置 
             cout<<"("<<shuchu[i]->x<<", "<<shuchu[i]->y<<")"<<endl;
            return 0;
                  }
        else{
            if(s.x-1>=0&&!visited[s.x-1][s.y]){//判断下移 
            num++;
                tail=maze+num+1;
                maze[num].x=s.x-1;
                maze[num].y=s.y;
                maze[num].steps=s.steps+1;
                maze[num].p=head; 
                visited[s.x-1][s.y]=1;//走过的变成1 
            }
            if(s.x+1<5&&!visited[s.x+1][s.y])//判断上移 
            {
                num++;
                tail=maze+num+1;
                maze[num].x=s.x+1;
                maze[num].y=s.y;
                maze[num].steps=s.steps+1;
                maze[num].p=head;
                visited[s.x+1][s.y]=1;
            }
            if(s.y+1<5&&!visited[s.x][s.y+1]){//判断右移 
                num++;
                tail=maze+num+1;
                maze[num].x=s.x;
                maze[num].y=s.y+1;
                maze[num].steps=s.steps+1;
                maze[num].p=head;
                visited[s.x][s.y+1]=1; 
            }
            if(s.y-1>=0&&!visited[s.x][s.y-1]){//判断左移 
                num++;
                tail=maze+num+1;
                maze[num].x=s.x;
                maze[num].y=s.y-1;
                maze[num].steps=s.steps+1;
                maze[num].p=head;
                visited[s.x][s.y-1]=1; 
            }
            head++;//头指针向尾部移 
    }

}
    return 0;
}