关于迷宫问题~~~急,各位请帮帮忙啊~
基本要求：
要求程序输出如下：
1 一条通路的二元组（i，j），数据序列（i，j）表示通路上某点的坐标。
2 用一种标志（如数字0）在二维数组中标出该条通路，并在屏幕上输出二维组。
实现提示：
可以用二维数组m[i][j]表示迷宫，其中1 <= i <= m，1 <= j <= n。数组元素为1表示该位置是墙壁不能通行，元素值为0表示该位置是通路。假定从 m[1][1]出发，出口位于m[m][n]，移动方向可以是8个方向（东，东南，南，西南，西，西北，北和东北）。一个购造的迷宫如下：
0 1 0 1 0 0 1
1 0 0 0 1 0 1
0 0 1 1 0 1 1
1 1 1 0 1 1 0
0 1 1 1 0 1 0
1 1 1 0 1 0 0


各位能 给我个c程序 和解决方案么?~~

[解决办法]
这个用回溯法

[解决办法]
课程设计吧，

网上这方面的代码不少，

自己找找看吧
[解决办法]
贪心法，每次找到一个出口就向前一步，如果没有出路了就回溯，用堆栈
[解决办法]
刚好我有时间就随便写了写,用的是c代码,主要是用递归了:


#include "stdafx.h "
#include <stdio.h>
typedef char BOOL;

//迷宫算法
const int a[6][7] = {
{0, 1, 0, 1, 0, 0, 1},
{1, 0, 0, 0, 1, 0, 1},
{0, 0, 1, 1, 0, 1, 1},
{1, 1, 1, 0, 1, 1, 0},
{0, 1, 1, 1, 0, 1, 0},
{1, 1, 1, 0, 1, 0, 0}
};

const int MAX_X = 6;
const int MAX_Y = 7;

//每一步在数组中的位置
typedef struct _STEP
{
//::memset(this, 0, sizeof(_STEP));
int x;
int y;
}Step;

//当前位置
Step trace[50];
Step stepCurrent;
int iCounter;

//移动操作
BOOL Right();
BOOL RightDown();
BOOL Down();
BOOL DownUp();
BOOL Left();
BOOL LeftUp();
BOOL Up();
BOOL UpDown();
//
BOOL GetExit();

void main()
{
stepCurrent.x = 0;
stepCurrent.y = 0;
iCounter = 0;

if (GetExit())
{
printf( "Successful! ");
}

scanf( "%d ", &iCounter);
}

BOOL GetExit()
{
//8个方向从Right开始逆时针运动
trace[iCounter++] = stepCurrent;

if (stepCurrent.x == MAX_X-1
&& stepCurrent.y == MAX_Y-1)
{
return 1;
}

if (Right())
{
return GetExit();
}
else
{
Left();
}

if (RightDown())
{
return GetExit();
}
else
{
LeftUp();
}

if (Down())
{
return GetExit();
}
else
{
Up();
}

if (DownUp())
{
return GetExit();
}
else
{
UpDown();
}

if (Left())
{
return GetExit();
}
else
{
Right();
}

if (LeftUp())
{
return GetExit();
}
else
{
RightDown();
}

if (Up())
{
return GetExit();
}
else
{
Down();
}

if (UpDown())
{
return GetExit();
}
else
{
DownUp();
}

iCounter--;
return 0;
}

BOOL Right()
{
if (++stepCurrent.y > = MAX_Y
|| a[stepCurrent.x][stepCurrent.y])
return 0;

return 1;
}

BOOL RightDown()
{
if (++stepCurrent.y > = MAX_Y

|| ++stepCurrent.x > = MAX_X
||a[stepCurrent.x][stepCurrent.y])
return 0;

return 1;
}

BOOL Down()
{
if (++stepCurrent.x > = MAX_X
|| a[stepCurrent.x][stepCurrent.y])
return 0;

return 1;
}

BOOL DownUp()
{
if (--stepCurrent.y > = MAX_Y
|| ++stepCurrent.x > = MAX_X
||a[stepCurrent.x][stepCurrent.y])
return 0;

return 1;
}

BOOL Left()
{
if (--stepCurrent.y > = MAX_X
|| a[stepCurrent.x][stepCurrent.y])
return 0;

return 1;
}

BOOL LeftUp()
{
if (--stepCurrent.y > = MAX_Y
|| --stepCurrent.x > = MAX_X
||a[stepCurrent.x][stepCurrent.y])
return 0;

return 1;
}

BOOL Up()
{
if (--stepCurrent.x > = MAX_X
|| a[stepCurrent.x][stepCurrent.y])
return 0;

return 1;
}

BOOL UpDown()
{
if (++stepCurrent.y > = MAX_Y
|| --stepCurrent.x > = MAX_X
||a[stepCurrent.x][stepCurrent.y])
return 0;

return 1;
}
[解决办法]
用一个最笨的方法，始终让你的右手（左手）摸到墙，最后一定能出去，不过很有可能不是最短路线
[解决办法]
呵呵，最后的方法估计是最实用的!大家迷路的时候可不要听程序员的,就按最后一个老兄说的办.