数据结构图的搜索实验

实验四 图的搜索实验

实验目的

熟悉图的相关操作，掌握图的搜索算法及其应用，同时进一步练习栈与队列在实际问题中的应用。

1、迷宫问题

问题描述：

一只老鼠走进了一个迷宫，这个迷宫是由M行N列的方格构成的，相邻方格之间可能是相通的，也可能有墙相隔，各方格位置由其对应坐标确定，如图所示为5行5列的迷宫，矩阵中1代表是墙走不通，0表示可以通行。迷宫在（1，1）处有一个入口，在（M,N）处有一个出口。问题是让你帮助老鼠找出从入口到出口一共有多少条路径，最短路径需多少步到达出口。

0 1 0 0 0

0 1 0 1 0

0 0 0 0 0

0 1 0 1 0

0 0 0 1 0

基本要求：

采用深度优先搜索计算路径数，用广度优先搜索找最短路径。

实现提示：

迷宫用数组表示，1代表是墙走不通，0表示可以通行。边界可以扩充为墙，即M×N迷宫用(M+2)×(N+2)数组表示。

向4个方向前进时的位移量可以用以下数组表示，处理时方便。

int move[4][2]={ {0,1},{1,0},{0,-1},{-1,0} };  

Input

   输入第一行为2个整数M和N（M、N不超过10），表示迷宫为M行N列，从第二行开始共有M行，每行N个整数（0或1），各数之间由空格分隔。

Output

输出包括2行，第一行为路径个数，第二行为最快到达出口的步数。

Sample Input

5  5

0 1 0 0 0

0 1 0 1 0

0 0 0 0 0

0 1 0 1 0

0 0 0 1 0

Sample Output

4

8

需求分析：（包括对问题的理解，解决问题的策略、方法描述）

用深度优先搜索求迷宫路径数问题

用广度优先搜索求最短路径问题

深度优先所有采用递归的方法

广度优先搜索采取矩阵的方法

系统设计：（包括数据结构定义、抽象出基本操作描述、主程序模块处理过程描述）

int mark[12][12],maze[12][12];              //设置迷宫和标志数组，也可以动态分配

int move[4][2]={ {0,1},{1,0},{0,-1},{-1,0} };  // 4行分别代表向4个方向前进时的位移量

int m,n;                                 //实际迷宫大小

struct {

     int x,y;           //当前结点位置

     int lev;

}que[100];        

int h,t;                  //队列头尾指针

//深度优先搜索策略                  

int  DFS(int x,int y,int &num)                 //按深度策略搜索路径,从x、y处开始搜索

{

 int i,g,h;

 mark[x][y]=1;                                //将（x，y）处标记为已走过

 if (x==m && y==n){                    //找到出口，返回1

  num++;

  return(1);

 }              

 for (i=0;i<4;i++)                              //顺序向4个方向试

 {

  g=x+move[i][0];

  h=y+move[i][1];                           //得到试探的坐标

  if((maze[g][h]==0) && (mark[g][h]==0))       //若没走过并且可走

  {

   mark[g][h]=1;                         //走到此处，标记已走过

   DFS(g,h,num);

   mark[g][h]=0;

  }

 }

 return(0);                                     //返回0，没找到出口

}

//广度优先搜索策略

int  BFS(int x,int y,int &lev)

{

 int cx,cy,dx,dy,i,fg;

 que[t].x=x;que[t].y=y;

 que[t].lev=0;

 t++;

 fg=0;                                     //起始节点入队列

 while(h!=t)                               //队列不空时循环

{

  cx=que[h].x;cy=que[h].y;                //取队列元素

  lev=que[h].lev;

  h++;                                 //出队列

  if(cx==m&&cy==n)

  {      

      fg=1;             //找到出口

      break;

  }

  for(i=0;i<4;i++)

  {                       //4个方向试探

   dx=cx+move[i][0];                  //计算新节点位置

   dy=cy+move[i][1];

   if(maze[dx][dy]==0&&mark[dx][dy]==0)

   {   //如果可以走

    mark[dx][dy]=1;                      //标记该位置

    que[t].x=dx;que[t].y=dy;

    que[t].lev=lev+1;

    t++;                                  //入队列

   }

  }

 }                     

    return(fg);

}

基本操作的实现：（对各基本操作实现的描述）

int main()

{

 int i,j,num;

 int lev;

 scanf("%d%d",&m,&n);                 //读入迷宫大小

 for(i=1;i<=m;i++)                      //读入迷宫数据

  for(j=1;j<=n;j++)

   scanf("%d",&maze[i][j]);

 for(i=0;i<=m+1;i++)                    //增加迷宫外围的"墙"

 {

  maze[i][0]=1;

  maze[i][n+1]=1;

 }

 for(j=1;j<=n;j++)                      //增加迷宫外围的"墙"

 {

  maze[0][j]=1;

  maze[m+1][j]=1;

}

num=0;

DFS(1,1,num);

printf("%d",num);

lev=0;

printf("\n");

if(BFS(1,1,lev)==0)

{

printf("NoPath");

}

else

{

printf("%d",lev);

}

return 0;

}

测试结果：（输入的测试数据及运行结果、正确性、在线测试情况）

调试分析：（包括调试过程中对原设计的修改，以及遇到的问题和解决的方法）

广度优先搜索寻找最短路径的过程中 算法不是只走一条最短的路径 而是四周能走的路径均考虑，将可走的点均进入队列中 一旦到达出口用break跳出循环 此路径即最短的路径 其余不是最短的可行路径将不再对其进行查找。

寻找最短路径过程中应将数据存放在队列中而不是栈中。