A* search ,find the shortest path

最新推荐文章于 2024-04-24 17:52:48 发布
最新推荐文章于 2024-04-24 17:52:48 发布
阅读量294 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 人工智能 文章标签： path search null struct c system
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/lihong_maths/article/details/6070267
本文介绍了一种基于A*搜索算法实现寻路的功能，并详细展示了算法的具体实现过程，包括节点结构定义、开放列表与关闭列表操作、路径评估与扩展等关键步骤。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

/********************************************
Function： A* search ,find the shortest path
Create Date: 2010 5.28
By:          LiHong
********************************************/
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <cstdlib>/*系统暂停头文件*/
#include <malloc.h>
#include <math.h>
#include <iostream>
#define  MAP_W 60
#define  MAP_H 30
struct POSITION{
 int x;
 int y; 
};
typedef struct Node NODE;
 struct Node {
 int x_axis;
 int y_axis;
 int g;
 int h;
 int f;
 NODE *Parent;
 NODE *Child[4];       /* a node may have upto 4(NULL) children. */
 NODE *next;
};
struct STACK {
 NODE *node;
 struct STACK *next;
};
class AiSearch{
    public:
           struct POSITION path[441];
           int cost;
           char map[MAP_H][MAP_W];
    protected:
    NODE *OPEN,*CLOSED;
    struct STACK *stack;/*全局变量*/
    private:
    public:
    AiSearch();
    virtual ~AiSearch();
   void initMap(char mapinfo[][MAP_W]);
    NODE *returnBestNode();
    void insertNode(NODE *Successor);
    NODE *checkOpenTable(int x,int y);
    NODE *checkClosedTable(int x,int y);
    void expandNode(NODE *BestNode,int dx,int dy);
    void expandNodeSucc(NODE *BestNode,int x, int y, int dx, int dy);
    void freshOldValue(NODE *Old);
    void Push(NODE *Node);
    NODE *Pop();
    void findPath(int sx,int sy,int dx,int dy);                              
};

AiSearch::AiSearch()
{
cost=0;
}

AiSearch::~AiSearch()
{

}
void AiSearch::initMap(char mapinfo[][MAP_W])
{
 int i,j;
 for(i=0;i<MAP_H;i++){
     for(j=0;j<MAP_W;j++){
     map[i][j]=mapinfo[i][j];
     }
 }
}

NODE * AiSearch::returnBestNode()
{
 NODE *tmp;
 if(OPEN->next==NULL){
 return NULL;
 }
 tmp = OPEN->next;
 OPEN->next = tmp->next;
 tmp->next = CLOSED->next;
 CLOSED->next = tmp;
 return(tmp);
}

void AiSearch::insertNode(NODE *Successor)
{
 NODE *tmp1,*tmp2;
 int f;
 if(OPEN->next == NULL) {
  OPEN->next = Successor;
  return;
 }
 f = Successor->f;
 tmp1 = OPEN;
 tmp2 = OPEN->next;
 while( ( tmp2 != NULL ) && ( tmp2->f < f ) ) {
  tmp1 = tmp2;
  tmp2 = tmp2->next;
 }
 Successor->next = tmp2;
 tmp1->next = Successor;
}

NODE * AiSearch::checkOpenTable(int x,int y)
{
 NODE *tmp;
 if(OPEN->next==NULL){
 return NULL;
 }
 tmp= OPEN->next;
 while( tmp!=NULL ) {
  if( tmp->x_axis == x && tmp->y_axis==y )
  return( tmp );
  else
  tmp = tmp->next;
 }
 return( NULL );
}

NODE * AiSearch::checkClosedTable(int x,int y)
{
 NODE *tmp;
 if(CLOSED->next==NULL){
 return NULL;
 }
 tmp = CLOSED->next;
 while( tmp!=NULL ) {
  if( tmp->x_axis == x && tmp->y_axis==y )
  return( tmp );
  else
  tmp = tmp->next;
 }
 return( NULL );
}

