迷宫程序

[idler]

偶朋友拜托偶帮忙的。。。偶今天出去喝喜酒看不了。。。各位兄弟帮忙解决。
200分不打折滴。。。回贴写修改点，能加说明最好。。。多谢^_^

//可能性：假死循环：运算时间很长，似乎进入死循环
//不要用c++语句
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<math.h>
void setmaze(int);
void move(int,int);
void path(int,int);
int **m,n,times;//times?似乎没用到
int count=2;//道路步数
int maincount=2;//主道路步数
int flag=1;
main()
{
int i,j;
printf("input the diameter(10-30):");
scanf("%d",&n);

//以下申请二维数组
m=(int**)malloc(2*n*n*sizeof(int*));
if(m==NULL){
printf("memory request failed\n");
exit(-1);
}
for(j=0;j<2*n;j++)//注意这里是2*n，为了视觉效果好
m[j]=(int*)malloc(2*n*sizeof(int));

//初始化迷宫
for(i=0;i<n;i++)
for(j=0;j<2*n;j++)
m[i][j]=1;
for(i=0;i<n;i+=n-1)
for(j=0;j<2*n;j++)
m[i][j]=2;
for(j=0;j<2*n;j+=2*n-1)
for(i=1;i<n-1;i++)
m[i][j]=2;

setmaze(n);
}

void setmaze(n)
{
int i,j;
m[0][1]=0;m[1][1]=0;//先走两步
move(1,1);//建立主道路

//找道路点，建立分支道路，直到道路走过的步数达到迷宫面积数的一半
while(count<=n*n){
srand(time(00));
do
{
i=rand()%n;j=rand()%(2*n);
}
while(m[i][j]!=0);//找到道路上的点
path(i,j);
}

//输出迷宫
for(i=0;i<n;i++){
printf("\t");
for(j=0;j<2*n;j++)
printf("%d",m[i][j]);
printf("\n");}
}

void move(int x,int y)
{
int direct;
srand(time(00));//这句是否用对，是否应放在这里
flag=1;//这里改为int flag=1后程序无错，但只有m[0][1]=0;m[1][1]=0;其余没变化

//选择一个方向，做判断后再走
direct=rand()%4;
switch(direct){
case 0://向上
if(x>=1){//不在最顶端
if(m[--x][y]==2){//上面是墙壁
if(maincount<=5*n) //走的步数太少
{x++;move(x,y);}//回复，叠代
else flag=0;}//上面是墙壁，且走的步数够多，结束
else m[x][y]=0;}//上面不是墙壁，走过去
break;
case 1://向左
if(y>=1){
if(m[x][--y]==2){
if(maincount<=5*n) {y++;move(x,y);}
else flag=0;}
else m[x][y]=0;}break;
case 2://向下
if(x<n-1){
if(m[++x][y]==2){
if(maincount<=5*n) {x--;move(x,y);}
else flag=0;}
else m[x][y]=0;}break;
case 3://向右
if(y<2*n-1){
if(m[x][++y]==2){
if(maincount<=5*n) {y--;move(x,y);}
else flag=0;}
else m[x][y]=0;}break;
}

maincount++;count++;
if(flag!=0)move(x,y);//没碰到墙壁或者走的步数不够，再走
else return;
}

void path(int x,int y)
{
int direct;
flag=1;
srand(time(00));

//选择方向，判断后再走
direct=rand()%4;
switch(direct){
case 0://向上
if((abs(x)<=2)&&(abs(x-n+1)<=2)&&(abs(y)<2)&&(abs(y-2*n)<=2)) //离边界有一定距离
flag=0;
else m[--x][y]=0;
break;
case 1://向左
if((abs(x)<=2)&&(abs(x-n+1)<=2)&&(abs(y)<2)&&(abs(y-2*n)<=2)) flag=0;
else m[x][--y]=0;break;
case 2://向下
if((abs(x)<=2)&&(abs(x-n+1)<=2)&&(abs(y)<2)&&(abs(y-2*n)<=2)) flag=0;
else m[++x][y]=0;break;
case 3://向右
if((abs(x)<=2)&&(abs(x-n+1)<=2)&&(abs(y)<2)&&(abs(y-2*n)<=2)) flag=0;
else m[x][++y]=0;break;
}

count++;
if(flag!=0)path(x,y);//当前点离边界有一定距离，再走
else return;//走到边界，返回
}

[xunfengxxx]

经典的程序
有经典的算法
网上多的是

[idler]

homtipo() 我的电子邮件[e-mail]
pzcai(泡菜) 所以偶打了200分嘛。。。。
最先改完的200分，做对但是晚到的50分辛苦费。。。偶昨天喝高咯。。。

