数据结构迷宫问题 数据结构迷宫问题的求解算法

关于数据结构的一个迷宫程序的问题 高分

bg[i][j]=0;

我能看懂一半了

数据结构迷宫问题 数据结构迷宫问题的求解算法

void push( const Comparable &x ){ sPtr = new Node( x, sPtr ); }

我发现自己很牛B

楼主你是罪人

你把一个好好的数据条打乱成这样

小弟实在佩服

排版好了再来!

if(stackempty(result)||s->t-s->bt-result->b){

for(cur->dir++;cur->dir<5;cur->dif((num<156)&&(i!=M||j!=N))ir++){

setfillstyle(SOLID_FILL,15);

switch(cur->dir){

case 1:

老大,没if的签数码so(pull+3:)你这个不成立啊

晕!你这个排版有很大的问题啊 有些都根本无法理解或者不成立啊

就是嘛把代码改一下嘛,把必要的注释加上,过天我们再来看看

?????????????小弟不才,实在不懂啊!!!呵呵

为了确定得到的路径是最短路径

你的编程规范太了 又没注释 改下再贴上来吧

强，我这学期数据结构肯定挂了，大题一个没做 55555555555

看都看不懂额

数据结构中 为什么队列求解迷宫的解就是解 而栈不是

1 1 0 0 0 1 0 1

这是因为求解要使用宽度优先探索，所以要使用队列这种数据结构；而用栈实现的是深度优先搜索，深度优先能较快地找到一个解，它一般并不是解，除非你把所有的if (!in_maze) {解全找出来，再选出解，这样的maze.m=row;话效率就太低了。

数据结构与算法作业：用C语言编程随机生成一个迷宫，然后找出从入口到出口的路线图。急！

int way[100][2],wayn=0;/way数组是显示路线用的,wayn是统计走了几个格子/

#include }int

#include

#include

#include

/ define the size of maze /

#define MAX_COL 6

#define MAX_ROW 6

#define TRUE 1

#define FALSE 0

#define IS_USABLE(a, b) (a >= 0 && a < MAX_ROW) && (b >= 0 && b < MAX_COL) && maze[a][b] && (!my_maze[a][b])

static int maze[MAX_ROW][MAX_COL];

static int target_maze[MAX_ROW][MAX_COL];

static void init_maze();

static int move_to(int i, int j, int (maze)[MAX_COL], int count);

static void print_maze(int (maze)[MAX_COL]);

static void init_maze()

{int i, j;

srand((unsigned) time(NULL));

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

for(j = 0; j < MAX_COL; j++) {

maze[i][j] = (int) (rand() % 2);

}maze[1][0] = 1; / start point /

maze[MAX_ROW - 1][MAX_COL - 2] = 1; / end point /

}static int move_to(int _i,int _j, int (in_maze)[MAX_COL], int count) {

int my_maze[MAX_ROW][MAX_COL], i, j;

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

for(j = 0; j < MAX_COL; j++) {

my_maze[i][j] = 0;

}} else {

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

for(j = 0; j < MAX_COL; j++) {

my_maze[i][j] = in_maze[i][j];

my_maze[_i][_j] = count;

/ reach the end point /

if (_i == MAX_ROW - 1 && _j == MAX_COL - 2) {

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

for(j = 0; j < MAX_COL; j++) {

target_maze[i][j] = my_maze[i][j];

}return TRUE;

}if (IS_USABLE(_i - 1, _j)) {

if (move_to(_i - 1, _j, my_maze, count + 1))

rint False=0;eturn TRUE;

}if (IS_USABLE(_i + 1, _j)) {

if (move_to(_i + 1, _j, my_maze, count + 1))

return TRUE;

}if (IS_USABLE(_i, _j - 1)) {

if (move_to(_i, _j - 1, my_maze, count + 1))

return TRUE;

}if (IS_USABLE(_i, _j + 1)) {

if (move_to(_i, _j + 1, my_maze, count + 1))

return TRUE;

}return FALSE;

}static void print_maze(int (maze)[MAX_COL]) {

int i, j;

for (i = 0; i < MAX_ROW; i++) {

for(j = 0; j < MAX_COL; j++) {

if (maze[i][j] != 0)

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

else

printf(" ");

{while(1) {

init_maze();

printf("Out put the maze :\n");

print_maze(maze);

if (move_to(1, 0, NULL, 1)) {

printf("Out put the path :\n");

print_maze(target_maze);

break;

} else {

printf("No way!\n");

}VC60下正常运行

数据结构如何定义迷宫选出路径

迷宫源程序/

int move[8][2]={{-1,0},{-1,1},{0,1},{1,1,},{1,0},{1,-1},{0,-1},{-1,-1}};#include

#include

#include

#include

#include

#define N 20/迷宫的大小，可改变/

int oldmap[N][N];/递归用的数组,用全局变量节约时间/

int yes=0;/yes是判断是否找到路的标志,1找到，0没找到/

void Init(void);/图形初始化/

void Close(voiddirec=3;);/图形关闭/

void DrawPeople(int x,int y,int n);/画人工探索物图/

void PeopleFind(int (x)[N]);/人工探索/

void WayCopy(int (x)[N],int (y)[N]);/为了8个方向的递归，把旧迷宫图拷贝给新数组/

int FindWay(int (x)[N],int i,int j);/自动探索函数/

void MapRand(int (x)[N]);/随机生成迷宫函数/

void PrMap(int (x)[N]);/输出迷e;宫图函数/

void Result(void);/输出结果处理/

void Find(void);/成功处理/

void NotFind(void);/失败处理/

void main(void)/主函数/

char ch;

clrscr();

C语言数据结构 老鼠走迷宫问题

{int i,j,x,y,k;

/ 迷宫矩阵

{int i,j;

1 1 1 1 1 1 1 1 1 1

/

1 0 0 0 0 1 0 0 0 1

1 1 1 0 0 1 0 1 0 1

1 0 0 0 1 0 0 0 0 1

1 0 0 0 0 1 0 1 0 1

1 1 0 1 0 0 0 0 0 1

1 0 0 1 1 1 0 1 1 1

1 1 0 0 0 1 0 0 0 1

1 1 1 1 1 1 1 1 1 1

#define m 7

#define n 8

void path()

{int maze[m+2][n+2] ;

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

int s[54][3];

int top=0;

int i,j,k,f=0;

int g,h,p;

for(i=0;i

for(j=0;j

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

maze[1][1]=2;

s[top][0]=1;

s[top][1]=1;

s[top][2]=0;

++top;

while(top!=0&&f==0)

{--top;

i=s[top][0];

j=s[top][1];

k=s[top][2];

while(k<4)

{g=i+move[k][0];

h=j+move[k][1];

if(g==m&&h==n&&maze[g][h]==0)

{for(p=0;p

printf("%3d,%d\n",s[p][0],s[p][1]);

printf("%3d,%d\n",i,j);

printf("%3d,%d\n",m,n);

f=1;

}//if

if(maze[g][h]==0)

{maze[g][h]=2;

s[top][0]=i;

s[top][1]=j;

s[top][2]=k;

++top;

i=g;

j=h;

k=0;

}//if

k=k+1;

}//while

}//while

if(f==0)

}//pathvoid main()

{path();

}

高分求数据结构迷宫问题

x=Laby[i].x;

#include

#include

#include

#define N 20

int aa[N][N];

int yes=0;

int x[100][2],n=0;

void fun1(int (aa)[N],int (a)[N]);

int fun(int (a)[N],int i,int j);

void begain(int (t)[N]);

void pr(int (t)[N],int nn);

void win(int (t)[N]);

void lose();

void main(void)

{int t[N][N];

begain(t);

pr(t,0);

fun(t,1,1);

if(yes)

win(t);

else

lose();

getch();

}void fun1(int (aa)[N],int (a)[N])

for(i=0#include;i

for(j=0;j

aa[i][j]=a[i][j];

}int fun(int (a)[N],int i,int j)

{if(i==N-2&&j==N-2)

{yes=1;

return;

}a[i][j]=1;

fun1(aa,a);

if(aa[i+1][j+1]==0&&!yes)

{fun(aa,i+1,j+1);

if(yes)

{x[n][0]=i,x[n++][1]=j;return;}

}fun1(aa,a)y=j+mazemove[k].dy;;

if(aa[i+1][j]==0&&!yes)

{fun(aa,i+1,j);

if(yes)

{x[n][0]=i,x[n++][1]=j;return;}

}fun1(aa,a);

if(aa[i][j+1]==0&&!yes)

{fun(aa,i,j+1);

if(yes)

{x[n][0]=i,x[n++][1]=j;return;}

}fun1(aa,a);

if(aa[i-1][j]==0&&!yes)

{fun(aa,i-1,j);

if(yes)

{x[n][0]=i,x[n++][1]=j;return;}

}fun1(aa,a);

if(aa[i-1][j+1]==0&&!yes)

{fun(aa,i-1,j+1);

if(yes)

{x[n][0]=i,x[n++][1]=j;return;}

}fun1(aa,a);

if(aa[i+1][j-1]==0&&!yes)

{fun(aa,i+1,j-1);

if(yes)

{x[n][0]=i,x[n++][1]=j;return;}

}fun1(aa,a);

if(aa[i][j-1]==0&&!yes)

{fun(aa,i,j-1);

if(yes)

{x[n][0]=i,x[n++][1]=j;return;}

}fun1(aa,a);

if(aa[i-1][j-1]==0&&!yes)

{fun(aa,i-1,j-1);

if(yes)

{x[n][0]=i,x[n++][1]=j;return;}

void begain(int (t)[N])

(cls);

randomize();

for(i=0;i

{for(j=0;j

{if(i==0||i==N-1||j==0||j==N-1)

t[i][j]=1;

else if(i==1&&j==1||i==N-2&&j==N-2)

t[i][j]=0;

else

t[i][j]=random(2);

}void pr(int (t)[N],int nn)

{int i,j,ii;

textcolor(RED);

gotoxy(1,1);

for(i=0;i

哥们，给我也发一份吧，1016537301@qq

数据结构 c语言 课程设计 小鼠走迷宫问题

printf("malloc

1、可以用“”来代表老鼠，“|”来代表墙，空格来代表路。每走一步用("cls")刷新一次屏幕。

i=1;

2、墙不可穿过代表，墙int main()与周围的格子没有边。

3、规定一个时间t，若在t步之内没有走到粮仓，则输出无解。

4、这个简单，无非就是修改条件，从而修改整个图。

5、所用路径可以用深搜（回朔）来解决，最短路就用广搜来解决。最短路也可以用Dijstra算法、floyd算法等，但广搜是最简单的。

具体的程序你自己实现吧，如果写不出来，就去请教一下你们学校的ACMer，他们应该会比较熟悉。加油吧。

请问你还保存着吗？

数据结构 迷宫问题算法

0;

//迷宫求解（自定义一个2维矩阵作为地图）

}printf("\n");

void Labyrinth()

{printf("自定义迷宫矩阵：\n");

iprintf("no path\n");nt a[10][10];

int i,j;

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

for(j=0;j<10;j++)

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

printf("\n");

int n=1;

int x,y;

Laby[1].x=x=1;

Laby[1].y=y=6;

Laby[1].step=1;

a[1][6]=2;

SqStack S;

InitStack(S);

Push(S,0);

Push(S,1);

while(GetTop(S))

{if(a[x][y]==100)

{printf("找到终点了!!!\n");

break;

}i++;

if(n==1)

a[x][y]=i;

if(a[x][y-1]==1||a[x-1][y]==100)

{Push(S,i);

Laby[i].x=x;

Laby[i].y=y=y-1;

Laby[i].step=i;

n=1;

continue;

}else if(a[x-1][y]==1||a[x-1][y]==100)

{Push(S,i);

Laby[i].x=x=x-1;

Laby[i].y=y;

Laby[i].step=i;

n=1;

continue;

}else if(a[x][y+1]==1||a[x][y+1]==100)

{Push(S,i);

Laby[i].x=x;

Laby[i].y=y=y+1;

Laby[i].step=i;

n=1;

continue;

}else if(a[x+1][y]==1||a[x+1][y]==100)

{Push(S,i);

Laby[i].x=x=x+1;

Laby[i].y=y;

Laby[i].step=i;

n=1;

continue;

}else

{Pop(S,i);

y=Laby[i].y;

a[x][y]=-1;

n=0;

if(!GetTop(S))

printf("没有找到出路!\n");

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

{for(j=0;j<10;j++)

printf("%d ",a[i][j]);

printf("\n");

我没有给出栈的代码，你自己应该有吧！

具体迷宫算法 就是如此 仅供参考

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

for(j=0;j//迷宫用栈做的

#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

};

void

init_stack(stack

);

void

push(stack,int);

int

pop(stack);

int

getop(stack);

int

palace(stack,

mi

p[10][10]);

int

main()

{int

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;

}struct

stack

s

=(stack)malloc(sizeof(stack));

init_stack(s);

palace(s,

p);

printf("\none

path

is:

\n");

for(int

{printf("-a");

printf("%d",s->base);

}return

}void

init_stack(stack

s)

{s->base

=(int)malloc(INITSIZEsizeof(stack));

if(!s->base)

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;

pop(stack

s)

{if(s->top

==

s->base)

printf("error\n");

int

e=

e=

--s->toptypedef struct;

s->top

=NULL;

return

getop(stack

s)

{if(s->top

==

s->base)

printf("error\n");

int

e=

stack

p

=s;

e=

(--p->top);

++p->top;

return

palace(stack

s,

mi

p[10][10])

{int

int

j=1;

int

k;

int

r;

push(s,i10+j);

do

{r=getop(s);

if(r==88)

return

if(p[i][j].val>0

&&

p[i][j].di<1)

{push(s,i10+j);

p[i][j].tag

=1;

p[i][j].di

=1;

}else

{if(direc!=1&&i

=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++解决迷宫问题

{x=i+mazemove[k].dx;

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

}drawman(x,y,len);

#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,mod=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("\nThere are %d mods.",mod);

printf("\n");

}void out(void)

{int i;

printf("\nThe NO.%d mod:\n",mod+1);

for(i=0;i

{if(i%5==0)

printf("\n");

printf("(%d,%d)\t",b[i],c[i]);

}printf("\n\n");

++mo0;d;

}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)<=9 && (j=y)>=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)<=9 && (j=y-1)>=0 && !a[j][i])

if(walk(i,j))

return 1;

/fail/

a[y][x]=0;

b[step]=c[step--]=-1;

return 0;

}

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌抄袭侵权/违法违规的内容， 12345678@qq.com 举报，一经查实，本站将立刻删除。