void AiSearch::expandNode(NODE *BestNode,int dx,int dy)
{
 int x,y;
 /* Upper */
 x = BestNode->x_axis;
 y = BestNode->y_axis - 1;
 if( y >= 0 && map[y][x]!='#' )
 { expandNodeSucc(BestNode,x,y,dx,dy);}
 /* Right */
 x = BestNode->x_axis + 1;
 y = BestNode->y_axis;
 if( x < MAP_W && map[y][x]!='#')
 {expandNodeSucc(BestNode,x,y,dx,dy);}
 /* Lower */
 x = BestNode->x_axis;
 y = BestNode->y_axis + 1;
 if( y < MAP_H && map[y][x]!='#')
 {expandNodeSucc(BestNode,x,y,dx,dy);}
 /* Left */
 x = BestNode->x_axis - 1;
 y = BestNode->y_axis;
 if( x >= 0 && map[y][x]!='#' )
 { expandNodeSucc(BestNode,x,y,dx,dy);}
}
void AiSearch::expandNodeSucc(NODE *BestNode,int x, int y, int dx, int dy)
{
 int g, c;
 NODE *Old,*Successor;
 //g = BestNode->g + TileMap[TileNumS];
 g = BestNode->g + 1;

 if( ( Old = checkOpenTable(x,y) ) != NULL ) {
  for( c = 0; c < 4; c ++ ) {
   if( BestNode->Child[c] == NULL ) break;
  }
  BestNode->Child[c] = Old;
  if( g < Old->g ) {
   Old->Parent = BestNode;
   Old->g = g;
   //Old->f = g + Old->h + Old->i;
   Old->f = g + Old->h;
  }
 }
 else if( ( Old = checkClosedTable(x,y) ) != NULL ) {
  for( c = 0; c < 4; c ++ ) {
   if( BestNode->Child[c] == NULL ) break;
  }
  BestNode->Child[c] = Old;
  if( g < Old->g ) {
   Old->Parent = BestNode;
   Old->g = g;
   Old->f = g + Old->h;
   //Old->f = g + Old->h + Old->i;
   freshOldValue( Old );
  }
 }
 else {
  Successor = (NODE *)calloc(1,sizeof(NODE ));
  Successor->Parent = BestNode;
  Successor->g = g;
  //Successor->h = abs( x - dx ) + abs( y - dy );
  Successor->h =abs( x - dx ) + abs( y - dy );
  Successor->f = g + Successor->h;
  Successor->x_axis = x;
  Successor->y_axis = y;
  Successor->next=NULL;
  insertNode(Successor);
  for( c = 0; c < 4; c ++ ) {
   if( BestNode->Child[c] == NULL ) break;
  }
  BestNode->Child[c]=Successor;
 }
}
void AiSearch::freshOldValue(NODE *Old)
{
 int c,g;
 NODE *Child, *Father;

 g = Old->g;
 for( c = 0; c < 4; c ++ ) {
  if( ( Child = Old->Child[c] ) == NULL ) break;
  if( g + 1 < Child->g ) {
   Child->g = g + 1;
   //Child->f = Child->g + Child->h + Child->i;
   Child->f = Child->g + Child->h;
   Child->Parent = Old;
   Push( Child );
  }
 }
 while( stack->next!= NULL ) {
  Father = Pop();
  for( c = 0; c < 4; c ++ ) {
   if( ( Child = Father->Child[c] ) == NULL ) break;
   if( Father->g + 1 < Child->g ) {
    Child->g = Father->g + 1;
    //Child->f = Child->g + Child->h + Child->i;
    Child->f = Child->g + Child->h;
    Child->Parent = Father;
    Push( Child );
   }
  }
 }
}


void AiSearch::Push(NODE *Node)
{
    struct STACK *tmp;
    tmp = ( struct STACK *)calloc(1,sizeof(struct STACK));
    tmp->node = Node;
    if(stack->next == NULL) {
    tmp->next = NULL;
    }else{
    tmp->next = stack->next;
    }
    stack->next = tmp;
}

 NODE * AiSearch::Pop()
{
    NODE *tmp;
    struct STACK *tmpstack;
    tmpstack = stack->next;
    tmp = tmpstack->node;
    stack->next = tmpstack->next;
    free( tmpstack );
    return( tmp );
}

void AiSearch::findPath(int sx,int sy,int dx,int dy)
{
NODE *node, *bestnode;
NODE *father; 
int i=0;
stack=( struct STACK *)calloc(1,sizeof(struct STACK)); 
OPEN=(NODE *)calloc(1,sizeof(NODE ));
CLOSED=(NODE *)calloc(1,sizeof(NODE ));
node=(NODE *)calloc(1,sizeof(NODE ));//source 节点
node->g = 0;
//这是计算h值
//node->h =int(sqrt( (dx-sx)*(dx-sx) + (dy-sy)*(dy-sy)));
node->h =abs(dx-sx)+abs(dy-sy);
//这是计算f值，即估价值
node->f = node->g+node->h;
node->x_axis =sx; node->y_axis = sy;
node->next=NULL;
// make Open List point to first node
OPEN->next=node;
for(;;){
bestnode=returnBestNode();
if (bestnode==NULL){
cost=0;
break;
}
if(bestnode->x_axis==dx && bestnode->y_axis==dy) {
  father=bestnode;
  cost=0;
  while(father!=node && father->Parent!=NULL){
     path[i].x=father->x_axis, path[i].y=father->y_axis;
     i++;
     cost++;
     father=father->Parent; 
  }
 
break;
}else{
expandNode(bestnode, dx, dy);//扩展这个节点     
}      
}
}

