A星算法,找寻最短路径

#include <iostream>
#include <cstdio>
#include <queue>
#include <algorithm>
#include <cmath>
#define N 1000
#define inf 1<<30;
using namespace std;
/*
	a星算法,找寻最短路径
	算法核心:有两个表open表和close表
		将方块添加到open列表中,该列表有最小的和值。且将这个方块称为S吧。
		将S从open列表移除,然后添加S到closed列表中。
		对于与S相邻的每一块可通行的方块T:
		如果T在closed列表中:不管它。
		如果T不在open列表中:添加它然后计算出它的和值。
		如果T已经在open列表中:当我们使用当前生成的路径到达那里时,检查F(指的是和值)是否更小。如果是,更新它的和值和它的前继。

		F = G + H        (G指的是从起点到当前点的距离,而H指的是从当前点到目的点的距离(移动量估算值采用曼哈顿距离方法估算)
*/
int map[6][7];     //0表示是路,1表示有阻碍物
int xstart, ystart, xend, yend;       //(x1,y1)起点,(x2, y2)目的点
int close[6][7];  //0表示不在,1表示在
int n;
void astar(int , int );
bool check(int x, int y);
int panyical(int x, int y);
void print2();

struct point{
	int x, y;
	int f, g, h;
	int prex, prey;   //上一个点的x,y
	point(int x0, int y0, int g0, int h0)
	{
		x = x0;
		y = y0;
		g = g0;
		h = h0;
		f = g + h;
	}
	point(){
	}
}open[N];
void print1(point);        //逆向反推

void init()
{
	xstart = 3, ystart = 1;   //起点
	xend = 4, yend = 5;   //目的点
	map[4][1] = map[1][3] = map[2][3] = map[3][3] = map[4][3] = 1;   //设置阻隔物
	astar(xstart,ystart);
}

point minfpoint()
{
	int flag;
	int minf = inf;
	for(int t=0; t<n; ++t)
	{
		if(close[open[t].x][open[t].y] == 0 && open[t].f <= minf)
		{
			flag = t;
			minf = open[t].f;
		}
	}
	return open[flag];
}
void update(int x, int y, point &s)
{
	for(int t=0; t<n; ++t)
	{
		if(open[t].x == x && open[t].y == y)         //如果该点已经在open表中存在的话,则更新值
		{
			int k = s.g+1+panyical(x, y);
			if(open[t].f > k)
			{
				open[t].f = k;
				open[t].prex = s.x;
				open[t].prey = s.y;
			}
			return ;
		}
	}
	open[n] = point(x, y, s.g+1, panyical(x,y));
	open[n].prex = s.x;
	open[n].prey = s.y;
	n++;
}
void astar(int x, int y)
{
	point s = point(x, y, 0, 0);
	n = 0;
	while(1)
	{
		close[s.x][s.y] = 1;
		if(s.x == xend && s.y == yend)
		{
			break;
		}
		if(check(s.x+1, s.y))
		{
			update(s.x+1, s.y, s);
		}
		if(check(s.x-1, s.y))
		{
			update(s.x-1, s.y, s);
		}
		if(check(s.x, s.y+1))
		{
			update(s.x, s.y+1, s);
		}
		if(check(s.x, s.y-1))
		{
			update(s.x, s.y-1, s);
		}
		s = minfpoint();
	}
	printf("min:%d g:%d h:%d\n", s.f, s.g, s.h);
	//print1(s);
	print2();
}

void print1(point p)
{
	point s  = p;
	while(1)
	{
		printf("(%d,%d  g:%d, h:%d f:%d)->", s.x, s.y, s.g, s.h, s.f);
		int prex = s.prex;
		int prey = s.prey;
		if(prex == xstart && prey == ystart)
		{
			break;
		}
		for(int t=0; t<n; ++t)
		{
			if(open[t].x == prex && open[t].y == prey)
			{
				s = open[t];
				break;
			}
		}

	}
}
void print2()
{
	for(int t=0; t<n; ++t)
	{
		point s = open[t];
		printf("(%d,%d  g:%d, h:%d f:%d)\n", s.x, s.y, s.g, s.h, s.f);

	}
}
int panyical(int x, int y)
{
	return abs(xend-x) + abs(yend-y);
}

bool check(int x, int y){
	if(x<0 || x>5 || y<0 || y>6 || map[x][y]==1 || close[x][y]==1)
	{
		return false;
	}
	return true;
}
int main()
{
	init();
	return 0;
}

运行结果:

版权声明:本文为博主原创文章,未经博主允许不得转载。

时间: 2024-11-05 18:26:22

A星算法,找寻最短路径的相关文章

A*搜寻算法(A星算法)

