c语言回溯法破解迷宫
#include
#include
//定义栈
structTNode
{
struct Node *top;
}TNode; typedefstructTNode *TN;
struct Node
{
int x;
int y;
struct Node *next;
}Node;
typedefstruct Node *N;
//压栈
void Push(TN tn,intxx,intyy) {
N q;
q=(N)malloc(sizeof(Node));
q->x=xx;
q->y=yy;
q->next=tn->top;
tn->top=q;
}
//出栈
void Out(TN tn)
{
N q;
if(tn->top==NULL) return;
q=tn->top;
tn->top=tn->top->next;
free(q);
}
//回溯法过迷宫
void Past(int maze[10][10],int direction[8][2],int x1,int y1,int x2,int y2)
{
TN tn;
int mark[10][10]= {
//0 1 2 3 4 5 6 7 8 9
{0,0,0,0,0,0,0,0,0,0},//0
{0,0,0,0,0,0,0,0,0,0},//1
{0,0,0,0,0,0,0,0,0,0},//2
{0,0,0,0,0,0,0,0,0,0},//3
{0,0,0,0,0,0,0,0,0,0},//4
{0,0,0,0,0,0,0,0,0,0},//5
{0,0,0,0,0,0,0,0,0,0},//6
{0,0,0,0,0,0,0,0,0,0},//7
{0,0,0,0,0,0,0,0,0,0},//8
{0,0,0,0,0,0,0,0,0,0},//9
};
tn=(TN)malloc(sizeof(TNode));//创建栈
tn->top=NULL;
Push(tn,x1,y1);//压入入口坐标
mark[x1][y1]=1;
while (tn->top!=NULL)
{
intm,n,hang,lie,i=0;
m=tn->top->x;
n=tn->top->y;
//循环方向数组,探四个方向
for(;i<8;)
{
hang=m+direction[i][0];
lie=n+direction[i][1];
if(hang==x2&&lie==y2)
{
Push(tn,hang,lie);
printf("迷宫已破解！！！路径是：\n\n");
while(tn->top!=NULL)
{
if(tn->top->x==x2&&tn->top->y==y2) maze[tn->top->x][tn->top->y]=4;
else
maze[tn->top->x][tn->top->y]=3;
Out(tn);
}
Print(maze);
return;
}
if(mark[hang][lie]!=1&&maze[hang][lie]==0)
{
mark[hang][lie]=1;
Push(tn,hang,lie);
m=hang;
n=lie;
i=-1;
}
i+=1;
}
Out(tn);
}
printf("找不到通路，迷宫无法走出去！！！\n");
}
//输出结果★
void Print(int array[10][10])
{
inti,j;
for(i=0;i<10;i++)
{
for(j=0;j<10;j++)
{
if(array[i][j]==3) printf(" ￥");
else if(array[i][j]==4) printf(" ★");
else printf("%5d",array[i][j]);
}
printf("\n");
}
printf("\n");
}
int main()
{
//定义迷宫数组
int maze[10][10]= {
//0 1 2 3 4 5 6 7 8 9
{1,0,1,1,1,1,1,1,1,1},//0
{1,0,1,1,1,0,0,0,0,1},//1
{1,0,0,0,1,0,1,0,0,1},//2
{1,0,1,0,0,1,1,0,1,1},//3
{1,0,1,1,1,0,1,1,0,1},//4
{1,0,1,1,1,0,1,1,0,1},//5
{1,0,1,1,1,0,1,1,0,1},//6
{1,0,1,0,1,1,0,1,0,1},//7
{1,0,0,1,0,0,1,1,0,1},//8
{1,1,1,1,1,1,1,1,1,0},//9 };
//定义方向数组
int direction[8][2]={
{0,1},
{1,1},
{1,0},
{1,-1},
{0,-1},
{-1,-1},
{-1,0},
{-1,1},
};
printf("迷宫数组是：\n\n");
Print(maze);
printf("开始破解...... \n\n");
Past(maze,direction,0,1,9,9);
getch();
}
算法分析与设计 查找迷宫的最短路径(深度算法)
算法分析与设计 查找迷宫的最短路径(深度算法) 计算机科学与技术12级 16班 2012/12/16
【摘要】：迷宫求解是一个古老的游戏，要在迷宫中找到出口，需要经过一连串的错误尝试才能找到正确的路径，有的时候甚至找不到路径。类似于给定一个m*n的矩形网格，设其左上角为起点S。一辆汽车从起点出发驶向右下角终点T。在若干网格处设置了障碍，表示该网格不可到达。设计一个算法，求汽车从起点S出发到达终点T的一条路线。用计算机求解这个问题时，我们通常采用的是回溯方法，即从入口出发，顺某方向向前探索，若能走通，则继续往前走；否则沿原路退回。换一个方向再继续探索，直至所有可能的通路都探索到为止。为了保证在任何位置上都能沿原路退回，显然需要用一个后进先出的结构来保存从入口到当前位置的路径。因此，在求迷宫通路的算法中应用“栈”也就是自然而然的事。当然还有其他的方法来解决，例如顺序表，深度优先遍历，广度优先遍历等。 【关键词】:最短路径; 时间复杂度;深度优先搜索 【Summary】Maze solving is an ancient game , you want to find the exit in the maze , need to go through a series of trial and error to find the right path , and sometimes not even find the path . A m * n rectangular grid , similar to a given set its upper-left corner as the starting point S . A car from the starting point towards the bottom right corner of the end of T . Set up barriers at certain grid , indicates that the grid is unreachable . Design an algorithm , find the car starting to reach the end point T, route from the starting point S . Use the computer to solve this problem , we usually use the backtracking method , that is, starting from the entrance , Shun forward to explore a direction , if we go through , and continue to move forward ; otherwise return along the same route . Continue to explore another direction , until all possible paths to explore to far . In order to ensure that in any position along the same route back , it is clear that the need to use a LIFO structure to save the path from the entrance to the current position . Therefore , in seeking labyrinth path algorithm application "stack" is the natural thing to do . Of course , there are other ways to solve , for example, the sequence table , depth-first traversal , breadth -first traversal . 【Key phrase】Shortest path ; time complexity ; deep-first search
利用栈实现迷宫地求解
利用栈实现迷宫的求解 一、要解决的问题： 以一个m*n的长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍，设计一个程序，对任意设定的迷宫，求出一条从入口到出口的通路，或得出没有通路的结论。 二：算法基本思想描述: 用一个字符类型的二维数组表示迷宫，数组中每个元素取值“0”（表示通路）或“1”（表示墙壁）。二维数组的第0行、第m+1行、第0列、第m+1列元素全置成“1”，表示迷宫的边界；第1行第1列元素和第m行第n列元素置成“0”，表示迷宫的入口和出口走迷宫的过程可以模拟为一个搜索的过程：每到一处，总让它按东、南、西、北4个方向顺序试探下一个位置； 用二维数组move记录4个方向上行下标增量和列下标增量，则沿第i个方向前进一步，可能到达的新位置坐标可利用move数组确定： Px=x+move[i][0] Py=y+move[i][1] 如果某方向可以通过，并且不曾到达，则前进一步，在新位置上继续进行搜索； 如果4个方向都走不通或曾经到达过，则退回一步，在原来的位置上继续试探下一位置。 三：设计： 1：数据结构的设计： （1）定义三元数组元素的结构 typedef struct MazeDirect { int Dx; //行标 int Dy; //列标 int direct; //走到下一个坐标点的方向 }MazeDirect; （2）定义链表节点的结构组成 typedef struct LinkNode { elemtype data; //数据域 struct LinkNode *next; //指针域 }LinkNode; （3）定义链栈的头指针 typedef struct {
迷宫求解问题资料
迷宫求解问题 摘要：用矩阵表示迷宫，将矩阵表示的迷宫转换成无向图，用邻接表存储。对无向图从入口结点开始广度优先搜索，用一个一维数组存储各个结点的前驱结点的编号，通过出口结点Vn找到其前驱结点Vn-1,再通过Vn-1找到Vn-2，依次类推直到找到出口结点。 关键字：矩阵迷宫求解 一、需求分析 1.程序题目： 迷宫求解问题。迷宫是一个如下所示的m行n列的0-1矩阵，0表示无障碍，1表示有障碍。设入口为（1，1），出口为（m，n），每次移动只能从一个无障碍的单元移到周围8个方向的任意一个无障碍的单元，编写程序给出一条通过迷宫的路径或者报告一个“无法通过”的信息。 入口->(0，0，0，1，0，0，0，1，0，0，0，1，0，0，1) (0，1，0，0，0，1，0，1，0，0，0，1，1，1，1) (0，1，1，1，1，1，0，1，0，0，1，1，1，0，1)
(1，1，0，0，0，1，1，0，1，1，0，0，1，0，1) (1，0，0，1，0，1，1，1，1，0，1，0，1，0，1) (1，0，1，0，0，1，0，1，0，1，0，1，0，1，0) (1，0，1，1，1，1，1，0，0，1，1，1，1，0，0) (1，1，1，0，1，1，1，1，0，1，0，1，0，1，0) (1，0，1，0，1，0，1，1，1，0，1，0，0，0，1) (0，1，0，1，0，1，0，0，0，1，1，0，0，1，0)->出口 2．程序说明及任务： 迷宫问题要求寻找一条从入口到出口的路径。路径是由一组位置构成的，每个位置上都没有障碍，且每个位置（第一个除外）都是前一个位置的东、南、西或北的邻居，如图C。 计算机走迷宫的方法是，采取一步一步试探的方法。每一步都从东开始，按顺时针对8个方向进行试探，若某方向上maze（x，y）=0，表示可以通行，则走一步；若maze（x，y）=1，表示不可以通行，须换方向再试，直到8个方向都试过；若maze （x，y）均为1，说明此步已无路可走，需退回一步，在上一步的下一个方向重新开始探测。为此，需设置一个栈，用于记录所走过的位置和方向（i,j,dir）。当退回一步时，从栈中退出一个元素，以便在上一个位置的下一个方向上探测，如又找到一个行进方向，则把当前位置和方向重新进栈，并走到新的位置。
利用栈实现迷宫的求解
利用栈实现迷宫的求解 一、要解决的四个问题： 1、表示迷宫的数据结构： 设迷宫为m行n列，利用maze[m][n]来表示一个迷宫，maze[i][j]=0或1; 其中：0表示通路，1表示不通，当从某点向下试探时，中间点有4个方向可以试探，（见图）而四个角点有2个方向，其它边缘点有3个方向，为使问题简单化我们用maze[m+2][n+2]来表示迷宫，而迷宫的四周的值全部为1。这样做使问题简单了，每个点的试探方向全部为4，不用再判断当前点的试探方向有几个，同时与迷宫周围是墙壁这一实际问题相一致。 如图3.4表示的迷宫是一个6×8的迷宫。入口坐标为（1，1），出口坐标为（m，n）。 入口(1,1) 图 1 用maze[m+2][n+2]表示的迷 宫 迷宫的定义如下： #define m 6 /* 迷宫的实际行 */ #define n 8 /* 迷宫的实际列 */ int maze [m+2][n+2] 2 、试探方向： 在上述表示迷宫的情况下，每个点有4个方向去试探，如当前点的坐标(x , y)，与其相邻的4个点的坐标都可根据与该点的相邻方位而得到，如图2所示。因为出口在（m，n），因此试探顺序规定为：从当前位置向前试探的方向为从正东沿顺时针方向进行。为了简化问题，方便的求出新点的坐标，将从正东开始沿顺时针进行的这4个方向（用0，1，2，3表示东、南、西、北）的坐标增量放在一个结构数组move [ 4 ]中，在move 数组中，每个元 m n 素有两个域组成，x：横坐标增量，y：纵坐标增量。Move数组如图3所示。 move数组定义如下： typedef struct { int x //行 int y //列 } item item move[4] 这样对move的设计会很方便地求出从某点 (x，y) 按某一方向 v (0≤v≤3) 到达的新点（i，j）的坐标：i =x + move[v].x ，j = y + move[v].y 。 3．栈的设计： 当到达了某点而无路可走时需返回前一点，再从前一点开始向下一个方向继续试探。因此，压入栈中的不仅是顺序到达的各点的坐标，而且还要有从前一点到达本点的方向，即每走一步栈中记下的内容为(行，列，来的方向)。对于图1所示迷宫，依次入栈为： 栈中每一组数据是所到达的每点的坐标及从该点沿哪个方向向下走的，对于图3迷宫，走
迷宫最短路径数据结构源码实验报告
实验报告 课程名称数据结构 实验名称迷宫最短路径 实验类型综合型 实验地点计405机房 实验日期2017.5.13 指导教师魏海平 专业软件工程 班级软件1601 学号1611030102 姓名寇春雷 辽宁石油化工大学计算机与通信工程学院
数据结构实验报告评分表
实验二迷宫最短路径 题目：迷宫最短路径 ⒈问题描述 从一个迷宫的入口到出口找出一条最短路经。用一个二维数组MAZE(1..m，1..n)模拟迷宫，数组元素为0表示该位置可以通过，数组元素为1表示该位置不可以通行。MAZE(1，1)和MAZE(m，n)分别为迷宫的入口和出口。 ⒉基本要求 (1)输入数据 a.输入迷宫的大小m行和n列，两者为整数 b.由随机数产生0或1，建立迷宫。 (2)输出数据 首先输出模拟迷宫的二维数组，若存在最短路经，则由出口回朔到入口打印这一条路径，如下所示：(m，n)，……，(i，j)，……，(1，1) 如无通道，则打印： THERE IS NO PATH. ⒊实现提示 (1)数据结构 ①为了在程序中判断方便，把迷宫扩展成为MAZE(0..m+1，0..n+1)，扩展部分的元素 设置为1，相当于在迷宫周围布上一圈不准通过的墙，这样，在迷宫的任一位置(I，j)上都有八个可以移动的方向。 ②用二维数组MOVE(1..8，1..2)存放八个方向上的位置量，如图所示： (i+MOVE[1，1]，j+MOVE[1，2]) ，2]) ，2]) ，2])
③为了标志已经通过的位置，采用一个标志数组MARK（1..m，1..n）初值为0，在寻 找路径的过程中，若通过了位置（i，j），则将MARK（i，j）置为为1。 ④为了记录查找过程中到达位置及其前一位置，建立一个Q（1..m*n-1，0..2）数组， 对于某一个数组元素Q(P)，其中，Q(P，0)和Q(P，1)记下到达位置i和j，Q(P，2)记下其出发点在Q数组中的下标。 （2）算法基本思想 将入口（1，1）作为第一个出发点，依次在八个反方向上搜索可通行的位置，形成第一层新的出发点，然后对第一层中各个位置分别搜索他所在八个方向上的可通行位置，形成第二层新的出发点，…，如此进行下去，直至达到出口(m，n)或者迷宫所有位置都搜索完毕为止。 具体实施：从(m，n)开始，将其记入Q数组，比如记入Q(1)，以它作为第一个出发点，依次对八个方向进行搜索，若下一个位置(I，j)可通行并且尚未经过（即MAZE(i，j)=0 且MARK(i，j)=0），则记入Q数组，如记在Q(P)，则在Q(P，2)中要记下其出发点在Q数组中的下标1，在八个方向上都搜索过以后，根据先进先出的原则Q从数组中重新取出一个位置作为新的出发点（这里，我们实际上把Q数组作为一个顺序表示的队列），重复以上过程，若能达到位置(m ，n)，表示找到最短路径；若Q数组中已经没有位置可以作为新的出发点了，则表示迷宫没有通路。 4.需求分析 (1)以二维数组maze[M+2][N+2]表示迷宫，其中maze[i][0]和maze[i][N+1](0= 中国计量学院实验报告 实验课程：算法与数据结构实验名称：迷宫的最优路径班级：学号： 姓名：实验日期：2013-5-20 一．实验题目： 输入一迷宫 查找并输出迷宫的最优路径 实验成绩：指导教师： 二．算法说明 1.定义一个结构体来表示起点和末点的坐标,定义一个数组来存放迷宫. struct elem { int x;//行 int y;//列 }; //定义结构体 int M[10][10]; 2.给数组中空白处赋上从起点到该处步骤的值. int find(int n) { for(i=0;i<9;i++) for(j=0;j<10;j++) { if(M[i][j]==n) { {if (M[i][j+1]==0) M[i][j+1]=n+1; else if(M[i][j+1]>n+1) M[i][j+1]=n+1;} {if (M[i+1][j]==0) M[i+1][j]=n+1; else if(M[i+1][j]>n+1) M[i+1][j]=n+1;} {if (M[i][j-1]==0) M[i][j-1]=n+1; else if(M[i][j-1]>n+1) M[i][j-1]=n+1;} {if (M[i-1][j]==0) M[i-1][j]=n+1; else if(M[i-1][j]>n+1) M[i-1][j]=n+1;} } } } 3.给最优路径附上特定的值,方便最后的输出. for (;;) { if(M[q.x+1][q.y]==(n-1)) {q.x++;M[q.x][q.y]=0;} else {if(M[q.x][q.y-1]==(n-1)) {q.y--;M[q.x][q.y]=0;} else {if(M[q.x-1][q.y]==(n-1)) {q.x--;M[q.x][q.y]=0;} else if(M[q.x][q.y+1]==(n-1)) {q.y++;M[q.x][q.y]=0;}}} n--; if(e.x==q.x&&e.y==q.y) {M[e.x][e.y]=0; break;} } 实验报告 【实验名称】项目一迷宫问题的求解 【实验目的】 1.了解栈的基本操作以及充分理解栈的特点。熟悉掌握栈的基本操作和结构体 的运用。 2.学会用栈或者递归方法解决迷宫问题。 【实验原理】 1.本次实验中，以二维数组maze[row][col]表示迷宫，0表示通路，1表示墙，在构建迷宫时，为了清晰显示，在最外层添加一圈墙。 2.算法的核心思想是利用栈后进先出的特点，对迷宫进行探索，如果此路可行，则将此坐标的信息入栈，如果此路不通，则将此坐标的信息出栈。 3.输入形式：根据控制台的提示，依次输入迷宫的行数、列数，然后输入迷宫，再输入入口和出口坐标。 4.输出形式：由用户选择，由递归、非递归两种求解方式输出一条迷宫通路。以非递归方式会显示一种求解方案，并给出相应的三元组序列和迷宫方阵；以递归方式则会显示出所有的路线。 【实验内容】 1.需求分析 （1）问题描述 以一个m*n的长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍。设计一个程序，对任意设定的迷宫，求出一条从入口到出口的通路，或得出没有通路的结论。 要求以递归和非递归两种方式分别输出一条迷宫的通路，以带方向坐标和迷宫图像表示。 （2）基本要求 （1）首先实现一个以链表作存储结构的栈类型，然后编写一个求解迷宫的非递归程序。求得的通路以三元组（i，j，d）的形式输出。其中：（i，j）指示迷宫中的一个坐标，d表示走到下一坐标的方向。如，对于下列数据的迷宫，输出一条通路为：（1，1，1），（1，2，2），（2，2，2），（3，2，3），（3，1，2），…。 （2）编写递归形式的算法，求得迷宫中所有可能的通路。 （3）以方阵形式输出迷宫及其通路。 2.概要设计 （1）栈的抽象数据类型 ADT Stack{ 数据对象：D={ai|ai∈ElemSet, i=1,2, …,n, n≥0} 数据关系：R1={ //回溯法之N皇后问题当N>10，就有点抽了~~ /*结果前total行每行均为一种放法，表示第i行摆放皇后的列位置，第total+1行，输出total*/ #include 计算机科学与技术专业《数据结构与算法》 课程设计报告 设计题目：迷宫路径求解专业： 学号： 姓名： 指导老师： 完成日期： 一、需求分析 迷宫路径求解：利用二维数组创建一个迷宫。编写一个算法能够完成输出走出迷宫的所有的路径。 二、设计概要 maze[9][11]={ {1,1,1,1,1,1,1,1,1,1,1}, {1,0,1,1,1,1,1,0,0,0,1}, {1,0,0,0,0,1,0,0,1,0,1}, {1,0,1,1,0,1,0,1,1,0,1}, {1,0,0,1,0,0,0,1,0,0,1}, {1,1,0,1,1,1,0,1,0,1,1}, {1,1,0,1,1,1,0,1,0,1,1}, {1,1,0,0,0,0,0,0,0,0,1}, {1,1,1,1,1,1,1,1,1,1,1} }; 一个迷宫用m*n的二维数组存储，用“0”代表可以通行，用“1”代表墙壁，不可通行。迷宫有一个路口和一个出口，设入口坐标为（x1，y1），出口坐标（x2，y2）。从迷宫的一个位置向东、南、西、北任意一个方向移动一步，前面若为“0”，则可前进一步，否则通行受阻，不能前进，则按顺时针改变为下一个方向。用一个switch语句控制方向的选择, 如： switch(d) {case 0:i=stack[s].i-1;j=stack[s].j;break; /*向西*/ case 1:i=stack[s].i;j=stack[s].j+1;break; /*向南*/ case 2:i=stack[s].i+1;j=stack[s].j;break; /*向东*/ case 3:i=stack[s].i;j=stack[s].j-1;break; /*向北*/ } 在走的同时需要用一个与迷宫同样大小的二维数组mark来存储走过的路径。避免重走已经走不通的老路。 为了寻找从入口点到出口点的一条通路，首先从入口点出发，按照四个方向的次序，当可以向前移动一步时，就把当前的的坐标入栈，若从当前位置无法继续前进时就做出栈操作，从上一次的位置的下一个方向，向前试探前进。如果当前位置为出口时，则表明找到一条路径从入口到出口的路径，打印出路径。若做出栈时为空，且当前位置不是出口，则表明没有找到一条可以出去的路径。结束程序。 三、详细设计 1.数据类型的定义； struct BinTreeNode { int i; int j; int d; 河南科技大学 课程设计报告 课程名称：算法设计与分析 设计题目：罗密欧与朱丽叶迷宫求解问题 院系：电子信息工程学院 专业：计算机科学与技术 班级：计算机092班 学生姓名: 学号:09************ 起止日期: 2011年5月28日 - 2011年6月3日指导教师:孙士保、张明川、冀治航 课程设计题目罗密欧与朱丽叶的迷宫问题 姓名*** 学号091040602** 班级092班系别电子信息工程学院专业计算机科学与技术 组别1人组长*** 组员*** 指导教师姓名孙士保、张明川、冀治航 课程设计目的 进一步巩固C程序设计和算法设计与分析的基础知识，提升结构化程序、模块化程序设计的方法和能力，深入理解数据结构的基本理论，掌握数据存储结构的设计方法，掌握基于数据结构的各种操作的实现方法，训练对基础知识和基本方法的综合运用能力，增强对算法的理解能力，提高软件设计能力。在实践中培养独立分析问题和解决问题的作风和能力。 设计环境1. PC兼容机 2．Windows 2000/XP操作系统3．TC集成开发环境或其他C语言开发环境 课程设计要求和任务要求：1．熟练掌握回溯法，能够利用回溯法解决实际问题； 2．使用文件进行存储和管理。程序启动时可从文件中读取信息，或从键盘输入信息；运行过程中也可对文件进行存取；退出前可选择将部分信息保存 到文件中； 3．不同的功能使用不同的函数实现（模块化），对每个函数的功能和调用接口要注释清楚。对程序其它部分也进行必要的注释。 4．对系统进行功能模块分析、画出总流程图和各模块流程图； 5．用户界面要求使用方便、简洁明了、美观大方、格式统一。所有功能可以反复使用，最好使用菜单； 6．通过命令行相应选项能直接进入某个相应菜单选项的功能模块； 7．所有程序需调试通过。 任务：完成罗密欧与朱丽叶的迷宫问题.设计内容包括： 1．确定能对给定的任何位置的罗密欧都能够找到一条通向朱丽叶的路线； 2．程序能够演示一条罗密欧找到朱丽叶的路线过程等。 课程设计工作进度计划 序号起止日期工作内容 1 下发任务书，分组，选定课题，查阅相关资料 2 总体设计，划分模块 3 编制源程序 4 上机调试，修改、完善系统 5 程序检查 6 撰写说明书 #include if(s->top - s->base >= s->size) { s->base = (lujing *)realloc(s->base, (s->size+INCREMENT)*sizeof(lujing)); if(!s->base) return -1; s->top = s->base+s->size; s->size += INCREMENT; } *s->top++ = e; return 0; } int pop(SqStack *s,lujing *e) { if(s->top == s->base) return -1; *e = *(--s->top); return 0; } int isEmpty(SqStack *s) { if(s->base == s->top) return 1; else return 0; } int pass( Maze maze,zuobiao dqzb) { if (maze.sz[dqzb.r][dqzb.c]==1) return 1; // 如果当前位置是可以通过，返回1 else return 0; // 否则返回0 } void footPrint(Maze &maze,zuobiao dqzb) { maze.sz[dqzb.r][dqzb.c]=9; } void markPrint(Maze &maze,zuobiao dqzb) { maze.sz[dqzb.r][dqzb.c]=4; } zuobiao nextPos(zuobiao dqzb, int Dir) { 深圳大学实验报告 课程名称：算法分析与复杂性理论 实验项目名称：八皇后问题 学院：计算机与软件学院 专业：软件工程 指导教师：杨烜 报告人：学号：班级：15级软工学术型 实验时间：2015-12-08 实验报告提交时间：2015-12-09 教务部制 一．实验目的 1.掌握选回溯法设计思想。 2.掌握八皇后问题的回溯法解法。 二．实验步骤与结果 实验总体思路： 根据实验要求，通过switch选择八皇后求解模块以及测试数据模块操作，其中八皇后模块调用摆放皇后函数模块，摆放皇后模块中调用判断模块。测试数据模块主要调用判断模块进行判断，完成测试。用一维数组保存每行摆放皇后的位置，根据回溯法的思想递归讨论该行的列位置上能否放置皇后，由判断函数Judge()判断，若不能放置则检查该行下一个位置。相应结果和过程如下所示（代码和结果如下图所示）。 回溯法的实现及实验结果： 1、判断函数 代码1： procedure BTrack_Queen(n) 皇后问题 2.测试数据0.退出**"< #include void PutOut_all(); //找所有路径和最短路径并输出所有路径 void PutOut_Grap(); //输出迷宫图形 void Migong(); //使用迷宫 void main() { cout<<"*******************欢迎使用迷宫系统 *******************\n"; while(1) { int i; cout<<"请选择你要的操作：\n" <<"1.使用系统自带迷宫\n" <<"2.使用新建迷宫\n" <<"0.退出\n"; cout<<"请输入："; cin>>i; switch(i) { case 1: Init_maze();Migong();break; case 2: NewCreat();Migong();break; case 0: return; 算法设计与分析课程设计罗密欧与朱丽叶的迷宫问题设计分析测试报告 程序算法设计说明书 一、前言 1、题目：罗密欧与朱丽叶的迷宫问题。 罗密欧与朱丽叶身处一个m×n的迷宫中，如图所示。每一个方格表示迷宫中的一个房间。这m×n个房间中有一些房间是封闭的，不允许任何人进入。在迷宫中任何位置均可沿8 个方向进入未封闭的房间。罗密欧位于迷宫的(p，q)方格中，他必须找出一条通向朱丽叶所在的(r，s)方格的路。在抵达朱丽叶之前，他必须走遍所有未封闭的房间各一次，而且要使到达朱丽叶的转弯次数为最少。每改变一次前进方向算作转弯一次。请设计和实现一个算法帮助罗密欧找出这些道路。 2、程序编制环境相关说明 硬件：装有windows操作系统的计算机 软件：Visual C++ 2008 二、程序主要算法设计分析说明 1、算法设计思路 用回溯法解迷宫问题时，用排列树表示其解空间比较合适。可行性约束函数减去不满足约束条件（x,y,z）已越界的子树。在排列树的第i+1层节点z处用board[z][x][y]记载所在的房间。当bool stepok(int x,int y,int z)返回为false时，以z为根的子树中所有子树都不满足约束条件，因而该子树中的解均为不可行解，故可将该子树剪枝。 算法调用递归方法void backtrack(int dep,int x,int y,int di)实现回溯搜索。void backtrack (int dep,int x,int y,int di)搜索排列树中第dep层子树。数组board[0][x][y]记录排列树中的节点信息。dirs记录当前节点对应的转弯数， best记录最少转弯数。 在算法void backtrack (int dep,int x,int y,int di)中，当i>n时，算法搜索至叶节点，其相应的转弯数dirs。如果dirs>best,则表示当前解优于最优解，此时更新best。当i≤n时，当前扩展节点位于是排列树的第i-1层。此时算法选择下一个要搜索的方向，以深度优先的方式递归地对相应子树进行搜。对于不满足上界约束的节点，则减去相应子树。 算法void backtrack (int dep,int x,int y,int di)动态地生成问题的解空间树。 时间复杂度为整个状态空间，即迷宫大小，O(m*n) 课程设计说明书 课程名称＿＿软件专题训练＿＿＿＿ 题目罗密欧与朱丽叶迷宫求解问题＿ 院系＿电子信息工程学院计算机系＿ 班级＿计算机科学与技术103班＿＿ 学生姓名＿＿＿＿＿＿＿＿＿＿＿ 指导教师＿孙士保、冀治航＿＿ 日期＿ 2012.5.21—2012.5.27＿＿ 课程设计任务书 课程名称＿＿算法设计与分析＿＿＿ 题目＿罗密欧与朱丽叶的迷宫问题 院系＿电子信息工程学院计算机系＿ 班级＿＿＿计算机103班＿＿＿＿＿ 学生姓名＿＿＿＿魏鹏超＿＿＿＿＿＿ 指导教师＿孙士保、冀治航＿＿ 日期＿ 2012.5.21—2012.5.27＿＿ 河南科技大学 课程设计报告 课程名称＿＿软件专题训练＿＿＿＿ 题目＿罗密欧与朱丽叶的迷宫问题 院系：电子信息工程学院计算机系 专业：计算机科学与技术 班级：计算机10级 学生姓名:学号: 起止日期: 2012年5月21日~ 2012年5月27日指导教师:孙士保、冀治航 目录 第一章需求分析 (4) 1.1课程设计题目 (4) 1.2 课程设计任务及要求 (4) 1.3运行环境及开发工具 (4) 第二章概要设计 (5) 2.1系统流程图 (5) 第三章详细设计 (6) 3.1函数划分 (6) 3.2函数之间的关系 (6) 第四章系统调试与操作说明 (7) 4.1系统调试及操作说明 (7) 第五章课程设计总结体会 (8) 5.1课程设计总结 (8) 5.2致谢 (8) 5.3参考文献 (8) 第一章需求分析 1.1课程设计题目 罗密欧与朱丽叶的迷宫问题 1.2 课程设计任务及要求 1、对于给定的罗密欧与朱丽叶的迷宫，编程计算罗密欧通向朱丽 叶的所有最少转弯道路 2、程序能够演示一条罗密欧找到朱丽叶的路线过程等 罗密欧与朱丽叶的迷宫。罗密欧与朱丽叶身处一个m×n的迷宫中，如图所示。每一个方格表示迷宫中的一个房间。这m×n个房间中有一些房间是封闭的，不允许任何人进入。在迷宫中任何位置均可沿8 个方向进入未封闭的房间。罗密欧位于迷宫的(p，q)方格中，他必须找出一条通向朱丽叶所在的(r，s)方格的路。在抵达朱丽叶之前，他必须走遍所有未封闭的房间各一次，而且要使到达朱丽叶的转弯次数为最少。每改变一次前进方向算作转弯一次。请设计一个算法帮助罗密欧找出这样一条路。 1.3运行环境及开发工具 硬件：装有windows操作系统的计算机 软件：Visual C++6.0 数据结构实验报告 题目：用栈解决迷宫问题 ．需求分析 1．以结构体 Maze 表示迷宫，其中 pos 表示该位置是否有障碍； freq 记录该位置被经过的次数；数组 move 表示下一步的方向。 2. 本程序自动随机生成一个12 × 12大小的迷宫，字符“ H”表示有障碍，空符表示通 路。 3. 迷宫的入口为左上角，出口为右下角。 4. 本程序只求出一条成功的通路。 .概要设计 为了实现上述操作，以栈为存储结构。 本程序包含三个模块： 1)主程序模块 :实现人机交互。 2)迷宫生产模块:随机产生一个12× 12的迷 宫。 3)路径查找模块：实现通路的查找。 4)求解迷宫中一条通路的伪代码： do{ 若当前位置可同，则{ 将当前位置插入栈顶；若该位置是出口位置，则结束；否则切换当前位置的东临方块为新的当前位置；} 否则 { 若栈不空且栈顶位置尚有其他方向未被探索，则设定新的的当前位置为沿顺时针 方向旋转找到的栈顶位置的下一相邻块若栈不空但栈顶位置的四周均不可通， 则{ 删去栈顶位置； 若栈不空，则重新测试新的栈顶位置，直至找到一个可通的相邻块或出栈 至栈空。 } } } while( 栈不空 ) 三. 详细设计栈的设计： typedef struct { Node *base,*top; int length; }Stack; Stack *initstack(); // 初始化栈 void printstack(Stack *s); // 打印栈 Status destroy(Stack *); // 销毁整个栈 Status deltop(Stack *s); // 出栈 Status pushelem(Stack *,ElemType ,ElemType); // 进栈 1. 主程序模块： int main() { printf(" 随机产生一个12× 12 的迷宫， X 字符表示障碍，空符表示通路： \n"); Maze a[N][N]; makemaze(a); printf(" 输入回车键显示路径 ,* 字符表示路径。 \n"); getchar(); findpath(a); while(1); return 0; 算法分析与设计实验报告 实验内容：N皇后问题 实验时间：2013.12.3 姓名：杜茂鹏 班级：计科1101 学号：0909101605 一、实验内容及要求 在n×n格的棋盘上放置彼此不受攻击的n个皇后，按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。 二、实验目的 1.巩固和加深对回溯法的理解 2.了解递归和迭代法在回溯法中的应用 三、算法分析 1.理解皇后不被攻击的条件：n后问题等价于在n*n格的棋盘上放置n个皇后，任何两个皇后不能放在同一行或同一列或同一斜线上。 2.算法模块简要分析 用数组存储皇后的位置，将i设置为0. Int place(*x,n) :数组x[] 用来表示列数，n为皇后个数，用来判断皇后是否被攻击，判断的条件是（x[i]-x[n]==i-n||x[i]-x[n]==n-i||x[i]==x[n]）即用来判断“同一行或同一列或同一斜线上”。 Int print(*x,n):打印皇后解的空间。 Int iniprint(*x,n):初始化打印函数，相当于对棋盘初始化。将可以放皇后的位置记为“1”，不放皇后的位置记为“0”。 Int Nqueen(int n):n皇后问题求解，如果满足一组可行解，sum++。Int i=0,如果x[i]>=n的时候即进行下一行，i++；当i=n时， sum++；输出该组可行解的个数和位置的矩阵。并且i--，回溯到上一层继续搜索可行解。 四、运行结果及分析 1、三皇后没有可行解 2、 2.4个皇后有2个可行解 3.5皇后有10个可行解 五、源代码 #include 求迷宫问题就是求出从入口到出口的路径。在求解时,通常用的是“穷举求解”的方法,即从入口出发,顺某一方向向前试探,若能走通,则继续往前走；否则沿原路退回,换一个方向再继续试探,直至所有可能的通路都试探完为止。为了保证在任何位置上都能沿原路退回(称为回溯),需要用一个后进先出的栈来保存从入口到当前位置的路径。 首先用如图所示的方块图表示迷宫。对于图中的每个方块,用空白表示通道,用阴影表示墙。所求路径必须是简单路径,即在求得的路径上不能重复出现同一通道块。 为了表示迷宫,设置一个数组mg,其中每个元素表示一个方块的状态,为0时表示对应方块是通道,为1时表示对应方块为墙,如图所示的迷宫,对应的迷宫数组mg如下: int mg[M+1][N+1]={ /*M=10,N=10*/ {1,1,1,1,1,1,1,1,1,1}, {1,0,0,1,0,0,0,1,0,1}, {1,0,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,1}, {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} }; 伪代码： c语言描述如下： void mgpath() /*路径为:(1,1)->(M-2,N-2)*/ { int i,j,di,find,k; top++; /*初始方块进栈*/ Stack[top].i=1; Stack[top].j=1; Stack[top].di=-1; mg[1][1]=-1; while (top>-1) /*栈不空时循环*/ { i=Stack[top].i; j=Stack[top].j; di=Stack[top].di; if (i==M-2 && j==N-2) /*找到了出口,输出路径*/ { printf("迷宫路径如下:\n"); for (k=0;k<=top;k++) { printf("\t(%d,%d)",Stack[k].i,Stack[k] .j); if ((k+1)%5==0) printf("\n"); }c语言实现迷宫最优路径选择
c语言迷宫问题的求解(栈和递归)
回溯法之N皇后问题(C语言)
迷宫路径求解
算法实验报告：罗密欧与朱丽叶迷宫求解
栈的应用-迷宫问题-数据结构(C语言版)-源代码(直接运行)
算法实验 递归回溯解八皇后问题
迷宫-最短路径及所有路径的问题
迷宫问题
罗密欧与朱丽叶迷宫求解问题
迷宫问题实验报告用栈解决迷宫问题
n皇后问题算法实验报告
求解迷宫问题