char map[MAP_H][MAP_W];
int start_x=0,start_y,end_x=0,end_y;

//将地图信息map.dat载入到map全局数组中,map.dat中只含#,s,e和空格字符
int readMap()
{
    FILE *f;
    int i,j;
    if((f=fopen("map.dat","r"))==NULL){
     printf("open file err!");
     return 0;                               
    }
    for(i=0;i<MAP_H;i++){
            fgets(&map[i][0],MAP_W+2,f) ;           
    }  
    fclose(f);
    for (i=0;i<MAP_H;i++){
      for (j=0;j<MAP_W;j++){
        if (map[i][j]=='s') {
        map[i][j]=' ',start_x=j,start_y=i;
        }          
        if (map[i][j]=='e'){
        map[i][j]=' ',end_x=j,end_y=i;
        }
      }
   }
    if(start_x>0 && end_x>0)
    return 1;
    else
    return 0;
}

//打印地图和找到的一条路径
void showMap(struct POSITION path[],int cost)
{
 int i,j;
 int ii,flag=0;
 for (i=0;i<MAP_H;i++){
    for (j=0;j<MAP_W;j++){
     for(ii=0;ii<cost;ii++){
     flag=0;
        if(path[ii].x==j && path[ii].y==i){
      printf("o");
    flag=1;
    break;
     }
     }
    if(flag==0){
           printf("%c",map[i][j]);
     }
  } 
     printf("/n");
 }

}

 

// the main fucnction is for test
int main(int argc, char *argv[])
{   int i;
    AiSearch ai;
    if(!readMap()){
    printf("the map is err!");
       system("PAUSE");
    }
    ai.initMap(map);
    ai.findPath(start_x,start_y,end_x,end_y);
    showMap(ai.path,ai.cost);
    for(i=0;i<ai.cost;i++){
       printf("%d_%d  ",ai.path[i].x,ai.path[i].y);
    }
    printf("/ncost:%d/n",ai.cost);
    //printf("%d %d/n",start_x,start_y);
    system("PAUSE");
    return EXIT_SUCCESS;
}

