人工智能算法实现

人工智能算法实现：[1]A*算法c语言 

分步阅读

A*算法，A*（A-Star)算法是一种静态路网中求解最短路最有效的方法。估价值与实际值越接近，估价函数取得就越好。

A*[1]（A-Star)算法是一种静态路网中求解最短路最有效的方法。 公式表示为： f(n)=g(n)+h(n),

其中 f(n) 是从初始点经由节点n到目标点的估价函数，

g(n) 是在状态空间中从初始节点到n节点的实际代价，

h(n) 是从n到目标节点最佳路径的估计代价。

保证找到最短路径（最优解的）条件，关键在于估价函数h(n)的选取： 估价值h(n)

如果 估价值>实际值,搜索的点数少，搜索范围小，效率高，但不能保证得到最优解。

 DEVC++或 VC 6.0

方法/步骤

1. 估价值与实际值越接近，估价函数取得就越好

例如对于几何路网来说，可以取两节点间欧几理德距离（直线距离）做为估价值，即f=g(n)+sqrt((dx-nx)*(dx-nx)+(dy-ny)*(dy-ny))；这样估价函数f在g值一定的情况下，会或多或少的受估价值h的制约，节点距目标点近，h值小，f值相对就小，能保证最短路的搜索向终点的方向进行。明显优于Dijkstra算法的毫无方向的向四周搜索。

conditions of heuristic

Optimistic (must be less than or equal to the real cost) As close to the real cost as possible

详细内容：

创建两个表，OPEN表保存所有已生成而未考察的节点，CLOSED表中记录已访问过的节点。

算起点的估价值;

将起点放入OPEN表;

2. A star算法在静态路网中的应用，以在地图中找从开始点 s 到e点的最短行走路径为例：

首先定义数据结构

#define MAPMAXSIZE 100 //地图面积最大为 100x100

#define MAXINT 8192 //定义一个最大整数, 地图上任意两点距离不会超过它 #define STACKSIZE 65536 //保存搜索节点的堆栈大小

#define tile_num(x,y) ((y)*map_w+(x)) //将 x,y 坐标转换为地图上块的编号 #define tile_x(n) ((n)%map_w) //由块编号得出 x,y 坐标

#define tile_y(n) ((n)/map_w)

// 树结构, 比较特殊, 是从叶节点向根节点反向链接

typedef struct node *TREE; struct node {

int h;

int tile;

TREE father;

};

typedef struct node2 *LINK;

struct node2 {

TREE node;

int f;

LINK next;

};

LINK queue; // 保存没有处理的行走方法的节点

TREE stack[STACKSIZE]; // 保存已经处理过的节点 (搜索完后释放) int stacktop;

char map[][6]={{'x','x','x','x','x','x'},

{'x','e',' ',' ',' ','x'},

{'x','x',' ','x',' ','x'},

{'x','x',' ',' ',' ','x'},

{'x','x','x','x','s','x'},

{'x','x','x','x','x','x'} };//地图数据

int dis_map[MAPMAXSIZE][MAPMAXSIZE];//保存搜索路径时,中间目标地最优解

int map_w,map_h;//地图宽和高

int start_x,start_y,end_x,end_y; //地点,终点坐标

// 路径寻找主函数

void findpath(int *path)

