请教高手C++数据结构回溯算法解,迷宫问题

//迷宫用栈做的
#include "stdio.h"
#include "stdlib.h"
#define INITSIZE 100
#define STACKINCRESMENT 10
#define WALL 9999
struct stack
{
int *base;
int *top;
int size;
};

struct mi
{
int val;
bool tag;
int di;
};

void init_stack(stack *);
void push(stack*,int);
int pop(stack*);
int getop(stack*);
int palace(stack*, mi p[10][10]);

int main()
{
int e;
int ch;
struct mi p[10][10];
for(int i=0;i<10;i++)
{
p[0][i].val = 0;
p[i][0].val = 0;
p[9][i].val = 0;
p[i][9].val = 0;
}
for(int j=1;j<9;j++)
{
for(int k=1;k<9;k++)
{
p[j][k].val = 1;
}
}
p[1][3].val = p[1][7].val =0;
p[2][3].val = p[2][7].val =0;
p[3][5].val = p[3][6].val =0;
p[4][2].val = p[4][3].val = p[4][4].val =0;
p[5][4].val = 0;
p[6][2].val = p[6][6].val =0;
p[7][2].val = p[7][3].val = p[7][4].val =0;
p[7][6].val = p[7][7].val =0;
p[8][1].val = 0;

for(int m=0;m<10;m++)
{
for(int n=0;n<10;n++)
{
printf(" %d ",p[m][n]);
p[m][n].tag =0;
p[m][n].di =0;
}
printf("\n");
}

struct stack *s = (stack*)malloc(sizeof(stack));
init_stack(s);
palace(s, p);

printf("\none path is: \n");
for(int a=0;*s->base<89;s->base++)
{
printf("-a");
printf("%d",*s->base);

}

return 0;
}

void init_stack(stack *s)
{
s->base = (int*)malloc(INITSIZE*sizeof(stack));
if(!s->base) printf("malloc error:");
*s->base++ = 0;//栈底为0
s->top = s->base;
s->size = INITSIZE;
}

void push(stack* s, int e)
{
if(s->top - s->base >= INITSIZE)
{
s->base = (int*)realloc(s->base,(s->size+STACKINCRESMENT)*sizeof(stack));
s->top = s->base + s->size;
s->size += STACKINCRESMENT;
}
*s->top++ = e;
}

int pop(stack* s)
{
if(s->top == s->base) printf("error\n");
int e = 0;
e = *--s->top;
*s->top = NULL;
return e;
}

int getop(stack* s)
{
if(s->top == s->base) printf("error\n");
int e = 0;
stack *p = s;
e = *(--p->top);
++p->top;
return e;
}

int palace(stack* s, mi p[10][10])
{
int i=1;
int j=1;
int k;
int r;
push(s,i*10+j);
j++;
do
{
r=getop(s);
if(r==88) return 0;
if(p[i][j].val>0 && p[i][j].di<1)
{
push(s,i*10+j);
p[i][j].tag = 1;
p[i][j].di = 1;
j++;
}
else
{
k = getop(s);
i = k/10;
j = k%10;
if(p[i][j].di==1 && (p[i][j].val>0))
{
p[i][j].di++;
i++;
}
if(p[i][j].di==2 && (p[i][j].val>0))
{
p[i][j].di++;
j--;
if(p[i][j].di>0) { k = pop(s);}
}
}

}while(1);
}

