A星算法的JAVA实现

最新推荐文章于 2024-05-09 21:03:47 发布
最新推荐文章于 2024-05-09 21:03:47 发布
阅读量275 收藏 2
点赞数 1
分类专栏： Java algorithm 文章标签： 算法 A星算法 JAVA A* algorithm
A星算法
A*搜寻算法，俗称A星算法。这是一种在图形平面上，有多个节点的路径，求出最低通过成本的算法。常用于游戏中的NPC的移动计算，或线上游戏的BOT的移动计算上。

该算法像Dijkstra算法一样，可以找到一条最短路径；也像BFS一样，进行启发式的搜索。

 

 Dijkstra的Java实现可以参照《Java实现Dijkstra算法》。

 

具体A星算法的理论部分已经在《A星算法——理论篇》一文中有详细说明，现直接上代码部分，该代码借助A星算法解决了一道acm题。题目如下：

 

援救行动
Problem
Angel被传说中神秘的邪恶的Moligpy人抓住了！他被关在一个迷宫中。迷宫的长、宽不超过200。

迷宫中有不可以越过的墙以及监狱的看守。

Angel的朋友带了一些救援队来到了迷宫中。他们的任务是：接近Angel。我们假设接近Angel就是到达Angel所在的位置。

假设移动需要1单位时间，杀死一个看守也需要1单位时间。到达一个格子以后，如果该格子有看守，则一定要杀死（否则会死

的很难看的……只见那个看守开了9倍狙镜……）。交给你的任务是，最少要多少单位时间，才能到达Angel所在的地方？

（只能向上、下、左、右4个方向移动）

Input
该题含有多组测试数据。

每组测试数据第一行二个整数n，m。表示迷宫的大小为n*m。

以后n行，每行m个时字符。其中“#”代表墙，“.”表示可以移动，“x”表示看守，“a”表示Angel，“r”表示救援队伍。

字母均为小写。

Output
一行，代表救出Angel的最短时间。

如果救援小组永远不能达到Angel处，则输出“Poor ANGEL has to stay in the prison all his life.”

Sample Input
7 8
#.#####.
#.a#..r.
#..#x...
..#..#.#
#...##..
.#......
........

Sample Output
13

 

    AStar类：

package com.sabrina.astar;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.Queue;

public class AStar {
	// 迷宫图
	Point[][] maze;
	// 起始节点
	Point start;
	// 终止节点
	Point goal;

	// 开启队列，用于存放待处理的节点
	Queue<Point> openQueue = null;
	// 关闭队列，用于存放已经处理过的节点
	Queue<Point> closedQueue = null;

	// 起始节点到某个节点的距离
	int[][] FList = null;
	// 某个节点到目的节点的距离
	int[][] GList = null;
	// 起始节点经过某个节点到目的节点的距离
	int[][] HList = null;

	/**
	 * 打印行走路径
	 * 
	 *  经过的点用'*'表示,
	 *  未经过的点用'.'表示，
	 *  起始节点用'r'表示,
	 *  目的节点用'a'表示
	 *  士兵用'x'表示
	 */
	public void printPath() {
		System.out.println("================ printPath ================");
		Point father_point = null;
		char[][] result = new char[7][8];
		for (int i = 0; i < 7; i++) {
			for (int j = 0; j < 8; j++) {
				result[i][j] = '.';
			}
		}

		int step = 0;
		father_point = maze[goal.getX()][goal.getY()];
		while (father_point != null) {
			if(father_point.equals(start))
				result[father_point.getX()][father_point.getY()] = 'r';
			else if(father_point.equals(goal)) {
				result[father_point.getX()][father_point.getY()] = 'a';
				step++;
			}
			else if(father_point.getValue() == 'x') {
				result[father_point.getX()][father_point.getY()] = 'x';
				step += 2;
			}
			else {
				result[father_point.getX()][father_point.getY()] = '*';
				step++;
			}
			father_point = father_point.getFather();
		}
		// 打印行走步数
		System.out.println("step is : " + step);
		for (int i = 0; i < 7; i++) {
			for (int j = 0; j < 8; j++) {
				System.out.print(result[i][j] + " ");
			}
			System.out.println();
		}
	}

