編程迷宮圖

A. 數據結構與演算法作業：用c語言編程隨機生成一個迷宮，然後找出從入口到出口的路線圖。急！

幾點說明：
1．本程序是動態的，運行後自動尋找迷宮出路
2.本程序對C語言剛學完的有很大的意義．
3.四周是牆,坐標(1,1)是入口,右下腳是出口
聲明:本程序用VC調試是無法通過的需要修改
本程序調試工具是TC.....................
#include "graphics.h"
#include "dos.h"
#include "stdlib.h"
#include "process.h"

#define MAX_COL 14/*定義迷宮大小*/
#define MAX_ROW 14

typedef struct
{ int vert;
int horiz;
}offsets;

mapture(int i,int j,int k);/*標記迷宮，（i,j）標記為k模式*/
initmaze();/*初始化迷宮數組*/
findmaze(int i,int j);/*找到了（i,j）可走，標記*/
mapmaze();/*畫出原始迷宮*/
int findpath(int row,int col);/*遞歸函數，找出迷宮路徑*/
mapbar();/*畫出方格*/
initgrap();/*初始化VGA*/
print();/*迷宮走完後，輸出是否成功 */

int startx=50,starty=50;/*畫圖的屏幕坐標*/
int maze[MAX_ROW][MAX_COL];
offsets move[8]={{0,1},{1,1},{-1,1},{1,0},{-1,0},{0,-1},{1,-1},{-1,-1}}; /*8個方向尋找*/

initmaze()/*初始化迷宮數組 */
{ int i,j;

for(i=0;i<MAX_ROW;i++)/*迷宮四周設置為1 代表牆*/
{ maze[i][0]=1;
maze[i][MAX_COL-1]=1;
}
for(i=0;i<MAX_COL;i++)
{ maze[0][i]=1;
maze[MAX_ROW-1][i]=1;
}
randomize();
for(i=1;i<MAX_ROW-1;i++)/*迷宮圖形隨機產生 1表示不通 0表示可行*/
for(j=1;j<MAX_COL-1;j++)
{
maze[i][j]=random(2);
}

}

findmaze(int i,int j)/*找到 （i,j）可走*/
{
mapture(j,i,2);/*在圖形上標記*/
sleep(1);

}

returnmaze(int i,int j)/*找到（i,j）可走 ，但下一步無路走則標記*/
{

mapture(j,i,3);/*在圖形上標記*/
sleep(1);
}

print(int i)/*迷宮走完後，輸出是否成功*/
{ settextstyle(1,0,5);
if(i==1)
outtextxy(340,400,"Ture path!");
else if(i==2)
outtextxy(340,400,"No path!");

}

int findpath(int row,int col)/*用遞歸法找迷宮*/
{ int direct,next_row,next_col;
direct=0;
maze[1][1]=2;
mapture(1,1,2);
sleep(1);
while(direct<8)/*8個方向尋找*/
{ next_row=row+move[direct].vert;/*設置下一步坐標*/
next_col=col+move[direct].horiz;
if(maze[next_row][next_col]==0) /*可走，便標記*/
{ maze[next_row][next_col]=2;
findmaze(next_row,next_col) ;
if(next_row==(MAX_ROW-2)&&next_col==(MAX_COL-2))/*找到出口退出程序*/
{ print(1);
getch();
exit(0);
}
else
findpath(next_row,next_col);/*沒有到出口繼續遞歸*/
maze[next_row][next_col]=3;
returnmaze(next_row,next_col);
}
direct++;
}
return(row);
}

TC調試良好

B. c語言數字迷宮問題怎麼做圖片如下

可以參考八皇後問題用回溯的方式來解決。

這道迷宮題，觀察一下，與某個格子相鄰的格子至多為4個，也就是有4種可能的前進方向，需要窮舉所有可能。在窮舉下一種可能前，需要恢復初始狀態（即回溯）。寫了一個簡單的代碼，還有很多需要優化的地方，但關鍵是能用^_^，你可以調試一下，把實現的思路寫出來，就可以順利完成這道題了。