{

//printf("%d,%d,%d,%d",start_x,start_y,end_x,end_y);

TREE root;

int i,j;

stacktop=0;

for (i=0;i

for (j=0;j

init_queue();

root=(TREE)malloc(sizeof(*root));

root->tile=tile_num(start_x,start_y);

root->h=0;

root->father=NULL;

enter_queue(root,judge(start_x,start_y));

for (;;) {

int x,y,child;

TREE p;

root=get_from_queue();

if (root==NULL) {

*path=-1;

return;

}

x=tile_x(root->tile);

y=tile_y(root->tile);

if (x==end_x && y==end_y) break;// 达到目的地成功返回

child=trytile(x,y-1,root);//尝试向上移动

child&=trytile(x,y+1,root);//尝试向下移动

child&=trytile(x-1,y,root);//尝试向左移动

child&=trytile(x+1,y,root);//尝试向右移动

if (child!=0)

pop_stack();// 如果四个方向均不能移动,释放这个死节点

}

// 回溯树，将求出的最佳路径保存在 path[] 中

for (i=0;root;i++) {

path[i]=root->tile;

root=root->father;

//printf("pathis %d",path[i]);

}

path[i]=-1;

freetree(); }

// 估价函数,估价 x,y 到目的地的距离,估计值必须保证比实际值小

int judge(int x,int y)

{

int distance;

distance=abs(end_x-x)+abs(end_y-y);

return distance;

}

// 尝试下一步移动到 x,y 可行否

int trytile(int x,int y,TREE father)

{

TREE p=father;

int h;

if (map[y][x]=='x') return 1; // 如果 (x,y) 处是障碍,失败

while (p) {

if (x==tile_x(p->tile) && y==tile_y(p->tile)) return 1; //如果 (x,y) 曾经经过,失败

p=p->father;

}

h=father->h+1;

if (h>=dis_map[y][x]) return 1;// 如果曾经有更好的方案移动到 (x,y) 失败 dis_map[y][x]=h;// 记录这次到 (x,y) 的距离为历史最佳距离

// 将这步方案记入待处理队列

p=(TREE)malloc(sizeof(*p));

p->father=father;

p->h=father->h+1;

p->tile=tile_num(x,y);

enter_queue(p,p->h+judge(x,y));

return 0;

}

3. 打开c语言编译器，输入我们的运行代码，编译，运行如下，打印出地图如下图：

4. 点任意键进行运行找静态路网

5. 说明：找到路后会存到一个数组中去，我们为了显示这个过程可以运用打印函数打印出来代码如下

void printpath(int *path)

{

int i;

//printf("-[1**********]444");

for (i=0;path[i]>=0;i++) {

gotoxy(tile_x(path[i])+1,tile_y(path[i])+1);

printf("-");

Sleep(2000);

}

printf("\n");

printf("\n");

printf("走迷宫完成");

}

6. 整个程序的代码如下：

#include

#include"stdio.h"

#include

#include"assert.h" #include"stdlib.h"

#define MAPMAXSIZE 100 //地图面积最大为 100x100

#define MAXINT 8192 //定义一个最大整数, 地图上任意两点距离不会超过它 #define STACKSIZE 65536 //保存搜索节点的堆栈大小

#define tile_num(x,y) ((y)*map_w+(x)) //将 x,y 坐标转换为地图上块的编号 #define tile_x(n) ((n)%map_w) //由块编号得出 x,y 坐标

#define tile_y(n) ((n)/map_w)

// 树结构, 比较特殊, 是从叶节点向根节点反向链接

typedef struct node *TREE;

struct/*designde by [email protected]*/ node {

int h;

int tile;

TREE father;

};

typedef struct /*designde by [email protected]*/node2 *LINK;

struct node2 {

TREE node;

int f;/*designde by [email protected]*/

LINK next;

};

LINK queue; // 保存没有处理的行走方法的节点

TREE stack[STACKSIZE]; // 保存已经处理过的节点 (搜索完后释放) int stacktop;

char map[][6]={{'x','x','x','x','x','x'},

{'x','e',' ',' ',' ','x'},

{'x','x',' ','x',' ','x'},

{'x','x',' ',' ',' ','x'},

{'x','x','x','x','s','x'},

{'x','x','x','x','x','x'} };//地图数据

int

中间目标地最优解 dis_map/*designde by [email protected]*/[MAPMAXSIZE][MAPMAXSIZE];//保存搜索路径时,

int map_w,map_h;//地图宽和高

int start_x,start_y,end_x,end_y; //地点,终点坐标

void gotoxy(int x ,int y)

{

HANDLE a;

COORD zb;

zb.X =x-1;

zb.Y =y-1;

a= GetStdHandle(STD_OUTPUT_HANDLE/*designde [email protected]*/);

SetConsoleCursorPosition(a,zb);

}

// 初始化队列

void init_queue()

{

queue=(LINK)malloc(sizeof(*queue));

queue->node=NULL;

queue->f=-1;

queue->next=(LINK)/*designde

[email protected]*/malloc(sizeof(*queue));

queue->next->f=MAXINT;

queue->next->node=NULL;

queue->next->next=NULL;

}

// 待处理节点入队列, 依靠对目的地估价距离插入排序 void enter_queue(TREE node,int f)

{

LINK p=queue,father,q;

while(f>p->f) {

father=p;

p=p->next/*designde by [email protected]*/;

assert(p);

} by by

q=(LINK)malloc(sizeof(*q)); assert(queue);

q->f=f,q->node=node,q->next=p;

father->next=q;

}

// 将离目的地估计最近的方案出队列

TREE get_from_queue()

{

TREE bestchoice=queue->next->node;

LINK next=queue->next->next;

/*designde by [email protected]*/free(queue->next);

queue->next=next;

stack[stacktop++]=bestchoice;

assert(stacktop

return /*designde by [email protected]*/bestchoice;

}

// 释放栈顶节点

void pop_stack()

{

free(stack[--stacktop]);

}

// 释放申请过的所有节点

void freetree()

{

int i;

LINK p;

for (i=0;i

free(stack);

while /*designde by [email protected]*/(queue) {

p=queue;

free(p->node);

queue=queue->next;

free(p);

} }

// 估价函数,估价 x,y 到目的地的距离,估计值必须保证比实际值小 int judge(int x,int y)

{

int distance;

distance=abs(end_x-x)+abs(end_y-y);

return distance;

}

// 尝试下一步移动到 x,y 可行否

int trytile(int/*designde by [email protected]*/ x,int y,TREE father) {

TREE p=father;

int h;

if (map[y][x]=='x') return 1; // 如果 (x,y) 处是障碍,失败

while (p) {

/*designde

p=p->father;

}

h=father->h+1;

if (h>=dis_map[y][x]) return 1;// 如果曾经有更好的方案移动到 (x,y) 失败 dis_map[y][x]=h;// 记录这次到 (x,y) 的距离为历史最佳距离

// 将这步方案记入待处理队列

p=(TREE)malloc(sizeof(*p));

p->father=father;

p->h=father->h+1;

p->tile=tile_num(x,y);

enter_queue(p,p->h+judge(x,y));

return 0;

}

// 路径寻找主函数

void findpath(int *path) by [email protected]*/if (x==tile_x(p->tile) && y==tile_y(p->tile)) return 1; //如果 (x,y) 曾经经过,失败

{ //printf("%d,%d,%d,%d",start_x,start_y,end_x,end_y); TREE root;

int i,j;

stacktop=0;

for (i=0;i

for (j=0;j

dis_map[i][j/*designde by [email protected]*/]=MAXINT; init_queue();

root=(TREE)malloc(sizeof(*root));

root->tile=tile_num(start_x,start_y);

root->h=0;

root->father=NULL;

enter_queue(root,judge(start_x,start_y));

for (;;) {

int x,y,child;

TREE p;

root=get_from_queue();

if (root==NULL) {

*path=-1;

return;

}

x=tile_x(root->tile);

y=tile_y(root->tile);

if (x==end_x && y==end_y) break;// 达到目的地成功返回 child=trytile(x,y-1,root);//尝试向上移动

child&=trytile(x,y+1,root);//尝试向下移动

child&=trytile(x-1,y,root);//尝试向左移动

child&=trytile(x+1,y,root);//尝试向右移动

if (child!=0)

pop_stack();// 如果四个方向均不能移动,释放这个死节点 }

// 回溯树，将求出的最佳路径保存在 path[] 中

for (i=0;root;i++) { path[i]=root->tile;

root=root->father;

//printf("pathis %d",path[i]/*designde by [email protected]*/); }

path[i]=-1;

freetree();

}

void printpath(int *path)

{

int i;

//printf("-[1**********]444");

for (i=0;path[i]>=0;i++) {

gotoxy(tile_x(path[i])+1,tile_y(path[i])+1);

printf("-");

Sleep(2000);

}

printf("\n");

printf("\n");

printf("走迷宫完成");

}

void readmap()

{ printf("走迷宫，s是起始点 e是终点 按任意键开始"); getchar();

//FILE *f;

int i,j;

//f=fopen("2.c","r");

//assert(f);

//scanf("%d%d",&map_w,&map_h);

map_w=map_h=6;

for (i=0;i

//fgets(&map[i][0],map_w+1,f);

//fclose(f);

start_x=-1,end_x=-1; for (i=0;i

for (j=0;j/*designde by [email protected]*/

if (map[i][j]=='e') map[i][j]=' ',end_x=j,end_y=i;

}

assert(start_x>=0 && end_x>=0);

//printf("%d,%d,%d,%d",start_x,start_y,end_x,end_y);

}

void showmap()

{

int i,j;

system("cls");

for (i=0;i

gotoxy(1,i+1);

for (j=0;j

if (map[i][j]!=' ') printf("x");

else printf(" ");

}

gotoxy(end_x+1,end_y+1);

printf("e");

gotoxy(start_x+1,start_y+1);

printf("s");

}

int main()

{

system("title 晓博 A*算法试验程序");//设置cmd窗口标题 printf("…………欢迎使用晓博 A*算法试验程序，[email protected] 河南财经政法大学…………"); int path[MAXINT];

readmap();

showmap();

Sleep(2000); Designed by

findpath(path); printpath(path); getchar();

system("pause"); return 0; }

END

注意事项  为了使的程序可以慢慢的打印出来动态的运行效果 加了Sleep(2000);

人工智能算法实现：[1]A*算法c语言 

分步阅读

A*算法，A*（A-Star)算法是一种静态路网中求解最短路最有效的方法。估价值与实际值越接近，估价函数取得就越好。

A*[1]（A-Star)算法是一种静态路网中求解最短路最有效的方法。 公式表示为： f(n)=g(n)+h(n),

其中 f(n) 是从初始点经由节点n到目标点的估价函数，

g(n) 是在状态空间中从初始节点到n节点的实际代价，

h(n) 是从n到目标节点最佳路径的估计代价。

保证找到最短路径（最优解的）条件，关键在于估价函数h(n)的选取： 估价值h(n)

如果 估价值>实际值,搜索的点数少，搜索范围小，效率高，但不能保证得到最优解。

 DEVC++或 VC 6.0

方法/步骤

1. 估价值与实际值越接近，估价函数取得就越好

例如对于几何路网来说，可以取两节点间欧几理德距离（直线距离）做为估价值，即f=g(n)+sqrt((dx-nx)*(dx-nx)+(dy-ny)*(dy-ny))；这样估价函数f在g值一定的情况下，会或多或少的受估价值h的制约，节点距目标点近，h值小，f值相对就小，能保证最短路的搜索向终点的方向进行。明显优于Dijkstra算法的毫无方向的向四周搜索。

conditions of heuristic

Optimistic (must be less than or equal to the real cost) As close to the real cost as possible

详细内容：

创建两个表，OPEN表保存所有已生成而未考察的节点，CLOSED表中记录已访问过的节点。

算起点的估价值;

将起点放入OPEN表;

2. A star算法在静态路网中的应用，以在地图中找从开始点 s 到e点的最短行走路径为例：

首先定义数据结构

#define MAPMAXSIZE 100 //地图面积最大为 100x100

#define MAXINT 8192 //定义一个最大整数, 地图上任意两点距离不会超过它 #define STACKSIZE 65536 //保存搜索节点的堆栈大小

#define tile_num(x,y) ((y)*map_w+(x)) //将 x,y 坐标转换为地图上块的编号 #define tile_x(n) ((n)%map_w) //由块编号得出 x,y 坐标

#define tile_y(n) ((n)/map_w)

// 树结构, 比较特殊, 是从叶节点向根节点反向链接

typedef struct node *TREE; struct node {

int h;

int tile;

TREE father;

};

typedef struct node2 *LINK;

struct node2 {

TREE node;

int f;

LINK next;

};

LINK queue; // 保存没有处理的行走方法的节点

TREE stack[STACKSIZE]; // 保存已经处理过的节点 (搜索完后释放) int stacktop;

char map[][6]={{'x','x','x','x','x','x'},

{'x','e',' ',' ',' ','x'},

{'x','x',' ','x',' ','x'},

{'x','x',' ',' ',' ','x'},

{'x','x','x','x','s','x'},

{'x','x','x','x','x','x'} };//地图数据

int dis_map[MAPMAXSIZE][MAPMAXSIZE];//保存搜索路径时,中间目标地最优解

int map_w,map_h;//地图宽和高

int start_x,start_y,end_x,end_y; //地点,终点坐标

// 路径寻找主函数

void findpath(int *path)

{

//printf("%d,%d,%d,%d",start_x,start_y,end_x,end_y);

TREE root;

int i,j;

stacktop=0;

for (i=0;i

for (j=0;j

init_queue();

root=(TREE)malloc(sizeof(*root));

root->tile=tile_num(start_x,start_y);

root->h=0;

root->father=NULL;

enter_queue(root,judge(start_x,start_y));

for (;;) {

int x,y,child;

TREE p;

root=get_from_queue();

if (root==NULL) {

*path=-1;

return;

}

x=tile_x(root->tile);

y=tile_y(root->tile);

if (x==end_x && y==end_y) break;// 达到目的地成功返回

child=trytile(x,y-1,root);//尝试向上移动

child&=trytile(x,y+1,root);//尝试向下移动

child&=trytile(x-1,y,root);//尝试向左移动

child&=trytile(x+1,y,root);//尝试向右移动

if (child!=0)

pop_stack();// 如果四个方向均不能移动,释放这个死节点

}

// 回溯树，将求出的最佳路径保存在 path[] 中

for (i=0;root;i++) {

path[i]=root->tile;

root=root->father;

//printf("pathis %d",path[i]);

}

path[i]=-1;

freetree(); }

// 估价函数,估价 x,y 到目的地的距离,估计值必须保证比实际值小

int judge(int x,int y)

{

int distance;

distance=abs(end_x-x)+abs(end_y-y);

return distance;

}

// 尝试下一步移动到 x,y 可行否

int trytile(int x,int y,TREE father)

{

TREE p=father;

int h;

if (map[y][x]=='x') return 1; // 如果 (x,y) 处是障碍,失败

while (p) {

if (x==tile_x(p->tile) && y==tile_y(p->tile)) return 1; //如果 (x,y) 曾经经过,失败

p=p->father;

}

h=father->h+1;

if (h>=dis_map[y][x]) return 1;// 如果曾经有更好的方案移动到 (x,y) 失败 dis_map[y][x]=h;// 记录这次到 (x,y) 的距离为历史最佳距离

// 将这步方案记入待处理队列

p=(TREE)malloc(sizeof(*p));

p->father=father;

p->h=father->h+1;

p->tile=tile_num(x,y);

enter_queue(p,p->h+judge(x,y));

return 0;

}

3. 打开c语言编译器，输入我们的运行代码，编译，运行如下，打印出地图如下图：

4. 点任意键进行运行找静态路网

5. 说明：找到路后会存到一个数组中去，我们为了显示这个过程可以运用打印函数打印出来代码如下

void printpath(int *path)

{

int i;

//printf("-[1**********]444");

for (i=0;path[i]>=0;i++) {

gotoxy(tile_x(path[i])+1,tile_y(path[i])+1);

printf("-");

Sleep(2000);

}

printf("\n");

printf("\n");

printf("走迷宫完成");

}

6. 整个程序的代码如下：

#include

#include"stdio.h"

#include

#include"assert.h" #include"stdlib.h"

#define MAPMAXSIZE 100 //地图面积最大为 100x100

#define MAXINT 8192 //定义一个最大整数, 地图上任意两点距离不会超过它 #define STACKSIZE 65536 //保存搜索节点的堆栈大小

#define tile_num(x,y) ((y)*map_w+(x)) //将 x,y 坐标转换为地图上块的编号 #define tile_x(n) ((n)%map_w) //由块编号得出 x,y 坐标

#define tile_y(n) ((n)/map_w)

// 树结构, 比较特殊, 是从叶节点向根节点反向链接

typedef struct node *TREE;

struct/*designde by [email protected]*/ node {

int h;

int tile;

TREE father;

};

typedef struct /*designde by [email protected]*/node2 *LINK;

struct node2 {

TREE node;

int f;/*designde by [email protected]*/

LINK next;

};

LINK queue; // 保存没有处理的行走方法的节点

TREE stack[STACKSIZE]; // 保存已经处理过的节点 (搜索完后释放) int stacktop;

char map[][6]={{'x','x','x','x','x','x'},

{'x','e',' ',' ',' ','x'},

{'x','x',' ','x',' ','x'},

{'x','x',' ',' ',' ','x'},

{'x','x','x','x','s','x'},

{'x','x','x','x','x','x'} };//地图数据

int

中间目标地最优解 dis_map/*designde by [email protected]*/[MAPMAXSIZE][MAPMAXSIZE];//保存搜索路径时,

int map_w,map_h;//地图宽和高

int start_x,start_y,end_x,end_y; //地点,终点坐标

void gotoxy(int x ,int y)

{

HANDLE a;

COORD zb;

zb.X =x-1;

zb.Y =y-1;

a= GetStdHandle(STD_OUTPUT_HANDLE/*designde [email protected]*/);

SetConsoleCursorPosition(a,zb);

}

// 初始化队列

void init_queue()

{

queue=(LINK)malloc(sizeof(*queue));

queue->node=NULL;

queue->f=-1;

queue->next=(LINK)/*designde

[email protected]*/malloc(sizeof(*queue));

queue->next->f=MAXINT;

queue->next->node=NULL;

queue->next->next=NULL;

}

// 待处理节点入队列, 依靠对目的地估价距离插入排序 void enter_queue(TREE node,int f)

{

LINK p=queue,father,q;

while(f>p->f) {

father=p;

p=p->next/*designde by [email protected]*/;

assert(p);

} by by

q=(LINK)malloc(sizeof(*q)); assert(queue);

q->f=f,q->node=node,q->next=p;

father->next=q;

}

// 将离目的地估计最近的方案出队列

TREE get_from_queue()

{

TREE bestchoice=queue->next->node;

LINK next=queue->next->next;

/*designde by [email protected]*/free(queue->next);

queue->next=next;

stack[stacktop++]=bestchoice;

assert(stacktop

return /*designde by [email protected]*/bestchoice;

}

// 释放栈顶节点

void pop_stack()

{

free(stack[--stacktop]);

}

// 释放申请过的所有节点

void freetree()

{

int i;

LINK p;

for (i=0;i

free(stack);

while /*designde by [email protected]*/(queue) {

p=queue;

free(p->node);

queue=queue->next;

free(p);

} }

// 估价函数,估价 x,y 到目的地的距离,估计值必须保证比实际值小 int judge(int x,int y)

{

int distance;

distance=abs(end_x-x)+abs(end_y-y);

return distance;

}

// 尝试下一步移动到 x,y 可行否

int trytile(int/*designde by [email protected]*/ x,int y,TREE father) {

TREE p=father;

int h;

if (map[y][x]=='x') return 1; // 如果 (x,y) 处是障碍,失败

while (p) {

/*designde

p=p->father;

}

h=father->h+1;

if (h>=dis_map[y][x]) return 1;// 如果曾经有更好的方案移动到 (x,y) 失败 dis_map[y][x]=h;// 记录这次到 (x,y) 的距离为历史最佳距离

// 将这步方案记入待处理队列

p=(TREE)malloc(sizeof(*p));

p->father=father;

p->h=father->h+1;

p->tile=tile_num(x,y);

enter_queue(p,p->h+judge(x,y));

return 0;

}

// 路径寻找主函数

void findpath(int *path) by [email protected]*/if (x==tile_x(p->tile) && y==tile_y(p->tile)) return 1; //如果 (x,y) 曾经经过,失败

{ //printf("%d,%d,%d,%d",start_x,start_y,end_x,end_y); TREE root;

int i,j;

stacktop=0;

for (i=0;i

for (j=0;j

dis_map[i][j/*designde by [email protected]*/]=MAXINT; init_queue();

root=(TREE)malloc(sizeof(*root));

root->tile=tile_num(start_x,start_y);

root->h=0;

root->father=NULL;

enter_queue(root,judge(start_x,start_y));

for (;;) {

int x,y,child;

TREE p;

root=get_from_queue();

if (root==NULL) {

*path=-1;

return;

}

x=tile_x(root->tile);

y=tile_y(root->tile);

if (x==end_x && y==end_y) break;// 达到目的地成功返回 child=trytile(x,y-1,root);//尝试向上移动

child&=trytile(x,y+1,root);//尝试向下移动

child&=trytile(x-1,y,root);//尝试向左移动

child&=trytile(x+1,y,root);//尝试向右移动

if (child!=0)

pop_stack();// 如果四个方向均不能移动,释放这个死节点 }

// 回溯树，将求出的最佳路径保存在 path[] 中

for (i=0;root;i++) { path[i]=root->tile;

root=root->father;

//printf("pathis %d",path[i]/*designde by [email protected]*/); }

path[i]=-1;

freetree();

}

void printpath(int *path)

{

int i;

//printf("-[1**********]444");

for (i=0;path[i]>=0;i++) {

gotoxy(tile_x(path[i])+1,tile_y(path[i])+1);

printf("-");

Sleep(2000);

}

printf("\n");

printf("\n");

printf("走迷宫完成");

}

void readmap()

{ printf("走迷宫，s是起始点 e是终点 按任意键开始"); getchar();

//FILE *f;

int i,j;

//f=fopen("2.c","r");

//assert(f);

//scanf("%d%d",&map_w,&map_h);

map_w=map_h=6;

for (i=0;i

//fgets(&map[i][0],map_w+1,f);

//fclose(f);

start_x=-1,end_x=-1; for (i=0;i

for (j=0;j/*designde by [email protected]*/

if (map[i][j]=='e') map[i][j]=' ',end_x=j,end_y=i;

}

assert(start_x>=0 && end_x>=0);

//printf("%d,%d,%d,%d",start_x,start_y,end_x,end_y);

}

void showmap()

{

int i,j;

system("cls");

for (i=0;i

gotoxy(1,i+1);

for (j=0;j

if (map[i][j]!=' ') printf("x");

else printf(" ");

}

gotoxy(end_x+1,end_y+1);

printf("e");

gotoxy(start_x+1,start_y+1);

printf("s");

}

int main()

{

system("title 晓博 A*算法试验程序");//设置cmd窗口标题 printf("…………欢迎使用晓博 A*算法试验程序，[email protected] 河南财经政法大学…………"); int path[MAXINT];

readmap();

showmap();

Sleep(2000); Designed by

findpath(path); printpath(path); getchar();

system("pause"); return 0; }

END

注意事项  为了使的程序可以慢慢的打印出来动态的运行效果 加了Sleep(2000);


相关文章

  • 智能优化算法概述

    • 本栏目责任编辑:李桂瑾人工智能及识别技术 智能优化算法概述 蒋腾旭 (九江职业大学计算机系,江西九江332000) 摘要:本文简要介绍了几种常见的智能优化算法,并给出了不同智能优化算法的优缺点及在优化应用领域的使用情况,指出了不同智能优化算 ...查看


  • 人工智能学年论文--对人工神经网络学习的探讨

    • 人工智能课程论文 学 院 计算机与信息技术 专 业 计算机科学与技术 年 级 2010级计科一班 姓 名 课 题 对人工神经网络学习的探讨 对人工神经网络学习的探讨 摘要: 随着智能技术研究和应用的不断深入,人工智能越来越受到社会的关注.在 ...查看


  • 智能交叉算子遗传算法的新机制

    • ComputerEngineeringandApplications计算机工程与应用 智能交叉算子遗传算法的新机制 张建彬,陈抱雪,隋国荣,王关德 ZHANGJian-bin.CHENBao-xue,SUI Guo-rong,WANGGua ...查看


  • 无人机航迹规划常用算法

    • V01．37,No．8Aug．2012 Fire 火力与指挥控制 Control&CommandControl 第37卷第8期 2012年8月 文章编号:1002-0640(2012)08-0005-04 无人机航迹规划常用算法 王 ...查看


  • 智能控制技术的研究

    • 智能控制技术的研究 Research for Intelligent Control Technology (ICT) 于卫平 彭亦功 (华东理工大学,上海 200237) 摘 要:以智能控制产生背景为研究基础,分析了智能控制技术的特点,并 ...查看


  • 一种新颖的仿生群智能优化算法_萤火虫算法

    • 第28卷第9期2011年9月计算机应用研究 ApplicationResearchofComputersVol．28No．9Sep．2011 一种新颖的仿生群智能优化算法: * 萤火虫算法 1,21 刘长平,叶春明 (1．上海理工大学管理学 ...查看


  • 商务智能(BI)论文:汽车营销商务智能软件的设计与实现

    • 商务智能(BI)论文:汽车营销商务智能软件的设计与实现 [中文摘要]中国加入了世贸组织(WTO)以后,中国汽车行业的竞争变得更加激烈和残酷,国外企业逐步进入中国市场,国内企业不断扩大规模,都纷纷抢夺资源.客户和市场.面对这些竞争压力,汽车企 ...查看


  • 蚁群优化算法

    • 蚁群优化算法目录 [隐藏] 比较1 2蚁群算法的提出: 人工蚂蚁与真实蚂蚁的异同o o     3 4 5 6 72.1 2.2相同点比较 不同点比较蚁群算法的流程图 基本蚁群算法的实现步骤 蚁群算法的 matlab 源程序 ...查看


  • 十五数码问题研究及实现

    • 2010年第2期福建电脑 73 十五数码问题研究及实现 闵文杰 (重庆交通大学重庆400047) [摘要]:十五数码问题是人工智能领域中的一个典型问题.本文对该问题进行了详细分析,并用启发式搜索解决了该问题,同时比较了3种不同评估函数的效率 ...查看


  • 技术贴 | 从算法层解读,自动驾驶的「轨迹规划」如何实现?

    • 车辆自主驾驶系统从本质上讲是一个智能控制机器,其研究内容大致可分为信息感知.行为决策及操纵控制三个子系统.路径规划是智能车辆导航和控制的基础,是从轨迹决策的角度考虑的,可分为局部路径规划和全局路径规划. 全局路径规划的任务是根据全局地图数据 ...查看


热门内容