	/**
	 * 构造函数
	 * 
	 * @param maze  迷宫图
	 * @param start 起始节点
	 * @param goal  目的节点
	 */
	public AStar(Point[][] maze, Point start, Point goal) {
		this.maze = maze;
		this.start = start;
		this.goal = goal;

		openQueue = new LinkedList<Point>();
		closedQueue = new LinkedList<Point>();

		FList = new int[maze.length][maze[0].length];
		GList = new int[maze.length][maze[0].length];
		HList = new int[maze.length][maze[0].length];

		for (int i = 0; i < maze.length; i++) {
			for (int j = 0; j < maze[0].length; j++) {
				FList[i][j] = Integer.MAX_VALUE;
				GList[i][j] = Integer.MAX_VALUE;
				HList[i][j] = Integer.MAX_VALUE;
			}
		}

		init();
	}

	/*
	 * 初始化
	 * 
	 *  将起始节点添加至开启列表，初始化：
	 *  1) 起始节点到当前节点（起始节点）的距离
	 *  2) 当前节点（起始节点）到目的节点的距离
	 *  3) 起始节点经过当前节点（起始节点）到目的节点的距离
	 */
	private void init() {
		openQueue.offer(start);
		int start_x = start.getX();
		int start_y = start.getY();
		int goal_x = goal.getX();
		int goal_y = goal.getY();

		// 起始节点到当前节点的距离
		GList[start_x][start_y] = 0;
		// 当前节点到目的节点的距离
		HList[start_x][start_y] = getDistance(start_x, start_y, goal_x, goal_y);
		// f(x) = g(x) + h(x)
		FList[start_x][start_y] = GList[start_x][start_y]
				+ HList[start_x][start_y];
	}

	/**
	 * 启动搜索迷宫过程主入口
	 * 
	 *   从开启列表中搜索F值最小（即：起始节点 经过某一节点 到目的节点 距离最短），
	 *   将选取的节点作为当前节点，并更新当前节点的邻居节点信息（G、H、F值）以及
	 *   开启列表与关闭列表的成员。   
	 */
	public void start() {
		Point currentPoint;

		while ((currentPoint = findShortestFPoint()) != null) {
			if (currentPoint.getX() == goal.getX()
					&& currentPoint.getY() == goal.getY())
				return;
			updateNeighborPoints(currentPoint);
		}
	}

	public static void main(String[] args) {

		// 原始迷宫图
		char[][] mazeRaw = { { '#', '.', '#', '#', '#', '#', '#', '.' },
				             { '#', '.', 'a', '#', '.', '.', 'r', '.' },
				             { '#', '.', '.', '#', 'x', '.', '.', '.' },
				             { '.', '.', '#', '.', '.', '#', '.', '#' },
				             { '#', '.', '.', '.', '#', '#', '.', '.' },
				             { '.', '#', '.', '.', '.', '.', '.', '.' },
				             { '.', '.', '.', '.', '.', '.', '.', '.' } };

		// 节点迷宫图
		Point[][] maze = new Point[mazeRaw.length][mazeRaw[0].length];
		for (int i = 0; i < maze.length; i++) {
			for (int j = 0; j < maze[0].length; j++) {
				maze[i][j] = new Point(i, j, mazeRaw[i][j]);
			}
		}
		// 起始节点
		Point start = maze[1][6];
		// 目的节点
		Point goal = maze[1][2];

		AStar astar = new AStar(maze, start, goal);
		// 启动搜索迷宫过程
		astar.start();
		// 打印行驶路径
		astar.printPath();

	}

	/*
	 * 检查位置是否有效
	 * 
	 *   如果当前位置存在、不是墙，且不在关闭列表中，则返回"true"，表示为有效位置；
	 *   否则，返回"false"。
	 * 
	 * 输入： 待检查位置的横坐标值
	 *       待检查位置的纵坐标值
	 *       
	 * 输出： 是否有效
	 */
	private boolean checkPosValid(int x, int y) {
		// 检查x,y是否越界， 并且当前节点不是墙
		if ((x >= 0 && x < maze.length) && (y >= 0 && y < maze[0].length)
				&& (maze[x][y].getValue() != '#')) {
			// 检查当前节点是否已在关闭队列中，若存在，则返回 "false"
			Iterator<Point> it = closedQueue.iterator();
			Point point = null;
			while (it.hasNext()) {
				if ((point = it.next()) != null) {
					if (point.getX() == x && point.getY() == y)
						return false;
				}
			}
			return true;
		}
		return false;
	}