#include <stdio.h>

#include <string.h>

/***

1、 迷宮大小n*n，擴展為(n+2)*(n+2)，外圍一圈的格子作為不可再前進的邊界。

2、 若所有相鄰格子均已訪問，表明此路不通，回溯。

3、 計數器達到總步數，檢查是否位於終點及中間路徑是否合法，通過則顯示。

4、 查找函數Lookup()以遞歸方式反復調用自身，a->b->c->...，以查找某條可能的路徑。

...c,b,a等返回前，均回溯，逐步恢復tag。

離開a時，tag已經恢復到初始狀態，如此就不影響查找其他路徑了。

5、 若迷宮夠大或數據特別，都可能存在不同的路線

6、 先查看main()，了解基本步驟及初始化過程

***/

const int N = 6;

// eg1. N = 6

int row[N] = { 0, 4, 3, 1, 3, 0}; // 4 + 3 + 1 + 3 = 11

int col[N] = { 0, 1, 4, 3, 3, 0};

// eg2. N = 6

//int row[N] = { 0, 3, 4, 4, 2, 0}; // 3 + 4 + 4 + 2 = 13

//int col[N] = { 0, 3, 2, 4, 4, 0};

// eg3. N = 8

//int row[N] = { 0, 3, 1, 4, 3, 3, 1, 0};

//int col[N] = { 0, 1, 1, 5, 3, 1, 4, 0};

// 計數器

// Lookup()用g_counter與COUNTER比較是否走到了規定的步數

int g_counter = 0; // 無論是否成功，每查找一條路徑後自動恢復為0

int COUNTER = 0; // 總步數，等於row（或col）數組各元素之和，在main()中初始化

// Lookup()用tag記錄行走狀況

// 在main()中初始化

// 每查找一條路徑後自動恢復為初始狀態

struct _tag

{

int row[N];

int col[N];

int arr[N][N]; // 走過，按順序標記

} tag;

// 顯示迷宮

// inside為false時，列印擴展的迷宮

// inside為true時，列印未擴展的迷宮

void Display(bool inside)

{

int i, j;

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

{

if ((i == 0 || i == N-1) && inside)

continue;

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

{

if ((j == 0 || j == N-1) && inside)

printf("%4s", " ");

else

printf("%4d", tag.arr[i][j]);

}

printf(" ");

}

printf(" ");

}

// 檢查路徑是否符合已給條件

bool Check()

{

bool b = true;

int sum_row, sum_col;

for (int i = 1; i < N-1; i++)

{

sum_row = 0;

sum_col = 0;

for (int j = 1; j < N-1; j++)

{

sum_row += tag.arr[i][j] > 0 ? 1 : 0;

sum_col += tag.arr[j][i] > 0 ? 1 : 0;

}

if (sum_row != row[i] || sum_col != col[i])

{

b = false;

break;

}

}

return b;

}

// 遞歸查找路徑，返回前擦除痕跡，恢復現場

// 當前訪問的格子(i,j)，i:行坐標，j:列坐標

void Lookup(int i, int j)

{

g_counter++; // 總步數加1

tag.arr[i][j] = g_counter; // visited

tag.row[i]--; // 行計數減1

tag.col[j]--; // 列計數減1

// 走完了

if (g_counter >= COUNTER)

{

// 位於終點，且路徑合法

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

{

Display(true);

}

// 此格子已判別，恢復現場，以查找其他路徑（此即回溯的思想）

tag.arr[i][j] = 0;

tag.row[i]++;

tag.col[j]++;

g_counter--;

return;

}

// 行方向

if (tag.row[i] > 0)

{

if (!tag.arr[i][j+1])

{

Lookup(i, j+1); // 從當前格子向右走一步

}

if (!tag.arr[i][j-1])

{

Lookup(i, j-1); // 從當前格子向左走一步

}

}

// 列方向

if (tag.col[j] > 0)

{

if (!tag.arr[i+1][j])

{

Lookup(i+1, j); // 從當前格子向下走一步

}

if (!tag.arr[i-1][j])

{

Lookup(i-1, j); // 從當前格子向上走一步

}

}

// 此格子已判別，恢復現場，以查找其他路徑（此即回溯的思想）

tag.arr[i][j] = 0;

tag.row[i]++;

tag.col[j]++;

g_counter--;

}