最短路 Finding Shortest Path
yake1965
12-24 1700
最短路（Finding Shortest Path）
A* Search Algorithm
weixin_41697507的博客
05-18 790
Motivation To approximate the shortest path in real-life situations, like- in maps, games where there can be many hindrances. We can consider a 2D Grid having several obstacles and we start from a sou...
hrbust 2369 Find the shortest path
努力打工
03-25 318
题意：    最短路裸题：唯一坑点两点间路径不唯一去最短。#include&lt;stdio.h&gt; #include&lt;string.h&gt; #include&lt;algorithm&gt; using namespace std; #define inf 0x3f3f3f3f int T; int n,m; int M[105][105]; int main(){ sca...
find shorttest path
Marshall的专栏
03-08 755
def find_shortest_path(maze): ''' maze = [['X', 'X', 'O', 'S', 'X'], ['X', 'X', 'O', 'O', 'X'], ['X', 'X', 'O', 'X', 'X'], ['X', 'X', 'O', 'E', 'X...
Find The Shortest Path In Triangle Numbers
Bo Yang's Blog
09-16 1783
Problem An example of triangle of numbers is: 1 / \ 2 5 / \ / \ 9 4 33 / \ / \/ \ 11 6 99 0 In each row (except for the last), the numbers are adjacent to two numbers
Informed A* algorithm to find the shortest path between two nodes
Terry C. Gao 的专栏
09-15 1269
Written a couple of months ago  and now post up in case it might be helpful to someone interested./*-------------------------------------------------------------------------------------- *   *  Inform
Consider a problem to find the shortest path from a given starting node s to any other nodes in the (undirected) graph. The length of a path in the graph is the number of edges included. Complete the function shortest_path(adj_list, s), which takes the adjacency list of the graph and a starting node as input, and returns a list containing the length of the shortest path from the starting node to all other nodes. Note: If there is no path from the starting node to a node, set the length of shortest path as float('inf'). You can use any Python built-in package to implement the stack/queue/priority queue if needed. Hint: Consider the three graph traversal strategies (DFS, BFS and PFS) discussed in the class. Which one is applicable in this problem? For example: Test Result adj_list = [[], [2, 3], [1, 4], [1], [2]] d = shortest_path(adj_list, 0) print(d) d = shortest_path(adj_list, 2) print(d) [0, inf, inf, inf, inf] [inf, 1, 0, 2, 1]
05-26
To find the shortest path from a given starting node s to any other nodes in the (undirected) graph, we can use Breadth-First Search (BFS) algorithm. The basic idea of BFS is to explore all the ...
ShortestPath
03-28
"ShortestPath"这个程序正是针对这一问题的解决方案，它利用了广度优先遍历（Breadth First Search，简称BFS）算法来查找两点之间的最短路径。在布满障碍的地图中，寻找最短路径是一个典型的图论问题，涉及到节点、...
路径规划算法 | A* 搜索算法
最新发布
一点人工一点智能的博客
04-24 2648
A*搜索算法是一种用于路径搜索和图遍历的效果很好、主流的技术之一。
《算法图解》笔记-Breath-first search
Qiudan的博客
02-20 449
Breath-first search（BFs） 解决两种问题： Is there a path from node A to node B? A和B之间是否存在路径 What is the shortest path from node A to node B? 寻找最短路径 步骤： 1. 用graph表示问题 Graph： 由nodes和edges构成 neighbors: 直接相连的nodes Directed Graph: 定向的，只能由一个方向指向另一个。 Undirect
牛客 每日一题 8 Shortest Path 题解（思维）
hunxuewangzi的博客
04-14 243
题目链接 题目大意 给你一棵 n 个节点的树（保证 n 是偶数），你需要将 n 个节点分为 n/2 个点对，使得每个点对的两个点的距离的和最小。 题目思路 这是一个打着图论题幌子的思维题。。。。 首先我们可以通过观察得到以下几点： 首先，在最短的距离和之中一条边一定不会被覆盖两次，如图，我们一定可以找到一种方法来交换配对，把重复的边去掉（其他的边是不会变的）。也就是说对于一条边来说，其实只有选和不...
python文件读写20/9/10
qq_34977841的博客
09-10 337
python访问文件的时候路径问题 1、python的os.path.isdir()参数只能是绝对路径，相对路径无法识别。 2、为避免分隔符混乱，在拼接地址的时候最好用os.path.join() 3、open()的路径可以是绝对路径或相对路径 4、分隔符’’ 和’/’ 分别用在绝对路径和相对路径中 ...
图解-迪杰斯特拉算法（找最短路径）Dijkstra's Algorithm (finding shortestpaths)
wengyupeng 蜗牛一步一步向前。。。
12-14 2766
转自：http://www.mathcs.emory.edu/~cheung/Courses/171/Syllabus/11-Graph/dijkstra2.html   一. 图解迪杰斯特拉   Before showing you the pseudo code, I will first execute the Dijkstra's Algorithm on the followin...
人工智能导论-搜索策略（pacman.py）吃豆人
热门推荐
junruit的博客
01-14 4万+
实验内容： 实验要求采用且不限于课程第四章内各种搜索算法此编写一系列吃豆人程序解决以下列出的问题1-8，包括到达指定位置以及有效的吃豆等。 简介： 参考网址：http://ai.berkeley.edu/search.html内容，以下为实验简介。 基本代码和支持文件可以从search.zip中获取。其中，一些需要参考的文件如下： 需要编辑的文件：search.py和searchAgen
集束搜索（Beam Search Algorithm ）
DavidChen的博客
08-06 1万+
看计算机科学中最重要的32个算法，其中有个是集束搜索（又名定向搜索，Beam Search）——最佳优先搜索算法的优化。使用启发式函数评估它检查的每个节点的能力。不过，集束搜索只能在每个深度中发现前m个最符合条件的节点，m是固定数字——集束的宽度。 泛泛的介绍，不是很能理解清楚，于是有百度又google，写篇东西备忘。先贴维基百科的地址：Beam Search 翻译过来就是： Beam Se
6-1 Shortest Path [3]
weixin_43301333的博客
10-19 1274
Shortest Path 3 (10分) Write a program to not only find the weighted shortest distances, but also count the number of different minimum paths from any vertex to a given source vertex in a digraph. It...
K8s 很难么？带你从头到尾捋一遍，不信你学不会
民工哥的博客
02-23 9846
点击关注公众号，回复“1024”获取2TB学习资源！为什么要学习 Kubernetes?虽然 Docker 已经很强大了，但是在实际使用上还是有诸多不便，比如集群管理、资源调度、文件管理等...
10天智能锁项目实战第1天（了解单片机STM32F401RET6和C语言基础）
北豼不太皮的博客
02-21 4026
10天智能锁项目实战第1天（了解单片机STM32F401RET6和C语言基础）一、学习目标二、了解单片机STM32F401RET6三、C语言基础 一、学习目标 二、了解单片机STM32F401RET6 4、STM32F401RE特征 三、C语言基础 1.数据类型 常用2的次方： 2^7 = 128 2^8 = 256 2^15 = 32768 2^16= 65536 51单片机常见的数据类型： char: 占内存1字节 取值范围：-128~127 -2^7 ~ 2
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值