	/*
	 * 获取当前位置到目的位置的距离
	 * 
	 *   距离衡量规则： 横向移动一格或纵向移动一格的距离为1.
	 * 
	 * 输入： 当前位置的横坐标值
	 *       当前位置的纵坐标值
	 *       目的位置的横坐标值
	 *       目的位置的纵坐标值
	 *       
	 * 输出： 当前位置到目的位置的距离
	 */
	private int getDistance(int current_x, int current_y, int goal_x, int goal_y) {
		return Math.abs(current_x - goal.getX())
				+ Math.abs(current_y - goal.getY());
	}

	/*
	 * 找寻最短路径所经过的节点
	 * 
	 *   从开启列表中找寻F值最小的节点，将其从开启列表中移除，并置入关闭列表。
	 * 
	 * 输出：最短路径所经过的节点
	 */
	private Point findShortestFPoint() {
		Point currentPoint = null;
		Point shortestFPoint = null;
		int shortestFValue = Integer.MAX_VALUE;

		Iterator<Point> it = openQueue.iterator();
		while (it.hasNext()) {
			currentPoint = it.next();
			if (FList[currentPoint.getX()][currentPoint.getY()] <= shortestFValue) {
				shortestFPoint = currentPoint;
				shortestFValue = FList[currentPoint.getX()][currentPoint.getY()];
			}
		}

		if (shortestFValue != Integer.MAX_VALUE) {
			openQueue.remove(shortestFPoint);
			closedQueue.offer(shortestFPoint);
		}

		return shortestFPoint;
	}

	/*
	 * 更新邻居节点
	 * 
	 *   依次判断上、下、左、右方向的邻居节点，如果邻居节点有效，则更新距离矢量表。
	 * 
	 * 输入： 当前节点
	 */
	private void updateNeighborPoints(Point currentPoint) {
		int current_x = currentPoint.getX();
		int current_y = currentPoint.getY();

		// 上
		if (checkPosValid(current_x - 1, current_y)) {
			updatePoint(maze[current_x][current_y],
					maze[current_x - 1][current_y]);
		}
		// 下
		if (checkPosValid(current_x + 1, current_y)) {
			updatePoint(maze[current_x][current_y],
					maze[current_x + 1][current_y]);
		}
		// 左
		if (checkPosValid(current_x, current_y - 1)) {
			updatePoint(maze[current_x][current_y],
					maze[current_x][current_y - 1]);
		}
		// 右
		if (checkPosValid(current_x, current_y + 1)) {
			updatePoint(maze[current_x][current_y],
					maze[current_x][current_y + 1]);
		}
	}

