回溯算法解迷宫问题(C语言)

回溯法也称为试探法,该方法首放弃关于问题规模大小的限制,并将问题的候选解按某一顺序逐一枚举和试验.当发现当前候选解不可能是解时,就选择下一个候选解;倘若当前候选解除了还不满足问题规模要求外,满足所有其他要求时,继续扩大当前候选解的规模,并继续试探.如果当前候选解满足包括问题规模在内的所有要求时,该候选解就是问题的一个解.在回溯法中,放弃当前候选解,寻找下一个候选解的过程称为回溯.扩大当前候选解的规模,并继续试探的过程成为向前试探.

为了确保程序能够终止,调整时,必须保证曾被放弃过的填数序列不被再次试验,即要求按某种有序模型生成填数序列.给解的候选者设定一个被检验的顺序,按这个顺序逐一生成候选者并检验.

对于迷宫问题,我想用回溯法的难点就在如何为解空间排序,以确保曾被放弃过的填数序列不被再次试验.在二维迷宫里面,从出发点开始,每个点按四邻域算,按照右,上,左,下的顺序搜索下一落脚点,有路则进,无路即退,前点再从下一个方向搜索,即可构成一有序模型.下表即迷宫

{  1,1,1,1,1,1,1,1,1,1,
    0,0,0,1,0,0,0,1,0,1,
    1,1,0,1,0,0,0,1,0,1,
    1,0,0,0,0,1,1,0,0,1,
    1,0,1,1,1,0,0,0,0,1,
    1,0,0,0,1,0,0,0,0,0,
    1,0,1,0,0,0,1,0,0,1,
    1,0,1,1,1,0,1,1,0,1,
    1,1,0,0,0,0,0,0,0,1,
    1,1,1,1,1,1,1,1,1,1}

从出发点开始,按序查找下一点所选点列构成有序数列,如果4个方向都搜遍都无路走,就回退,并置前点的方向加1,依此类推.......

1	2	3	4	5	6	7	8	9	10
x	1	1	1	2	3	3	3	2	...
y	0	1	2	2	2	3	4	4	...
c	1	1	3	3	1	1	2	1	...

#include<stdio.h>
#include<stdlib.h>
#define n1 10
#define n2 10
typedef struct node
{
int x; //存x坐标
int y; //存Y坐标
int c;  //存该点可能的下点所在的方向,1表示向右,2向上,3向左,4向右
}linkstack;

linkstack top[100];
//迷宫矩阵
int maze[n1][n2]={1,1,1,1,1,1,1,1,1,1,
    0,0,0,1,0,0,0,1,0,1,
    1,1,0,1,0,0,0,1,0,1,
    1,0,0,0,0,1,1,0,0,1,
    1,0,1,1,1,0,0,0,0,1,
    1,0,0,0,1,0,0,0,0,0,
    1,0,1,0,0,0,1,0,0,1,
    1,0,1,1,1,0,1,1,0,1,
    1,1,0,0,0,0,0,0,0,1,
    1,1,1,1,1,1,1,1,1,1,};

int i,j,k,m=0;

main()
{
//初始化top[],置所有方向数为左
for(i=0;i<n1*n2;i++)
{
top[i].c=1;
}
printf("the maze is:/n");

//打印原始迷宫矩阵
for(i=0;i<n1;i++)
{
 for(j=0;j<n2;j++)
 printf(maze[i][j]?"* ":"  ");
 printf("/n");
}
i=0;top[i].x=1;top[i].y=0;
maze[1][0]=2;
/*回溯算法*/
do
{
 if(top[i].c<5)    //还可以向前试探
 {
  if(top[i].x==5 && top[i].y==9) //已找到一个组合
  {
   //打印路径
   printf("The way %d is:/n",m++);
   for(j=0;j<=i;j++)
   {
    printf("(%d,%d)-->",top[j].x,top[j].y);
   }
   printf("/n");

   //打印选出路径的迷宫
   for(j=0;j<n1;j++)
   {
    for(k=0;k<n2;k++)
    {
     if(maze[j][k]==0) printf("  ");
     else if(maze[j][k]==2)  printf("O ");
     else printf("* ");
    }
    printf("/n");
   }

   maze[top[i].x][top[i].y]=0;
   top[i].c = 1;
   i--;
   top[i].c += 1;
   continue;
  }
  switch (top[i].c)   //向前试探
  {
   case 1:
    {
     if(maze[top[i].x][top[i].y+1]==0)
     {
      i++;
      top[i].x=top[i-1].x;
      top[i].y=top[i-1].y+1;
      maze[top[i].x][top[i].y]=2;
     }
     else
     {
      top[i].c += 1;
     }
     break;
    }
   case 2:
    {
     if(maze[top[i].x-1][top[i].y]==0)
     {
      i++;
      top[i].x=top[i-1].x-1;
      top[i].y=top[i-1].y;
      maze[top[i].x][top[i].y]=2;
     }
     else
     {
      top[i].c += 1;
     }
     break;
    }
   case 3:
    {
     if(maze[top[i].x][top[i].y-1]==0)
     {
      i++;
      top[i].x=top[i-1].x;
      top[i].y=top[i-1].y-1;
      maze[top[i].x][top[i].y]=2;
     }
     else
     {
      top[i].c += 1;
     }
     break;
    }
   case 4:
    {
     if(maze[top[i].x+1][top[i].y]==0)
     {
      i++;
      top[i].x=top[i-1].x+1;
      top[i].y=top[i-1].y;
      maze[top[i].x][top[i].y]=2;
     }
     else
     {
      top[i].c += 1;
     }
     break;
    }
  }
 }
 else   //回溯
 {
  if(i==0) return;   //已找完所有解
  maze[top[i].x][top[i].y]=0;
  top[i].c = 1;
  i--;
  top[i].c += 1;
 }
}while(1);
}