int main()

{

// 格子初始化為全0

memset(tag.arr, 0, sizeof(tag.arr));

for (int i = 0; i < N; i++)

{

tag.row[i] = row[i];

tag.col[i] = col[i];

COUNTER += row[i];

tag.arr[0][i] = 1;

tag.arr[N-1][i] = 1;

tag.arr[i][0] = 1;

tag.arr[i][N-1] = 1;

}

printf("初始化: ");

Display(false);

printf("合法路徑: ");

Lookup(1, 1); // 從格子(1, 1)出發

//getchar();

return 0;

}

C. 求編程高手給個JS迷宮的代碼。

以下是我作的迷宮:
我作的只有九格的,不過你可以自己改製成任意多格的迷宮.前提是一定要是用我的6個css樣式來布局迷宮.否則會出錯.核心的javascript我已經測試過了.沒有問題
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312">
<title>無標題文檔</title>
<style>
.rb{
border-style:double;
border-width:0px;
border-color:#000000;
border-left-width:1px;
border-top-width:1px;
}
.rt{
border-style:double;
border-width:0px;
border-color:#000000;
border-left-width:1px;
border-bottom-width:1px;
}
.lb{
border-style:double;
border-width:0px;
border-color:#000000;
border-right-width:1px;
border-top-width:1px;
}
.lt
{
border-style:double;
border-width:0px;
border-color:#000000;
border-right-width:1px;
border-bottom-width:1px;
}
.lr{
border-style:double;
border-width:0px;
border-color:#000000;
border-top-width:1px;
border-bottom-width:1px;
}
.tb
{
border-style:double;
border-width:0px;
border-color:#000000;
border-left-width:1px;
border-right-width:1px;
}
</style>
</head>

<body>
<div id="layer1" style="position:absolute; left:15px; top:21px; width:27px; height:29px; z-index:1; background-color: #FF0000; layer-background-color: #FF0000; border: 1px none #000000;"></div>
<table width="120" height="120" border="0" cellpadding="0" cellspacing="0" style="border-color:#000000; border-width:1px; border-style:solid; ">
<tr>
<td class="rb"></td>
<td class="rb"></td>
<td class="lb"></td>
</tr>
<tr>
<td class="tb"></td>
<td class="rt"></td>
<td class="lb"></td>
</tr>
<tr>
<td class="rt"></td>
<td class="lr"></td>
<td class="lt"></td>
</tr>
</table>
<script language="javascript">
//得用css來布局迷宮,迷宮的多少行多少列,只要改下面的數據就可以了.不過表格的單元格一定要是40*40
var col=3;//列數
var row=3;//行數
var i=0;//位置數
var player=document.getElementById("layer1");
var td=document.getElementsByTagName("table")[0].getElementsByTagName("td");
document.onkeydown=function (e)
{
e=window.event||e;
if(e.keyCode==37)//向下運動
{
if(i%col!=0)//不在最左邊
{
if((td[i].className=="lb"||td[i].className=="lt"||td[i].className=="lr")&&(td[i-1].className=="rb"||td[i-1].className=="rt"||td[i-1].className=="lr"))//可以通過
{
player.style.left=parseInt(player.style.left)-40+"px";
i=i-1;
}
}
}//向左運動
else if(e.keyCode==38)//向上運動
{
if(i>=col)//不在最上邊
{
if((td[i].className=="lt"||td[i].className=="rt"||td[i].className=="tb")&&(td[i-col].className=="tb"||td[i-col].className=="rb"||td[i-col].className=="lb"))//可以通過
{
player.style.top=parseInt(player.style.top)-40+"px";
i=i-col;
}
}
}//向上運動
else if(e.keyCode==39)//向右運動
{
if((i%col)!=(col-1))//不在最右邊
{
if((td[i].className=="lr"||td[i].className=="rt"||td[i].className=="rb")&&(td[i+1].className=="lb"||td[i+1].className=="lt"||td[i+1].className=="lr"))//可以通過
{
player.style.left=parseInt(player.style.left)+40+"px";
i=i+1;
}
}
}//向右運動
else if(e.keyCode==40)//向下運動
{
if(i<=col*(row-1))//不在最下邊
{
if((td[i].className=="lb"||td[i].className=="rb"||td[i].className=="tb")&&(td[i+col].className=="tb"||td[i+col].className=="rt"||td[i+col].className=="lt"))//可以通過
{
player.style.top=parseInt(player.style.top)+40+"px";
i=i+col;
}
}
}//向下運動
}
</script>
</body></html>