	/*
	 * 更新节点
	 * 
	 *   依次计算：1) 起始节点到当前节点的距离; 2) 当前节点到目的位置的距离; 3) 起始节点经过当前节点到目的位置的距离
	 *   如果当前节点在开启列表中不存在，则：置入开启列表，并且“设置”1)/2)/3)值；
	 *   否则，判断 从起始节点、经过上一节点到当前节点、至目的地的距离 < 上一次记录的从起始节点、到当前节点、至目的地的距离，
	 *   如果有更短路径，则更新1)/2)/3)值
	 * 
	 * 输入： 上一跳节点（又：父节点）
	 *       当前节点
	 */
	private void updatePoint(Point lastPoint, Point currentPoint) {
		int last_x = lastPoint.getX();
		int last_y = lastPoint.getY();
		int current_x = currentPoint.getX();
		int current_y = currentPoint.getY();

		// 起始节点到当前节点的距离
		int temp_g = GList[last_x][last_y] + 1;
		if (maze[current_x][current_y].getValue() == 'x') // 如果当前节点是看守
			++temp_g;
		// 当前节点到目的位置的距离
		int temp_h = getDistance(current_x, current_y, goal.getX(), goal.getY());
		// f(x) = g(x) + h(x)
		int temp_f = temp_g + temp_h;

		// 如果当前节点在开启列表中不存在，则：置入开启列表，并且“设置”
		// 1) 起始节点到当前节点距离
		// 2) 当前节点到目的节点的距离
		// 3) 起始节点到目的节点距离
		if (!openQueue.contains(currentPoint)) {
			openQueue.offer(currentPoint);
			currentPoint.setFather(lastPoint);

			// 起始节点到当前节点的距离
			GList[current_x][current_y] = temp_g;
			// 当前节点到目的节点的距离
			HList[current_x][current_y] = temp_h;
			// f(x) = g(x) + h(x)
			FList[current_x][current_y] = temp_f;
		} else {

			// 如果当前节点在开启列表中存在，并且，
			// 从起始节点、经过上一节点到当前节点、至目的地的距离 < 上一次记录的从起始节点、到当前节点、至目的地的距离，
			// 则：“更新”
			// 1) 起始节点到当前节点距离
			// 2) 当前节点到目的节点的距离
			// 3) 起始节点到目的节点距离
			if (temp_f < FList[current_x][current_y]) {
				// 起始节点到当前节点的距离
				GList[current_x][current_y] = temp_g;
				// 当前节点到目的位置的距离
				HList[current_x][current_y] = temp_h;
				// f(x) = g(x) + h(x)
				FList[current_x][current_y] = temp_f;
				// 更新当前节点的父节点
				currentPoint.setFather(lastPoint);
			}
		}
	}
}

 

   Point类：

package com.sabrina.astar;

public class Point {
	// 节点横坐标
	private int x;
	// 节点纵坐标
	private int y;

	// 节点值
	private char value;
	// 父节点
	private Point father;

	/**
	 * 构造函数
	 * 
	 * @param x  节点横坐标
	 * @param y  节点纵坐标
	 */
	public Point(int x, int y) {
		this.x = x;
		this.y = y;
	}

	/**
	 * 构造函数
	 * 
	 * @param x      节点横坐标
	 * @param y      节点纵坐标
	 * @param value  节点值
	 */
	public Point(int x, int y, char value) {
		this.x = x;
		this.y = y;
		this.value = value;
	}
	
	public Point getFather() {
		return father;
	}

	public void setFather(Point father) {
		this.father = father;
	}
	
	public char getValue() {
		return value;
	}

	public int getX() {
		return x;
	}

	public int getY() {
		return y;
	}
}

 

代码执行结果
================ printPath ================
step is : 13
. . . . . . . .
. . a . * * r .
. * * . x . . .
. * . * * . . .
. * * * . . . .
. . . . . . . .
. . . . . . . .

 

 

