写了下A*(读作A星，或者A Star)算法的地图搜索，作为一个算法新手来说，感觉真的很好啊，因为据说在使用一个合理的估价函数的前提下A*算法能够得到最优解。我会说在检查完运行结果后，我的内心不经涌起了一股成就感吗？
什么是A*算法，个人觉得A*算法是基于Dijkstra算法的一种优化,同样是基于广搜，并有一个当前列表检索列表，并不断的从优先队列中移除已完成节点。但是A*算法中多了一个开放队列,我想正是因为这个开放队列的存在，才使得A*算法能够求的最优解，因为最优解总是会包含在这个开放队列中的。
A*算法的标准特征是包含开放列表、关闭列表、估价函数等。
package com.wly.algorithmbase.search;
import java.util.Comparator;
import java.util.PriorityQueue;
public class AStarAlgorithm {
//包含通路的地图测试实例
private static int[][] graph = {
{0,0,2,0,0,0,0,2,0,0},
{0,0,0,0,0,0,0,2,0,0},
{0,0,2,0,0,0,0,2,0,0},
{0,0,2,0,0,0,0,2,0,0},
{0,0,0,0,0,0,0,0,0,0},
{0,2,0,0,0,0,0,2,0,0},
{1,2,0,0,0,0,0,2,0,3},
{0,2,0,0,0,0,0,2,0,0},
{0,0,0,0,0,0,0,2,0,0}
};
//不包含通路的地图测试实例
private static int[][] graph2 = {
{0,0,2,0,0,0,0,2,0,0},
{0,0,0,0,0,0,0,2,0,0},
{0,0,2,0,0,0,0,2,0,0},
{0,0,2,0,0,0,0,2,0,0},
{0,0,0,0,0,0,0,0,0,0},
{0,2,0,0,0,0,0,2,0,2},
{1,2,0,0,0,0,0,2,2,2},
{0,2,0,0,0,0,0,2,0,3},
{0,0,0,0,0,0,0,2,0,0}
};
static int start_row = 0;
static int start_column = 0;
static int dest_row = 0;
static int dest_column = 0;
private static S[][] enableFlag; //用来模拟"开放列表"，"关闭列表"的标记数组
private static enum S{ //对应三个状态:初始状态中，开放列表中，关闭列表中
INIT,OEPN,CLOSE
};
private static int PRICE_HW = 10; //水平、垂直移动1单位代价
private static int PRICE_X = 14; //斜着移动1.44的代价
private final static int ROLD = 0; //通路
private final static int SELF = 1; //自己
private final static int STONE = 2; //障碍物
private final static int DEST = 3; //目标
public static void main(String[] args) {
AStarAlgorithm aStarAlgorithm = new AStarAlgorithm();
//测试有解地图
System.out.println("---测试有解实例---");
Node[][] nodes = new Node[graph.length][graph[0].length];
enableFlag = new S[graph.length][graph[0].length];
for(int i=0;i<graph.length;i++) {
for(int j=0;j<graph[0].length;j++) {
nodes[i][j] = new Node(i,j,graph[i][j]);
enableFlag[i][j] = S.INIT; //将状态置为初始状态
}
}
aStarAlgorithm.search(nodes);
//测试无解地图
Node[][] nodes2 = new Node[graph.length][graph[0].length];
System.out.println("\n---测试无解实例---");
enableFlag = new S[graph2.length][graph2[0].length];
for(int i=0;i<graph2.length;i++) {
for(int j=0;j<graph2[0].length;j++) {
nodes2[i][j] = new Node(i,j,graph2[i][j]);
enableFlag[i][j] = S.INIT; //将状态置为初始状态
}
}
aStarAlgorithm.search(nodes2);
}
/**
* 开始搜索
* @param start_row 起始坐标的行号
* @param start_column 起始坐标的列号
*/
public void search(Node[][] graph) {
//打印地图数据
System.out.println("地图:");
for(int i=0;i<graph.length;i++) {
for(int j=0;j<graph[0].length;j++) {
System.out.print(graph[i][j].type + " ");
}
System.out.println();
}
//检索地图得到起始点和目标点坐标
for(int i=0;i<graph.length;i++) {
for(int j=0;j<graph[i].length;j++) {
if(graph[i][j].type == SELF) {
start_row = i;
start_column = j;
} else if(graph[i][j].type == DEST) {
dest_row = i;
dest_column = j;
}
}
}
//---使用java自带的优先队列---
Comparator<Node> comparator = new Comparator<Node>() {
@Override
public int compare(Node o1, Node o2) {
if((o1.getCost()) > (o2.getCost())) {
return 1;
} else if((o1.getCost()) == (o2.getCost())) {
return 0;
} else {
return -1;
}
}
};
PriorityQueue<Node> queue = new PriorityQueue<>(12,comparator);
//将起点放置到开放列表中
queue.add(new Node(start_row, start_column,1));
enableFlag[start_row][start_column] = S.OEPN; //将起点打上开放标记
//搜索不到通路(开放列表为空)，或者搜索到了通路(终点位于开放列表中)
while(!queue.isEmpty() &&
enableFlag[dest_row][dest_column] != S.OEPN) {
Node currNode = queue.poll();
enableFlag[currNode.row][currNode.column] = S.CLOSE; //放到关闭列表
for(int i=currNode.row -1;i<currNode.row+2;i++) {
for(int j=currNode.column-1;j<currNode.column+2;j++) {
if(i>=0&& i<graph.length && j>=0 && j<graph[i].length //边界过滤
&& graph[i][j].type != STONE //不是障碍物
&& enableFlag[i][j] != S.CLOSE /*不在关闭列表中*/) {
if(i != currNode.row && j != currNode.column) { //斜着移动
if(graph[i][j].getCost() > currNode.getCost() + PRICE_X) {
graph[i][j].setG(currNode.getG() + PRICE_X);
}
} else { //水平、垂直移动
if(graph[i][j].getCost() > currNode.getCost() + PRICE_HW) {
graph[i][j].setG(currNode.getG() + PRICE_HW);
}
}
if(enableFlag[i][j] == S.INIT) {
queue.add(graph[i][j]);
enableFlag[i][j] = S.OEPN;
}
}
}
}
System.out.print(currNode.row + "," + currNode.column + "=>");
}
if(queue.isEmpty()) {
System.out.println("\n---未搜索到从起点到终点的有效通路!");
} else {
System.out.print(dest_row + "," + dest_column);
System.out.println("\n---搜索到从起点到终点的有效通路!");
}
}
/**
* 节点类
* @author wly
*
*/
static class Node {
Node parentNode; //持有父节点的引用
int g; //搜索当前节点已发生的开销
int row,column; //坐标
int type; //当前节点的类型(障碍物、道路等)
public Node(int row, int column,int type) {
super();
this.row = row;
this.column = column;
this.type = type;
}
public int getG() {
return g;
}
public void setG(int g) {
this.g = g;
}
public int getCost() {
return getHValue() + g;
}
/**
* 估算函数
* @return
*/
private int getHValue() {
return (Math.abs(row - dest_row) + Math.abs(column - dest_column)) * PRICE_HW;
}
}
}
---测试有解实例---
地图:
0 0 2 0 0 0 0 2 0 0
0 0 0 0 0 0 0 2 0 0
0 0 2 0 0 0 0 2 0 0
0 0 2 0 0 0 0 2 0 0
0 0 0 0 0 0 0 0 0 0
0 2 0 0 0 0 0 2 0 0
1 2 0 0 0 0 0 2 0 3
0 2 0 0 0 0 0 2 0 0
0 0 0 0 0 0 0 2 0 0
6,0=>5,0=>7,0=>4,1=>5,2=>6,3=>6,4=>6,5=>6,6=>5,6=>7,6=>4,7=>5,8=>6,9
---搜索到从起点到终点的有效通路!
---测试无解实例---
地图:
0 0 2 0 0 0 0 2 0 0
0 0 0 0 0 0 0 2 0 0
0 0 2 0 0 0 0 2 0 0
0 0 2 0 0 0 0 2 0 0
0 0 0 0 0 0 0 0 0 0
0 2 0 0 0 0 0 2 0 2
1 2 0 0 0 0 0 2 2 2
0 2 0 0 0 0 0 2 0 3
0 0 0 0 0 0 0 2 0 0
6,0=>7,0=>8,1=>7,2=>7,3=>7,4=>7,5=>7,6=>6,6=>8,6=>5,6=>4,7=>5,8=>4,9=>4,8=>3,9=>2,9=>3,8=>1,9=>8,5=>6,5=>4,6=>5,5=>8,4=>2,8=>5,4=>0,9=>4,4=>5,3=>6,4=>1,8=>4,5=>8,3=>6,3=>3,6=>2,6=>2,5=>5,2=>3,4=>0,8=>1,6=>8,2=>3,5=>6,2=>4,3=>8,0=>2,4=>0,6=>4,2=>3,3=>1,5=>5,0=>0,4=>4,0=>3,1=>1,4=>2,3=>0,5=>4,1=>2,1=>0,3=>3,0=>1,2=>1,1=>1,3=>2,0=>0,1=>1,0=>0,0=>
---未搜索到从起点到终点的有效通路!
1、代码中用一个状态标记和枚举变量代替了当前节点出于"开放列表","关闭列表"的状态。
2、代码中使用了Java自带的PriorityQueue来做优先队列，这个PriorityQueue是在JDK1.7中新增的，若在1.6的JDK上会报错。当然，读者也可以参考笔者的另一篇博文：使用二叉堆实现优先队列。
3、A*的关键在于"开放队列"的思想以及估价函数的建立，估价函数不能太大，这样会导致搜索速度不高，也不能太小，因为这样可能导致搜索不到最优解。
4、And,如果你对A*算法还不是很了解，笔者这里有秘籍：猛戳下载
。
O啦~~~
转载请保留出处:http://blog.csdn.net/u011638883/article/details/17245371
谢谢!!
1100
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