D. 走迷宮的C語言版代碼求助 程序開始運行時顯示一個迷宮地圖，迷宮中央有一隻老鼠，迷宮的右下方有一個糧

/*註：本程序探索迷宮的優先順序=> 1-下、2-右、3-上、4-左 <=總體趨勢：下右，逆時針方向。因為出口就在右邊下方*/
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define stack_init_size 200
#define stack_increment 10
#define OVERFLOW 0
#define OK 1
#define ERROE 0
#define TRUE 1
#define FALSE 0
typedef int Status;

typedef struct{
int x;
int y;
}PosType;

typedef struct {
int ord; // 通道塊在路徑上的"序號"
PosType seat; //通道塊在迷宮中的"坐標位置"
int di; //從此通道塊走向下一通道塊的"方向"
}SElemType;

typedef struct{
SElemType *base;
SElemType *top;
int stacksize;
}SqStack;

int mg[20][20];

/*隨機生成迷宮的函數
/*為了能夠讓盡量能通過，將能通過的塊和不能通過的塊數量比大致為2:1*/
void Random(){
int i,j,k;
srand(time(NULL));
mg[1][0]=mg[1][1]=mg[18][19]=0; //將入口、出口設置為"0"即可通過
for(j=0;j<20;j++)
mg[0][j]=mg[19][j]=1; /*設置迷宮外圍"不可走"，保證只有一個出口和入口*/
for(i=2;i<19;i++)
mg[i][0]=mg[i-1][19]=1; /*設置迷宮外圍"不可走"，保證只有一個出口和入口*/
for(i=1;i<19;i++)
for(j=1;j<19;j++){
k=rand()%3; //隨機生成0、1、2三個數
if(k)
mg[i][j]=0;
else{
if((i==1&&j==1)||(i==18&&j==18)) /*因為距入口或出口一步的路是必經之路，故設該通道塊為"0"加大迷宮能通行的概率*/
mg[i][j]=0;
else
mg[i][j]=1;
}
}
}
//構造一個空棧
Status InitStack(SqStack &s){
s.base =(SElemType *)malloc(stack_init_size * sizeof(SElemType));
if(!s.base) return OVERFLOW;
s.top=s.base;
s.stacksize=stack_init_size;
return OK;
}

//當前塊可否通過
Status Pass(PosType e){
if (mg[e.x][e.y]==0) //0時可以通過
return OK; // 如果當前位置是可以通過，返回1
return OVERFLOW; // 其它情況返回0
}

//留下通過的足跡
Status FootPrint(PosType e){
mg[e.x][e.y]=7;
return OK;
}