[languagec]

[languagec]

m=(int**)malloc(2*n*n*sizeof(int*));
if(m==NULL){
printf("memory request failed\n");
exit(-1);
}
for(j=0;j<2*n;j++)//注意这里是2*n，为了视觉效果好
m[j]=(int*)malloc(2*n*sizeof(int));

//二维数组可以这样分配吗？

[lazyboya]

哈哈白忙乎了.

[liujingfu123]

我这里也有一个，邮件联系
[e-mail]

[foochow]

好长.....-_-

[zsh6709]

就是嘛，c里面是不允许有类的
而c++里面有没有 graphic（）函数
迷惑中，请指教~~~

[copygirl]

我不喜欢迷宫

[zhousqy]

哇。。。好长的程序！

[wind44]

我要一份,发给我吧.
[e-mail]

[chuwanghui]

lxjlz(我本飛翔) lxjlz(我本飛翔) lxjlz(我本飛翔) lxjlz(我本飛翔)
想问一下,,那个陶唱的迷宫算法...在哪里执行阿.怎么又有c里面的函数库graphics.h..又有class阿..
c里面不能执行...C++也不能执行阿

[useresu]

这么早的帖子?怎么翻出来的

那会我还没上csdn呢

现在还要不要?

是不是一定要改这个程序?

[mostideal]

mark

[Trainsp0tting]

楼上的牛啊，五个多月就变成猩猩了？

[zloves]

mark

[foochow]

mark!!!

[qybao]

mark

[yangwuhan]

这里有一个迷宫算法的例子
说不定对不有所启发
http://virtualhost.webplus.com.cn/softcreation/index.asp
呵呵
不怕丑,做一下广告

[nasi00]

我有一个迷宫的程序，是用A*解的，可以给你作为参考

#include <iostream>
#include <fstream>
#include <vector>
#include <cstring>
#include <queue>

#define __STRICT

//--------------------------------------------------
// Class: elem
// DESC: used for construct a priority queue
//--------------------------------------------------
class elem
{
public:
int v;
int cost;
int depth;

elem(int _v, int _c, int _d) : v(_v), cost(_c), depth(_d) {}

bool operator<(const elem& rhs) const
{
return rhs.cost < cost;
}
};


//--------------------------------------------------
// Class: cMaze
// DESC: used for solve the problem
//--------------------------------------------------
class cMaze
{
//--------------------------------------------------
// Constants
//--------------------------------------------------
protected:
enum { MAX_VERTEX = 20 };

//--------------------------------------------------
// Members
//--------------------------------------------------
protected:
int m_iCol, m_iRow;
std::vector<int> m_vGraph[MAX_VERTEX*MAX_VERTEX];
bool m_bVisited[MAX_VERTEX*MAX_VERTEX];
int m_iSrc, m_iDst;

int m_iSolve[MAX_VERTEX*MAX_VERTEX];
int m_iParent[MAX_VERTEX];
int m_iLen;

bool m_bLoaded, m_bSolved;

char m_cCanvas[MAX_VERTEX*2][MAX_VERTEX*3];

//--------------------------------------------------
// Public Interfaces
//--------------------------------------------------
public:
// constructor
cMaze();
// destructor
virtual ~cMaze();
// load a maze-map from text file
void load(const char *filename);
// solve it using A* search
void solve();
// output the results
void output();

//--------------------------------------------------
// Member Functions
//--------------------------------------------------
// calculate the cost
int cost(int v)
{
int xg = m_iDst / m_iCol;
int yg = m_iDst % m_iCol;
int xn = v / m_iCol;
int yn = v % m_iCol;

return abs(xg - xn) + abs(yg - yn);
}

// show error message when it occurs
void err(char *desc)
{
std::cout << "Error: ";
std::cout << desc << std::endl;
}

void init_canvas()
{
int i, j;
for (i = 0; i < m_iRow*2; ++i)
{
for (j = 0; j < m_iCol*3; ++j)
{
m_cCanvas[i][j] = (!(i % 2) && !(j % 3)) ? 'o' : ' ';
}
}

m_cCanvas[(m_iSrc/m_iCol)*2][(m_iSrc%m_iCol)*3] = 'S';
m_cCanvas[(m_iDst/m_iCol)*2][(m_iDst%m_iCol)*3] = 'E';
}

void paint_canvas()
{
int i, j;
for (i = 0; i < m_iRow*2 - 1; ++i)
{
for (j = 0; j < m_iCol*3; ++j)
{
std::cout << m_cCanvas[i][j];
}
std::cout << std::endl;
}
}

void link_canvas(int v, int i)
{
int x, y;

x = i / m_iCol;
y = i % m_iCol;

if (v == i-1)
{
// left
m_cCanvas[x*2][y*3-1] = m_cCanvas[x*2][y*3-2] = '-';
}
else if (v == i+1)
{
// right
m_cCanvas[x*2][y*3+1] = m_cCanvas[x*2][y*3+2] = '-';

}
else if (v < i)
{
// up
m_cCanvas[x*2-1][y*3] = '|';

}
else
{
// down
m_cCanvas[x*2+1][y*3] = '|';
}
}
};

