A Start A星算法

最新推荐文章于 2024-04-16 00:37:29 发布
最新推荐文章于 2024-04-16 00:37:29 发布
阅读量2.4k 收藏 1
点赞数
分类专栏： c++ 算法 文章标签： c++ c++11 A
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xie1xiao1jun/article/details/71097456
版权
c++ 同时被 2 个专栏收录
115 篇文章 2 订阅
订阅专栏
算法
4 篇文章 0 订阅
订阅专栏

启发式算法

俗称Astart A*算法

 

 

//启发式算法
#include <iostream>  
#include <vector>  
#include <stdio.h>  
#include <algorithm>  
#include <memory>
#include <random>

//int nnn = 0;
using namespace std;
class Node {
public:
	int x;//行
	int y;//列
	int f;//g+h  
	int g;//起点到当前点的消耗   
	int h;//重点到当前点的理论消耗   
	std::shared_ptr <Node>parent;
	Node(int x, int y) {
		this->x = x;
		this->y = y;
		this->f = 0;
		this->g = 0;
		this->h = 0;
		this->parent = NULL;
	}
	Node(int x, int y, std::shared_ptr<Node> parent) {
		this->x = x;
		this->y = y;
		this->f = 0;
		this->g = 0;
		this->h = 0;
		this->parent = parent;
	}
};

//0表示可通过1表示障碍物   
int map[101][101] = {
	{ 0,0,0,1,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,1,0,0,0 },
	{ 0,0,0,1,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1,0,0,0,0 },
	{ 0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0 },
	{ 0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,1,0 },
	{ 0,0,0,1,1,1,0,1,0,0,0,1,1,1,0,1,0,0,0,1,1,1,0,1,0 },
	{ 0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 },
	{ 0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0 },
	{ 0,0,0,1,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,1,0,0,0 },
	{ 0,0,0,1,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1,0,0,0,0 },
	{ 0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0 },
	{ 0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,1,0 },
	{ 0,0,0,1,1,1,0,1,0,0,0,1,1,1,0,1,0,0,0,1,1,1,0,1,0 },
	{ 0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 },
	{ 0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0 },
	{ 0,0,0,1,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,1,0,0,0 },
	{ 0,0,0,1,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1,0,0,0,0 },
	{ 0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0 },
	{ 0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,1,0 },
	{ 0,0,0,1,1,1,0,1,0,0,0,1,1,1,0,1,0,0,0,1,1,1,0,1,0 },
	{ 0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 },
	{ 0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0 }
};
int map1[101][101] = {
	{ 0,0,0,1,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,1,0,0,0 },
	{ 0,0,0,1,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1,0,0,0,0 },
	{ 0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0 },
	{ 0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,1,0 },
	{ 0,0,0,1,1,1,0,1,0,0,0,1,1,1,0,1,0,0,0,1,1,1,0,1,0 },
	{ 0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 },
	{ 0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0 },
	{ 0,0,0,1,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,1,0,0,0 },
	{ 0,0,0,1,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1,0,0,0,0 },
	{ 0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0 },
	{ 0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,1,0 },
	{ 0,0,0,1,1,1,0,1,0,0,0,1,1,1,0,1,0,0,0,1,1,1,0,1,0 },
	{ 0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 },
	{ 0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0 },
	{ 0,0,0,1,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,1,0,0,0 },
	{ 0,0,0,1,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1,0,0,0,0 },
	{ 0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0 },
	{ 0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,1,0 },
	{ 0,0,0,1,1,1,0,1,0,0,0,1,1,1,0,1,0,0,0,1,1,1,0,1,0 },
	{ 0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 },
	{ 0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0 }
};

vector<std::shared_ptr<Node>> openList;
vector<std::shared_ptr<Node>> closeList;
int row;//地图总行数   
int col;//地图总列数   
std::shared_ptr<Node> startPos;//开始点   
std::shared_ptr<Node> endPos;//结束点   
int weightW;//平移权重   
int weightWH;//斜移权重   