A*搜寻算法[编辑] 维基百科,自由的百科全书 本条目需要补充更多来源.(2015年6月30日) 请协助添加多方面可靠来源以改善这篇条目,无法查证的内容可能会被提出异议而移除. A*搜索算法,俗称A星算法.这是一种在图形平面上,有多个节点的路径,求出最低通过成本的算法.常用于游戏中的NPC的移动计算,或在线游戏的BOT的移动计算上. 该算法综合了BFS(Breadth First Search)和Dijkstra算法的优点:在进行启发式搜索提高算法效率的同时,可以保证找到一条最优路径(基于评估函

基于HTML5的WebGL呈现A星算法的3D可视化

http://www.hightopo.com/demo/astar/astar.html 最近搞个游戏遇到最短路径的常规游戏问题,一时起兴基于HT for Web写了个A*算法的WebGL 3D呈现,算法基于开源 https://github.com/bgrins/javascript-astar 的javascript实现,其实作者也有个不错的2D例子实现 http://www.briangrinstead.com/files/astar/ ,只不过觉得所有A*算法的可视化实现都是平面的不够

Cocos2d-x 3.1.1 学习日志16--A星算法(A*搜索算法)学问

A *搜索算法称为A星算法.这是一个在图形平面,路径.求出最低通过成本的算法. 经常使用于游戏中的NPC的移动计算,或线上游戏的BOT的移动计算上. 首先:1.在Map地图中任取2个点,開始点和结束点 2.首先推断该点是不是不能够穿越的点,或者是已经再close中了 3.假设2步骤为真.什么都不做,假设为假,那么我们就进行加入了 4.假设在加入的时候,发现该点在open中不存在.那么我们直接加入,并且视之为当前节点,假设该点              存在open中,那么我们比較G值,假设发现当

Cocos2d-x 3.1.1 学习日志16--A星算法(A*搜寻算法)的学习

A *搜寻算法俗称A星算法.这是一种在图形平面上,有多个节点的路径,求出最低通过成本的算法.常用于游戏中的NPC的移动计算,或线上游戏的BOT的移动计算上. 首先:1.在Map地图中任取2个点,开始点和结束点 2.首先判断该点是不是不可以穿越的点,或者是已经再close中了 3.如果2步骤为真,什么都不做,如果为假,那么我们就进行添加了 4.如果在添加的时候,发现该点在open中不存在,那么我们直接添加,而且视之为当前节点,如果该点              存在open中,那么我们比较G值,如

图论算法之最短路径

图论算法之最短路径 作者:jasonkent27 转载请注明出处:www.cnblogs.com/jasonkent27 1. 前言 1.1 最短路引入 小明和小天现在住在海口(C1),他们俩计划暑假到三亚(C4)玩一趟,在海口和三亚之间有许多中间城市(文昌,临高,乐东,万宁...)图中的边上的数字是他们到达该城市必须的花费,现在需要你帮他们俩找出一条从海口到三亚的最省钱的路径出来. 等等,图中的边的weight怎么会有负的呢?你暂且可以这么理解吧.图中的边上的weight可以当作他们旅途中必须

算法系列笔记8(有关图的算法二—最短路径问题)

图的最短路径问题主要分为两类,单源最短路径问题和全对最短路径问题.单源最短路径问题指给点单个源点,求其到所有其它顶点之间的最短距离.而全对最短路径问题指所有顶点之间的最短路劲问题.此外对于单对最短路径问题,从渐进意义上来看,目前还没有比最好的单元算法更快的算法来解决这一问题. 一:单源最短路径问题 单源最短路劲问题根据其权重分为四类,当图G=(V,E)为无权图,直接使用广度优先遍历(这里不做介绍):当权值为非负值,则使用Dijkstra算法:存在负权值及负权环,可以使用Bellman-Ford算

算法_最短路径

一.概述  定义:在一幅加权有向图中,从顶点s到顶点t的最短路径是所有从s到t的路径中的权重的最小者.从定义可以看出单点最短路径的实现是建立在加权有向图的基础上的. 最短路径树:给定一幅加权有向图和一个顶点s,以s为起点的一颗最短路径树是图的一幅子图,它包含s和从s可达的所有顶点.这颗有向树的根节点是s,树的每条路径都是有向图中的一条最短路径.它包含了顶点s到所有可达的顶点的最短路径. 二.加权有向图和加权有向边的数据结构 加权有向图和加权有向边的数据结构和加权无向图无向边的数据结构类型基本相同

A星算法入门之入ing...

几天以来的瞎折腾,能算入门么? 漫漫几千里,A星算法这么走. 测试程序: public class AStarTest { /** * @param args */ public static void main(String[] args) { int[][] mySearchArea = new int[][] { {1, 1, 1, 1, 1, 1, 1, 1}, {1, 1, 1, 1, 0, 1, 1, 1}, {1, 1, 1, 1, 0, 1, 1, 1}, {1, 1, 1, 1

Bellman-Ford算法(最短路径)

Dijkstra算法是处理单源最短路径的有效算法,但它局限于边的权值非负的情况,若图中出现权值为负的边,Dijkstra算法就会失效,求出的最短路径就可能是错的. 这时候,就需要使用其他的算法来求解最短路径,Bellman-Ford算法就是其中最常用的一个.该算法由美国数学家理查德?贝尔曼(Richard Bellman, 动态规划的提出者)和小莱斯特?福特(Lester Ford)发明. 适用条件&范围: 单源最短路径(从源点s到其它所有顶点v); 有向图&无向图(无向图可以看作(u,v