//迷宫用栈做的
#include
"stdio.h"
#include
"stdlib.h"
#define
INITSIZE
100
#define
STACKINCRESMENT
10
#define
WALL
9999
struct
stack
{
int
*base;
int
*top;
int
size;
};
struct
mi
{
int
val;
bool
tag;
int
di;
};
void
init_stack(stack
*);
void
push(stack*,int);
int
pop(stack*);
int
getop(stack*);
int
palace(stack*,
mi
p[10][10]);
int
main()
{
int
e;
int
ch;
struct
mi
p[10][10];
for(int
i=0;i<10;i++)
{
p[0][i].val
=
0;
p[i][0].val
=
0;
p[9][i].val
=
0;
p[i][9].val
=
0;
}
for(int
j=1;j<9;j++)
{
for(int
k=1;k<9;k++)
{
p[j][k].val
=
1;
}
}
p[1][3].val
=
p[1][7].val
=0;
p[2][3].val
=
p[2][7].val
=0;
p[3][5].val
=
p[3][6].val
=0;
p[4][2].val
=
p[4][3].val
=
p[4][4].val
=0;
p[5][4].val
=
0;
p[6][2].val
=
p[6][6].val
=0;
p[7][2].val
=
p[7][3].val
=
p[7][4].val
=0;
p[7][6].val
=
p[7][7].val
=0;
p[8][1].val
=
0;
for(int
m=0;m<10;m++)
{
for(int
n=0;n<10;n++)
{
printf("
%d
",p[m][n]);
p[m][n].tag
=0;
p[m][n].di
=0;
}
printf("\n");
}
struct
stack
*s
=
(stack*)malloc(sizeof(stack));
init_stack(s);
palace(s,
p);
printf("\none
path
is:
\n");
for(int
a=0;*s->base<89;s->base++)
{
printf("-a");
printf("%d",*s->base);
}
return
0;
}
void
init_stack(stack
*s)
{
s->base
=
(int*)malloc(INITSIZE*sizeof(stack));
if(!s->base)
printf("malloc
error:");
*s->base++
=
0;//栈底为0
s->top
=
s->base;
s->size
=
INITSIZE;
}
void
push(stack*
s,
int
e)
{
if(s->top
-
s->base
>=
INITSIZE)
{
s->base
=
(int*)realloc(s->base,(s->size+STACKINCRESMENT)*sizeof(stack));
s->top
=
s->base
+
s->size;
s->size
+=
STACKINCRESMENT;
}
*s->top++
=
e;
}
int
pop(stack*
s)
{
if(s->top
==
s->base)
printf("error\n");
int
e
=
0;
e
=
*--s->top;
*s->top
=
NULL;
return
e;
}
int
getop(stack*
s)
{
if(s->top
==
s->base)
printf("error\n");
int
e
=
0;
stack
*p
=
s;
e
=
*(--p->top);
++p->top;
return
e;
}
int
palace(stack*
s,
mi
p[10][10])
{
int
i=1;
int
j=1;
int
k;
int
r;
push(s,i*10+j);
j++;
do
{
r=getop(s);
if(r==88)
return
0;
if(p[i][j].val>0
&&
p[i][j].di<1)
{
push(s,i*10+j);
p[i][j].tag
=
1;
p[i][j].di
=
1;
j++;
}
else
{
k
=
getop(s);
i
=
k/10;
j
=
k%10;
if(p[i][j].di==1
&&
(p[i][j].val>0))
{
p[i][j].di++;
i++;
}
if(p[i][j].di==2
&&
(p[i][j].val>0))
{
p[i][j].di++;
j--;
if(p[i][j].di>0)
{
k
=
pop(s);}
}
}
}while(1);
}

广搜即可。

用图论中的广度优先搜索!

数据结构迷宫问题 C++算法~

/*百度作个东西能用点心么 代码区的代码丑爆了 *程序的框架:宏定义,函数声明,main函数,函数实现 * ========================================================= * Filename: maze.c * Description: 基于栈寻找迷宫路径 * * ========================================================= */#include #include #include #define ROW 10 /*迷宫大小*/#define COL 10#define STACKSIZE 100 /*栈大小*/#define ISEND(n) ((n).p.x==ROW-1 &&(n).p.y==COL-1)/*判断该位置是否为出口*/#define ISVALID(n) ((n).visit== NO &&((n).path== YES))/*判断该位置是否可走*/#define ISEMPTY(s) (s.top==0)enum Bool{ NO, YES};/*--------------------------------------------------- * 棋盘由R*C 个节点构成,每个节点包含的信息由: * 节点位置(x,y) , 是否是死路(yes/no) , 是否被访问过(yes/no) *---------------------------------------------------*/typedef struct point Point;typedef struct node Node;typedef struct maze Maze;struct point{ int x,y;};struct node{ Point p; int path; int visit;};struct maze{ Node ma[ROW][COL];};/*--------------------------------------------------- * 1.初始化迷宫,每个节点有4/5的概率可走 * 2.输出迷宫的构造 *---------------------------------------------------*/void Initmaze(Maze *m);void printmaze(Maze m);/*--------------------------------------------------- * 存储访问过程的栈及相应操作 *---------------------------------------------------*/typedef struct stack Stack;struct stack{ Node *no[STACKSIZE]; int top;};Stack s;void push(Node * n);Node* pop();void print(Stack s);/*--------------------------------------------------- * find path based on stack 这个是关键函数,基于回溯思想 *---------------------------------------------------*/int findpath(Maze *m,Node *n);int main(){ Maze m; Initmaze(&m); printmaze(m); Node *n=m.ma[0]; if(findpath(&m,n)) print(s);}void Initmaze(Maze *m){ int i,j; srand(time(NULL)); /* initialize random seed */ for(i=0;ima[i][j].visit=NO; m->ma[i][j].p.x=i; m->ma[i][j].p.y=j; m->ma[i][j].path=((i==0 && j==0) || (i==ROW-1 && j==COL-1) || rand()%ROW visit==NO){ n->visit=YES; push(n); } int current_x=n->p.x; int current_y=n->p.y; if(current_y+1ma[current_x][current_y+1])) /* rigth valid */ n=m->ma[current_x]+current_y+1; else if(current_x+1ma[current_x+1][current_y])) /* down valid */ n=m->ma[current_x+1]+current_y; else if(current_x-1>=0 && ISVALID(m->ma[current_x-1][current_y])) /* up valid */ n=m->ma[current_x-1]+current_y; else if(current_y-1>=0 && ISVALID(m->ma[current_x][current_y-1])) /* left valid */ n=m->ma[current_x]+current_y-1; else{ pop(); /* current n is not valid */ if(!ISEMPTY(s)) /* n point to pre */ n=s.no[s.top-1]; else{ printf("stack empty.
"); n=NULL; break; } } } if(n==NULL) return 0; else{ push(n); return 1; }}void push(Node * n){ s.no[s.top++]=n;}Node * pop(){ if(s.top!=0) return s.no[--s.top]; else{ printf("%s","stack empty
"); return NULL; }}void print(Stack s){ int iter; for(iter=0;iterp.x,s.no[iter]->p.y);}void printmaze(Maze m){ int i,j; for(i=0;i<ROW;i++) for(j=0;j<COL;j++) printf("%d%s",m.ma[i][j].path,(j==COL-1)?"
":" ");}给C行么,改改就是了。
output:如果无路径


如果有路径.

用纯C写成的.关系迷宫的产生自己写一个函数吧.

#include
#include

int a[6][10]={ {0,1,1,1,1,1,1,1,1,1},
{0,1,0,0,1,0,0,0,0,1},
{0,0,0,1,1,0,0,1,0,1},
{0,1,1,0,0,0,1,1,0,1},
{0,0,0,0,1,0,0,0,0,1},
{1,1,1,1,1,1,1,1,0,0}
};

int b[200],c[200];
int step=0,method=0;


int walk(int x,int y);
void out(void);

void main()
{
int i;

for(i=0;i<200;++i)
b[i]=c[i]=-1;

walk(0,0);

printf("
There are %d methods.",method);
printf("
");
}

void out(void)
{
int i;

printf("
The NO.%d method:
",method+1);

for(i=0;i<step;++i)
{
if(i%5==0)
printf("
");
printf("(%d,%d)",b[i],c[i]);
}
printf("

");
++method;
}

int walk(int x,int y)
{
int i,j;

a[y][x]=1;
b[step]=x;
c[step++]=y;

if(x==9 && y==5)
{
out();
}

if((i=x)>=0 && (i=x)<=9 && (j=y+1)<=5 && !a[j][i])
if(walk(i,j))
return 1;
if((i=x+1)=0 && (j=y)<=5 && !a[j][i])
if(walk(i,j))
return 1;
if((i=x-1)>=0 && (j=y)>=0 && (j=y)<=5 && !a[j][i])
if(walk(i,j))
return 1;
if((i=x)>=0 && (i=x)=0 && !a[j][i])
if(walk(i,j))
return 1;

/*fail*/
a[y][x]=0;
b[step]=c[step--]=-1;
return 0;
}

#18520482253# visual c++数据结构高手请进!!!!!!!!!!!!!! - ******
#年淑# #include

#18520482253# 请教高手c++ 寻找路线问题 - ******
#年淑# #include <iostream> using namespace std; char map[][9]={"XXXXXXXX", "XS.....X", "X..X..XX", "X.X....X", "X..XX..X", "XXXX...X", "X...G..X", "XXXXXXXX"}; int xz[]={1,0,-1,0}; int yz[]={0,1,0,-1}; int counts=0; int countsmin=8;...

#18520482253# C++数据结构 - ******
#年淑# 核心代码见reverselink(),如果不懂hi我!很明显空间复杂度为O(n),因为我只有一次遍历链表,就是while循环遍历它. 核心思想: 1.链表是必须带有头节点的; 2.先把头节点取出来(head = L),并且断链(head->next = NULL),并记...

#18520482253# 一段C++数据结构代码,求解!! - ******
#年淑# 是C++ 的输出文件流类,这样声明后 out 与cout 具有同等的输出作用

#18520482253# C++数据与结构,二叉树递归找双亲算法 - ******
#年淑# 可以在中序遍历的基础上,加几条指令.n表示层,初始值为0 下列算法是递归嵌套. 1、n++,遍历当前节点的左子树 2、n--,访问当前节点,如果节点的data==x,那么(意味着找到节点了)打印节点层数 3、n++,遍历当前节点的右子树 递归结束后,如果没有找到X节点不要忘了,打印一下没有找到.

#18520482253# C、C++、数据结构、算法 - ******
#年淑# 我建议还是学数据结构和算法 数据结构和算法只是一种思维方法 是任何语言都必须的 C和C++只是个工具 就好比你买了辆客车用来代步 你接下来是该学开车呢还是再去买一辆轿车呢?你不会开车买再多车也没用 而数据结构算法什么的就是开车的方法 任何程序到后来都归咎到了数据结构和算法

#18520482253# 求一C++数据结构算法:已知线性表中的元素以值递增有序排列,并以单链表作为储存结构.试写一高效算法,删除表中所以值相同的多余元素(使得表中所有元素都),同时释放被删除节点空间,并分析算法定的时间复杂度 - ******
#年淑# #includetypedef struct _list { int v; struct _list* n; }*node; node create(int* beg, int* end) // 从数组创建链表 { node root, *cur; cur = &root; while(beg != end) { *cur = (node)malloc(sizeof(_list)); (*cur)->v = *beg++; (*cur)->n = NULL; cur = &(*cur)->n; } ...

#18520482253# 关于八皇后问题的c++代码,数据结构 - ******
#年淑# 用八个for语句#include"iostream.h"#include"math.h"int judge(int x[]){ int flag=0; for(int m=0;m<7;m++) for(int n=m+1;n<8;n++) { if(x[m]==...

#18520482253# 请教C++高手 - ******
#年淑# 这个函数就是返回一个指向一个Student对象的指针这个Student对象的一个属性是Jenny.tudent sb("Jone"); 这一句话,在这个函数中没有什么用的!!

  • 信息学奥林匹克竞赛高中组c语言考点
  • 答:更加高级一些的算法是结合数据结构学的。栈结构,队列还好,比较容易理解。链表的话,不难,但是有点麻烦,用得少。树很重要,肯定要学。和二叉树有关的堆必须看,以后挺有用,堆排序也是一个高效的排序方法。有的递归回...

  • 数据结构面试常见问题
  • 答:3.hash算法 4.一些算法设计思想。 贪心算法,分治算法,动态规划算法,随机化算法,回溯算法等。这些可以根据具体的例子程序来复习。 5.STL STL(Standard Template Library)是一个C++领域中,用模版技术实现的数据结构和算法库,已经包含在了...

  • c语言重点
  • 答:(1) 下面叙述正确的是(C)A. 算法的执行效率与数据的存储结构无关B. 算法的空间复杂度是指算法程序中指令(或语句)的条数C. 算法的有穷性是指算法必须能在执行有限个步骤之后终止 D. 以上三种描述都不对(2) 以下数据结构中不...

  • 计算机基础最全自学指南!
  • 答:《算法(第4版)》 算法领域的经典参考书,包含了经过几十年演化而成的算法核心知识体系。 书中讲解了多种算法和数据结构,让你能够在各种计算机环境下实现、调试并应用它们。 作为算法领域经典的参考书,全面介绍了关于算法和数据结构的必备...

  • 数据结构与算法是什么?推荐一本数据结构的书,谢了
  • 答:●专用一章来讨论算法设计技巧,包括贪婪算法、分治算法、动态规划、随机化算法以及回溯算法 ●介绍了当前流行的论题和新的数据结构,如斐波那契堆、斜堆、二项队列、跳跃表和伸展树 ●安排一章专门讨论摊还分析,考查书中介绍的...

  • ...我现在知道有数据结构语法算法,但是概念很模糊,不知道要学什么才_百...
  • 答:从基础开始学起,学扎实 引用各类数据库,变量,顺序,选择,循环,栈,文件,树 算法 穷举,回溯,递归,递推,深搜,广搜,动规多了去了 主要是实践。多做题进行锻炼 先把一门学好 JAVA,VB,pascal这类和c在思路上...

  • 谁有关于二级c公共基础知识的东西,发一个给我
  • 答:算法基本设计方法:列举法、归纳法、递推、递归、减斗递推技术、回溯法。算法复杂度:算法时间复杂度和算法空间复杂度。算法时间复杂度是指执行算法所需要的计算工作量。算法空间复杂度是指执行这个算法所需要的内存空间。1.2 数据结构的...

  • 数据结构题目,广度优先和深度优先
  • 答:但也看到,无论问题的内容和性质以及求解要求如何不同,它们的程序结构 都是相同的,即都是深度优先算法(一)和深度优先算法(二)中描述的算法结 构,不相同的仅仅是存储结点数据结构和产生规则以及输出要求。(2)深度...

  • pascal语言`要从那里开始入手啊`
  • 答:第十二章 常用算法 穷举法 不同进制数的转换和应用 高精度计算 数据排序(二分法,希尔法,选择排序,基数排序)递推与递归 回溯算法 试题的知识范围 一. 初赛内容与要求:计 基 算 本 机 常 的 识 1.计算机和信息...

  • 我想问一下编写软件需要哪些算法
  • 答:迭代是数值分析中通过从一个初始估计出发寻找一系列近似解来解决问题(一般是解方程或者方程组)的过程,为实现这一过程所使用的方法统称为迭代法。[编辑本段]算法分类 算法可大致分为基本算法、数据结构的算法、数论与代数...

    为传递更多家电数码信息,若有事情请联系
    数码大全网