int countH(std::shared_ptr<Node> sNode, std::shared_ptr<Node> eNode) {
	int w = abs(sNode->x - eNode->x);
	int h = abs(sNode->y - eNode->y);
	int cost = min(w, h)*weightWH + abs(w - h)*weightW;
	return cost;
}
void countFGH(std::shared_ptr<Node> sNode, std::shared_ptr<Node> eNode, int cost) {
	int h = countH(sNode, eNode);
	int g = sNode->parent->g + cost;
	int f = h + g;
	sNode->f = f;
	sNode->h = h;
	sNode->g = g;
}
//检测列表是否包含指定节点  
int isContains(vector<std::shared_ptr<Node>>* v, int x, int y) {
	for (int i = 0; i < v->size(); i++) {
		if (((*v)[i])->x == x
			&& ((*v)[i])->y == y) {
			return i;
		}
	}
	return -1;
}
void initMap() {
	row = 21;
	col = 25;
	memcpy(map, map1, sizeof(int) * 101 * 101);
	weightW = 15;
	weightWH = 20;

	std::random_device rd;
	std::mt19937 gen(rd());
	std::uniform_int_distribution<> dis(0, row);
	std::uniform_int_distribution<> dis1(0, col);

	startPos = std::shared_ptr<Node>(new Node(dis(gen), dis1(gen)));
	endPos = std::shared_ptr<Node>(new Node(dis(gen), dis1(gen)));
	startPos = std::shared_ptr<Node>(new Node(0, 0));
	endPos = std::shared_ptr<Node>(new Node(20, 24));
	//nnn += 2;
	printf("start(%d,%d),end(%d,%d)\n", startPos->x, startPos->y, endPos->x, endPos->y);
}

void printMap() {
	for (int i = 0; i < row; i++) {
		for (int j = 0; j < col; j++) {
			printf("%d ", map[i][j]);
		}
		printf("\n");
	}
}
bool compare(std::shared_ptr<Node> n1, std::shared_ptr<Node> n2) {
	return n1->f < n2->f;
}
void checkMove(int x, int y, std::shared_ptr<Node> & parent, std::shared_ptr<Node> & end, int cost) {
	if (map[x][y] == 1) {
		return;
	}
	if (isContains(&closeList, x, y) != -1) {
		return;
	}
	int index = -1;
	if ((index = isContains(&openList, x, y)) != -1) {
		//是否存在更小的G值  
		std::shared_ptr<Node> sNode = openList[index];
		if (parent->g + cost < sNode->g) {
			sNode->parent = parent;
			sNode->g = parent->g + cost;
			sNode->f = sNode->g + sNode->h;
			//openList.push_back(sNode);
		}
	}
	else {
		std::shared_ptr<Node> n = std::shared_ptr<Node>(new Node(x, y, parent));
		countFGH(n, end, cost);
		openList.push_back(n);
	}
}
void printPath(std::shared_ptr<Node> node) {
	if (node->parent != NULL) {
		printPath(node->parent);
	}
	//将走过的点标记为2   
	map[node->x][node->y] = 2;  
	printf("->%d,%d", node->x, node->y);
}
// void releaseNode(std::shared_ptr<Node> n) {
// 	if (n->parent != NULL) {
// 		releaseNode(n->parent);
// 	}
// 	//delete n;
// 	nnn--;
// }
//-1错误0没找到1找到   
int startSearch(std::shared_ptr<Node> start, std::shared_ptr<Node> end) {
	if (start->x < 0 || start->y < 0 || start->x >= row || start->y >= col
		|| end->x < 0 || end->y < 0 || end->x >= row || end->y >= col) {
		return -1;
	}
	if (map[start->x][start->y] == 1 || map[end->x][end->y] == 1) {
		return -1;
	}

	start->h = countH(start, end);
	start->f = start->h + start->g;
	//查找算法  
	openList.push_back(start);
	std::shared_ptr<Node> root = NULL;
	int find = 0;
	while (openList.size() > 0) {
		root = openList[0];
		if (root->x == end->x&&root->y == end->y) {
			find = 1;
			break;
		}
		//上下左右   
		if (root->x > 0) {
			checkMove(root->x - 1, root->y, root, end, weightW);
		}
		if (root->y > 0) {
			checkMove(root->x, root->y - 1, root, end, weightW);
		}
		if (root->x < row - 1) {
			checkMove(root->x + 1, root->y, root, end, weightW);
		}
		if (root->y < col - 1) {
			checkMove(root->x, root->y + 1, root, end, weightW);
		}
		if (root->x < row - 1 && root->y>0) {
			checkMove(root->x + 1, root->y - 1, root, end, weightWH);
		}
		if (root->y < col - 1 && root->x>0) {
			checkMove(root->x - 1, root->y + 1, root, end, weightWH);
		}
		if (root->x > 0 && root->y > 0) {
			checkMove(root->x - 1, root->y - 1, root, end, weightWH);
		}
		if (root->y < col - 1 && root->x < row - 1) {
			checkMove(root->x + 1, root->y + 1, root, end, weightWH);
		}
		closeList.push_back(root);
		openList.erase(openList.begin());
		std::sort(openList.begin(), openList.end(), compare);
	}
	if (find) {
		printPath(root);
		printf("\n");
		//printMap();  
	}
	//releaseNode(root);
	printMap();
	openList.clear();
	closeList.clear();
	return find;
}