//壓入棧
Status Push(SqStack &s,SElemType e){
if(s.top-s.base>=s.stacksize){
s.base=(SElemType *)realloc(s.base,(s.stacksize+stack_increment) *sizeof(SElemType));
if(!s.base)exit(OVERFLOW);
s.top=s.base+s.stacksize;
s.stacksize+=stack_increment;
}
*s.top++=e;
return OK;
}

//出棧
Status Pop(SqStack &s,SElemType &e){
if(s.top==s.base)
return ERROE;
e=*--s.top;
return OK;
}

//下一步
PosType NextPos(PosType &e,int dir){
PosType E;
switch(dir){
case 1:E.x=e.x; //向下
E.y=e.y+1;
break;
case 2:E.x=e.x+1; //向右
E.y=e.y;
break;
case 3:E.x=e.x; //向上
E.y=e.y-1;
break;
case 4:E.x=e.x-1; //向左
E.y=e.y;
break;
}
return E;
}

//是否空棧
Status StackEmpty(SqStack s){
if (s.top==s.base)
return OK;
return OVERFLOW;
}

//留下不能通過的足跡
Status MarkPrint(PosType e){
mg[e.x][e.y]=3;
return OK;
}

//迷宮函數
// 若迷宮maze中從入口 start到出口 end的通道，則求得一條存放在棧中
// （從棧底到棧頂），並返回TRUE；否則返回FALSE
Status MazePath(int mg,PosType start,PosType end,SqStack &s){
PosType curpos;
InitStack(s);
SElemType e;
int curstep;
curpos=start; // 設定"當前位置"為"入口位置"
curstep=1; // 探索第一步
do{
if(Pass(curpos)){ // 當前位置可通過，即是未曾走到過的通道塊
FootPrint(curpos); // 留下足跡
e.di =1;
e.ord = curstep;
e.seat= curpos;
Push(s,e); // 加入路徑
if(curpos.x==end.x&&curpos.y==end.y){
printf("\n\n0∩_∩0 能到達終點!");
return TRUE;
}
curpos=NextPos(curpos,1); // 下一位置是當前位置的東鄰
curstep++; // 探索下一步
}
else{ // 當前位置不能通過
if(!StackEmpty(s)){
Pop(s,e);
while(e.di==4&&!StackEmpty(s)){
MarkPrint(e.seat);
Pop(s,e);
}
if(e.di<4){
e.di++;
Push(s,e); // 留下不能通過的標記，並退回一步
curpos=NextPos(e.seat,e.di); /* 當前位置設為新方向的相鄰塊*/
}//if
}//if
}//else
}while(!StackEmpty(s));
printf("\n\n囧 ! 不能到達終點!");
return FALSE;
}

//列印迷宮
void PrintMaze(){
int i,j;
printf("運行路徑:\n\n");
for(i=0;i<20;i++){
for(j=0;j<20;j++){
if(mg[i][j]==0)printf(" ");
else if(mg[i][j]==1) printf("■"); //迷宮的"牆"
else if(mg[i][j]==3) printf("◇"); //不通的路
else if(mg[i][j]==7)printf("○"); //通過的路徑
}
printf("\n");
}
printf("\n");
}

void main(){
SqStack S;
PosType start,end;
start.x=1;start.y=0; //起點坐標
end.x=18;end.y=19; //終點坐標
printf("\n==================迷宮游戲==================");
printf("\n說明:■不能走的區域\t◇走不通的區域");
printf("\n '空格'代表未到過的區域");
printf("\n ○代表能通過的路徑，指向終點");
printf("\n============================================");
Random();
printf("\n\nTest 1:");
MazePath(mg[20][20],start,end,S);
PrintMaze();
system("pause");
Random();
printf("\nTest 2:");
MazePath(mg[20][20],start,end,S);
PrintMaze();
system("pause");
Random();
printf("\nTest 3:");
MazePath(mg[20][20],start,end,S);
PrintMaze();
printf("\n==========程序退出，感謝使用!==========\n");
}