//--------------------------------------------------
// Constructor
//--------------------------------------------------
cMaze::cMaze()
{
m_iRow = m_iCol = 0;
m_iSrc = m_iDst = 0;

int i;
for(i = 0; i < MAX_VERTEX*MAX_VERTEX; ++i)
{
m_vGraph[i].clear();
m_iParent[i] = -1;
}

memset(m_bVisited, 0, MAX_VERTEX * MAX_VERTEX * sizeof(bool));
memset(m_iSolve, 0, MAX_VERTEX * MAX_VERTEX * sizeof(int) );

m_iLen = 0;

m_bLoaded = m_bSolved = false;
}

//--------------------------------------------------
// Destructor
//--------------------------------------------------
cMaze::~cMaze()
{
// only use for override
}

//--------------------------------------------------
// Load()
// @param const char *filename: the text file name
// @describe
// the text file format
// --------------------
// number_of_row number_of_column
// source_vertex destination_vertex
// number_of_edge
// vertex0 vertex1 (a edge between v0 and v1)
// ...
// the map format
// --------------
// v[0] v[1] v[2] .... v[m]
// v[m+1] ... v[2m]
//--------------------------------------------------
void cMaze::load(const char *filename)
{
std::ifstream fin(filename);

fin >> m_iRow >> m_iCol;
fin >> m_iSrc >> m_iDst;

int edge, i, src, dst;
fin >> edge;
for (i = 0; i < edge; ++i)
{
fin >> src >> dst;
m_vGraph[src].push_back(dst);
m_vGraph[dst].push_back(src);
}

m_bLoaded = true;
}

//--------------------------------------------------
// Solve
//--------------------------------------------------
void cMaze::solve()
{
#ifdef __STRICT
if (!m_bLoaded)
{
err("Map is not loaded yet");
}
#endif

std::priority_queue<elem> q;

// push the source to the priority queue
q.push( elem(m_iSrc, cost(m_iSrc), 0) );
m_bVisited[m_iSrc] = true;

while (! q.empty())
{
// got the top one (the least cost)
elem e = q.top();
q.pop();

// check if it is the destination
if (e.v == m_iDst)
{
// construct the solution
m_iLen = 0;
m_iSolve[m_iLen++] = m_iDst;
int v = m_iParent[m_iDst];
while( -1 != v )
{
m_iSolve[m_iLen++] = v;
v = m_iParent[v];
}

m_bSolved = true;
return;
}

// extend the vertex
int i;
for (i = 0; i < m_vGraph[e.v].size(); ++i)
{
int v = m_vGraph[e.v][i];

if (!m_bVisited[v])
{
m_bVisited[v] = true;
q.push( elem(v, cost(v) + e.depth + 1, e.depth+1) );
m_iParent[v] = e.v;
}
}

}
}

//--------------------------------------------------
// Output
//--------------------------------------------------
void cMaze::output()
{
#ifdef __STRICT
if (!m_bSolved)
{
err("Maze is not solved correctly");
}
#endif

int i, j;

// output the maze
std::cout << "the Maze:" << std::endl;
init_canvas();
for(i = 0; i < m_iRow*m_iCol; ++i)
{
for(j = 0; j < m_vGraph[i].size(); ++j)
{
link_canvas(m_vGraph[i][j], i);
}
}
paint_canvas();

std::cout << std::endl;

if (0 == m_iLen)
{
std::cout << "the Path doesn't exist." << std::endl;

return;
}

// output the path
std::cout << "the Path:" << std::endl;
init_canvas();
for(i = 0; i < m_iLen-1; ++i)
{
link_canvas(m_iSolve[i], m_iSolve[i+1]);
}
paint_canvas();
}


//--------------------------------------------------
// Main Function
//--------------------------------------------------
int main()
{
cMaze *maze;

#ifdef __DEBUG
#include <cstdio>
freopen("debug.txt", "w", stdout);
#endif

maze = new cMaze;
maze->load("map2.txt");
maze->solve();
maze->output();

delete maze;
return 0;
}