#include<windows.h>
int main(int argc, char *argv[]) {
	while (true)
	{
		initMap();
		printMap();
		int t = startSearch(startPos, endPos);
		if (t == 1) {
			printf("find!\n");
		}
		else if (t == 0) {
			printf("no find.\n");
		}
		else {
			printf("error!\n");
		}
		Sleep(10);
	}

	return 0;
}

 

获取更多帮主请关注小程序

 

 

 

 

jnpher
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
A星寻路算法&B星寻路算法 c++实现 MFC
11-26
代码中实现了3种寻路算法AStar，AStar_Direct，BStar() 在VS2019环境下运行，建议以release方式运行，DEBUG没有调会崩溃
【路径规划】基于matlab A_star算法机器人栅格地图最短路径规划【含Matlab源码 496期】
订阅付费专栏（初级版），可赠送该付费专栏任意代码1份；
03-12 2093
A_star算法机器人栅格地图最短路径规划 完整的代码，方可运行；可提供运行操作视频！适合小白！
毕业设计 基于Astart的寻路算法设计与实现
noopier的博客
01-31 1168
今天学长向大家分享一个毕业设计项目毕业设计 基于Astart的寻路算法设计与实现毕业设计 基于Astart的自动寻路算法A*（念做：AStar）算法是一种很常用的路径查找和图形遍历算法。它有较好的性能和准确度。本文在讲解算法的同时也会提供Python语言的代码实现，并会借助matplotlib库动态的展示算法的运算过程。A*算法最初发表于1968年，由Stanford研究院的Peter Hart, Nils Nilsson以及BertramRaphael发表。
A* 算法
z1067832450_的专栏
02-14 232
1，广度优先算法 2，AStart算法 也称为启发式算法 1）当前代价 f 从起始点到当前方块花费的步数 2）预估代价 g 从当前方块到终点可能需要的步数 计算预估代价方法 a）欧拉距离： 计算两点之间的直线距离 b）曼哈顿距离：|x1-x2|+|y1-y2| = distance 3）总代价：当前代价+预估代价 则为最优路径 参考网站：Introduction to the A* Algorithm ...
【路径规划】Astart算法——图文直观解析
Jimmyshis
06-16 6583
Astart算法详解1. Astart算法原理 1.1. Astart算法路径搜索原理 1.2. 栅格网络的Astart算法2. Astart程序实现 Java 1. Astart算法原理  1.1. Astart算法路径搜索原理   Dijkstra算法已经是非常经典的求解最短路径的动态规划算法，其可在解空间的可行域内求解出唯一确定最短路径。但Dijkstra算法需要遍历解空间内所有的点，这在解空间节点数巨大的情况下十分占用计算资源，求解效率低下。而对于在三维构型空间或运动空间内路径规划常见的栅格网络法，
Astart寻路算法
DotNetFirst的专栏
07-21 1773
use A* to find path.../*written by hjjboyemail:[email protected]:156809986*/var closelist=new Array(),openlist=new Array();var gw=10,gh=10,gwh=14;var p_start=new Array(2),p_end=new Array(2);var
光速AStar寻路算法（C++）
略游
04-16 2799
光速AStar算法实现，基于C++ 一、最终效果 可以看到，我创建了500个小动物，也有110的FPS。虽然它们并不是每一帧都在计算寻路，但是平均下来不卡顿也不错了。我是i7 6700 + GT 720，这个效果图虽然不能直观的说明效率问题，但我相信我的AStar比网上一般的例子快。 如果对绘图的DND库感兴趣，可以移步我的其他文章。 二、使用方法 针对不同的物体，肯定有不同的寻路逻...
JavaScript Dijkstra算法 Astart算法
梁婉玲krysliang的博客
01-05 573
/** * 最短路径 * Dijkstra算法 * 首先根据起始顶点到当前顶点的dist 构建小顶堆，然后区堆顶元素。 * 取堆顶元素以后，需要从下往上堆化 * 然后取堆顶元素对应的邻接表中，更新每个顶点的dist值，并且入队。 */ class Graph{ constructor(v){ this.v = v;//图中的顶点 this.n = v.length; this.adj = new Array(this.n);//图...
使用A Star 算法实现自动寻路详解
是江迪呀 的博客
03-14 3311
寻路，嗯~
易语言A星寻路算法
04-23
易语言A星寻路算法，包含源码，Astart.dll，A星测试.e，寻路例程.e
astart算法astart算法
08-31
a*算法，基于网上的改的，xcode版本
AStart寻路算法
05-09
AStart寻路算法,代码为java
a star算法（A*算法）
06-17
一个关于A*算法的详细讲解 A*（A-Star)算法是一种静态路网中求解最短路最有 效的方法。
Astart（C++）.zip
07-01
A星c++版--进行了解耦，基本上可以通用 算法讲解：https://blog.csdn.net/qq_45620703/article/details/118368359
astar:a星寻路算法javascript的实现
07-24
最近要用到寻路算法，偷懒网上搜了一批，尼玛惨不忍睹，各种bug，没办法，自己动手丰衣足食。 本版本优化了两个地方，第一个是将经典的递归改成了循环避免了堆栈溢出，第二个是优化了路径尽量走直线。 关于用法 工程...
AStart_Algorithm.rar
12-18
基于winform开发，使用C#语言。可手设置起点与终点，能够添加障碍物，动态演示路径寻优过程，能够随机产生地图。
unity简单实现AStar A*算法
09-18
Unity简单实现A*算法 一、功能概述 1.地图节点类 坐标值； 定义节点类型； 记录父节点； 计算F,G,H； 2.AStart类 寻路； 寻找路径点； openList； closeList； 建立链表关系； 按照F值排序；
C++-命名空间
最新发布
WolvenSec的博客
04-16 709
C++ 命名空间是一种用于组织代码的机制，可以帮助避免命名冲突，提高代码的可读性和可维护性。命名空间将代码分组到逻辑单元中，允许在不同的代码单元中使用相同的名称而不会产生冲突。命名空间通过将代码放置在一个命名空间内部来实现。在 C++ 中，命名空间由关键字 namespace 开始，后面跟着命名空间的名称以及一对大括号，大括号中包含了命名空间内部的代码。
python 实现a星算法
10-23
A星算法是一种常用于寻路问题的启发式搜索算法，可以用Python进行实现。以下是一个用Python实现A星算法的简单示例： ```python import heapq # 定义节点类 class Node: def __init__(self, position=None, parent=None): self.position = position # 当前节点位置 self.parent = parent # 父节点 self.g = 0 # 从起点到当前节点的实际代价 self.h = 0 # 从当前节点到目标节点的估计代价 self.f = 0 # f = g + h # 实现A星算法 def a_star(start, goal): open_list = [] closed_list = [] # 添加起点到open list heapq.heappush(open_list, (0, start)) while open_list: # 选择f值最小的节点作为当前节点 current = heapq.heappop(open_list)[1] # 如果当前节点是目标节点，则搜索结束 if current == goal: path = [] while current: path.append(current.position) current = current.parent return path[::-1] # 反转路径，得到从起点到目标的最短路径 # 将当前节点添加到closed list中 closed_list.append(current) # 遍历当前节点的相邻节点 for neighbor in find_neighbors(current): # 如果相邻节点已经在closed list中，则跳过 if neighbor in closed_list: continue # 计算从起点经过当前节点到相邻节点的实际代价 temp_g = current.g + 1 # 如果相邻节点不在open list中，则添加到open list if neighbor not in [n[1] for n in open_list]: heapq.heappush(open_list, (neighbor.h, neighbor)) # 如果相邻节点已经在open list中，并且新计算的实际代价更小，则更新其实际代价和父节点 elif temp_g < neighbor.g: open_list.remove((neighbor.h, neighbor)) heapq.heappush(open_list, (neighbor.h, neighbor)) # 更新相邻节点的实际代价、估计代价和f值 neighbor.g = temp_g neighbor.h = heuristic(neighbor, goal) neighbor.f = neighbor.g + neighbor.h return [] # 搜索失败，返回空路径 # 定义估计函数，可以根据实际情况进行修改 def heuristic(node, goal): return abs(node.position[0] - goal.position[0]) + abs(node.position[1] - goal.position[1]) # 定义寻找相邻节点的函数 def find_neighbors(node): neighbors = [] # 编写具体的寻找相邻节点的逻辑 return neighbors # 调用A星算法寻路 start_node = Node((0, 0)) goal_node = Node((3, 3)) path = a_star(start_node, goal_node) if path: print("最短路径为:", path) else: print("无法找到路径") ``` 以上是一个简单的用Python实现A星算法的示例。通过定义节点类、实现A星算法函数和相关辅助函数，可以使用A星算法解决寻路问题。具体实现需要根据具体情况进行调整和完善。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值