iteye_5053
关注
专栏目录
A星算法的实现(JAVA)
10-19
A星寻路算法基本实现，但有进一步优化的空间。
A星算法——Java修正版
你青春还有多久
01-31 1153
package com.test; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.List; public class AStar { private int[][] map;// 地图(1可通过 0不可通过) private
Java实现A星算法
12-04
Java实现A星算法,通过数组生成地图，设置起点、终点生成最短路径
A星算法（Java实现）
weixin_33919941的博客
02-07 117
2019独角兽企业重金招聘Python工程师标准>>> ...
A星算法Java实现
03-20
寻找A到B点的最优路径，F = G + H; G值实际走的路长，H值估计要运动的路长。 代码有注释，易看懂！ 本人亲测暂没有发现BUG
A星算法Java实现+源代码+文档说明
01-15
A星算法Java实现+源代码+文档说明 A星算法Java实现 一、适用场景 在一张地图中，绘制从起点移动到终点的最优路径，地图中会有障碍物，必须绕开障碍物。 二、算法思路 1. 回溯法得到路径 (如果有路径)采用“结点与...
A星算法Java实现.zip
03-14
到处运行（Write Once, Run Anywhere）”，这意味着开发者可以使用Java编写应用程序，并在支持Java的任何平台上无需重新编译即可运行，这得益于其独特的跨平台性，通过Java虚拟机（JVM）实现不同操作系统上的兼容。...
A* (A Star) 算法 java实现
最新发布
m0_59745374的博客
05-09 700
A*算法的性能和效果取决于所选择的估计函数。一个好的估计函数应该能够提供较为准确的估计值，以便更好地引导搜索，但也需要具备一定的效率，以免过多地增加计算复杂度。算法综合了Dijkstra算法的广度优先搜索和贪婪最优搜索策略，通过使用估计函数（heuristic function）来指导搜索方向，从而提高搜索效率。算法的优点是在适当的估计函数下，能够找到最短路径，并且相对于其他完全搜索算法，它的搜索效率更高。A*算法使用了一个估计函数来指导搜索，在每次选择下一个节点时，它考虑了两个值：g值和h值。
java实现的A星算法
狡猾的皮球的博客
04-19 1110
A星算法原理: 原理我就不再赘述,可以参考这篇博客：https://blog.csdn.net/hitwhylz/article/details/23089415 需要js代码的看这里：https://blog.csdn.net/qq_39687901/article/details/85697127 需要python代码的看这里：https://blog.csdn.net/qq_39687901/article/details/80753433 用法： 这里是八方寻路，如果想改成四方寻路，把AS
Java版A星算法
你青春还有多久
08-26 3359
A星算法步骤：  1.起点先添加到开启列表中  2.开启列表中有节点的话，取出第一个节点，即最小F值的节点    判断此节点是否是目标点，是则找到了，跳出    根据此节点取得八个方向的节点，求出G，H，F值    判断每个节点在地图中是否能通过，不能通过则加入关闭列表中，跳出    判断每个节点是否在关闭列表中，在则跳出    判断每个节点是否在开启列表中，在则更新G
A星算法 迷宫寻路
05-11
A星算法 迷宫寻路，源代码，注释详细，适合刚刚接触java和算法的人学习
java版走迷宫算法。。。。。
09-09
利用栈完成走迷宫
java用A*算法简单做的迷宫
10-29
用java完成的，关于启发式搜索算法在迷宫问题中的求解。
随机生成迷宫算法及其 Java 实现
05-27
NULL 博文链接：https://stupid.iteye.com/blog/224414
A星算法寻路（英雄救美）
12-18
自己通过A*算法写的“人工智能”课题作业，参考文献为《java制作扫雷》和《自己写的一个A*算法基于最小优先队列的实现JAVA版本》，有不足之处仅供参考。
a算法java_A*算法java实现
weixin_39824223的博客
02-12 304
展开全部代码实现(Java)1. 输入(1) 代表地图二值二维数组(0表示可通路，1表示路障)int[][] maps = {{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },{ 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, ...
java a星寻路算法_JS算法之A*（A星）寻路算法
weixin_35219046的博客
02-23 234
今天写一个连连看的游戏的时候，接触到了一些寻路算法，我就大概讲讲其中的A*算法。这个是我学习后的一点个人理解，有错误欢迎各位看官指正。寻路模式主要有三种：广度游戏搜索、深度优先搜索和启发式搜索。广度优先搜索(Breadth First Search)：又称为"宽度优先搜索"或"横向优先搜索"，简称BFS。BFS的搜索模式是：从图中某节点v出发，在访问了v之后依次访问v的各个未曾访问过的邻接点，然后...
Java游戏三维迷宫源代码
03-16
内容索引:JAVA源码,游戏娱乐,迷宫　　Java Maze3D迷宫游戏源码，浏览器上只要安上JAVA解释器就能运行，三维显示迷宫，点击 "New" 按钮开始迷宫之旅, 找不到出口的时候点击"Solve" 按钮显示红色的出口线路，点击"Clear" 清除解答。按上、下、左、右光标键可以单步找出口。 　　
A星算法Java版：完整源代码与文档指南
资源摘要信息:"A星算法Java实现+源代码+文档说明" A星算法是一种广泛应用于图形平面上从一点到另一点的最低成本路径算法，它能够在带障碍的路径规划中找到最优路径，非常适合用于地图导航、游戏AI和机器人路径规划...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值