编程练习：走迷宫问题后续
上一篇文章中提到了走迷宫问题《编程练习：走迷宫问》题 是使用广度优先算法解出的，最后给出了A*算法，此算法是一种静态路网中求解最短路最有效的算法。最后扯点别的：在人工智能，游戏制作中好像很有用，对于参考文献《A* Pathfinding for Beginners》 中最后讨论的例如游戏设计中避免碰撞，不同地形损耗，路径平滑等，联想到“三国志11”中的操作，感觉醍醐灌顶，有时间参与此类工作要再多研究了。这篇文章主要介绍相应的实现。
问题描述：
实现给定迷宫，给出你认为最快的走出迷宫步数和策略；若不存在，请输出0。
解决思路：
A* （A-Star)算法是一种静态路网中求解最短路最有效的直接搜索方法，也是许多其他问题的常用启发式算法。
注意是最有效的直接搜索算法。之后涌现了很多预处理算法（ALT，CH，HL等等），在线查询效率是A*算法的数千甚至上万倍。
公式表示为： f(n)=g(n)+h(n),
其中 f(n) 是从初始状态经由状态n到目标状态的代价估计，g(n) 是在状态空间中从初始状态到状态n的实际代价，h(n) 是从状态n到目标状态的最佳路径的估计代价。（对于路径搜索问题，状态就是图中的节点，代价就是距离）百度百科《A*算法》
上述链接还给出了可运行的C语言程序（已运行没问题），如果做嵌入式设计是否能修改移植呢？嗯。。。
代码实现：
此处尝试编写A*算法，但是google发现了类似实现，现记录如下：
/*
//转自：http://baike.baidu.com/link?url=j_pHMECOXPa_eidbnJhdVPCQDoKsk1EjtEkPhsfXRG0xCGSCyoTNOIVWZrBt5NuLmzVgZPzAczicC9rRJBSsn0u8x_0cDSBtbUzCSvBhsW7
#include pq[2]; // list of open (not-yet-tried) nodes
static int pqi; // pq index
static node* n0;
static node* m0;
static int i, j, x, y, xdx, ydy;
static char c;
pqi = 0;
//初始化
// reset the node maps
for (y = 0; y<m; y++)
{
for (x = 0; xx++)
{
closed_nodes_map[x][y] = 0;
open_nodes_map[x][y] = 0;
}
}
// create the start node and push into list of open nodes
//开始点的位置，距离度量初始化
n0 = new node(xStart, yStart, 0, 0);
//计算F=G+H中的H（理想情况下移动到终点的耗费）即可
n0->updatePriority(xFinish, yFinish);
pq[pqi].push(*n0);
open_nodes_map[x][y] = n0->getPriority(); // mark it on the open nodes map
// A* search
while (!pq[pqi].empty())
{
// get the current node w/ the highest priority
// from the list of open nodes
n0 = new node(pq[pqi].top().getxPos(), pq[pqi].top().getyPos(),
pq[pqi].top().getLevel(), pq[pqi].top().getPriority());
x = n0->getxPos(); y = n0->getyPos();
pq[pqi].pop(); // remove the node from the open list
open_nodes_map[x][y] = 0;
// mark it on the closed nodes map
closed_nodes_map[x][y] = 1;
// quit searching when the goal state is reached
//if((*n0).estimate(xFinish, yFinish) == 0)
//首先考虑了当寻找到终点并输出策略的情况
if (x == xFinish && y == yFinish)
{
// generate the path from finish to start
// by following the directions
string path = "";
while (!(x == xStart && y == yStart))
{
//此处将距离变量登记到dir_map中，当最终找到终点时，应用此方向记录可回溯至父节点
j = dir_map[x][y];
c = '0' + (j + dir / 2) % dir;
path = c + path;
x += dx[j];
y += dy[j];
}
// garbage collection
delete n0;
// empty the leftover nodes
//当已经找到终点时，后续open list都不需要考虑了
while (!pq[pqi].empty()) pq[pqi].pop();
return path;
}
// generate moves (child nodes) in all possible directions
for (i = 0; ix + dx[i]; ydy = y + dy[i];
//考虑8邻域方向，需要满足合法位置，且不再close list中，且原始地图中标记可行进时
if (!(xdx<0 || xdx>n - 1 || ydy<0 || ydy>m - 1 || map[xdx][ydy] == 1
|| closed_nodes_map[xdx][ydy] == 1))
{
// generate a child node
m0 = new node(xdx, ydy, n0->getLevel(),
n0->getPriority());
//移动到邻域时耗费
m0->nextLevel(i);
//移动到终点时耗费
//Ps，此处与参考文献中的计算方法不同，参考文献中H只计算一次存储就好，而这里每考虑一次就重新计算，速度必然慢，优化可考虑这里
m0->updatePriority(xFinish, yFinish);
// if it is not in the open list then add into that
if (open_nodes_map[xdx][ydy] == 0)
{
//若第一遍历到此
open_nodes_map[xdx][ydy] = m0->getPriority();
pq[pqi].push(*m0);
// mark its parent node direction
//更新方向记录表（参考文献是记录父指针，相应的记录空间会少，但这里也可以输出策略，可后续修改）
dir_map[xdx][ydy] = (i + dir / 2) % dir;
}
//若已经在open list中，需要考虑那种方式耗费更低
else if (open_nodes_map[xdx][ydy]>m0->getPriority())
{
//以下是当open list中耗费更低时修改父指针（异曲同工）
// update the priority info
open_nodes_map[xdx][ydy] = m0->getPriority();
// update the parent direction info
dir_map[xdx][ydy] = (i + dir / 2) % dir;
// replace the node
// by emptying one pq to the other one
// except the node to be replaced will be ignored
// and the new node will be pushed in instead
//修改后需要删除open list中相应的项，此处开辟了两个priority_queue,有两个就可以有空间操作了，其实完全可以用一个+erase完成吧，后需优化再说吧
while (!(pq[pqi].top().getxPos() == xdx &&
pq[pqi].top().getyPos() == ydy))
{
pq[1 - pqi].push(pq[pqi].top());
pq[pqi].pop();
}
pq[pqi].pop(); // remove the wanted node
//此处就是考虑了当移动后多于一般或少于一半时，通过交换指针减少操作次数
// empty the larger size pq to the smaller one
if (pq[pqi].size()>pq[1 - pqi].size()) pqi = 1 - pqi;
while (!pq[pqi].empty())
{
pq[1 - pqi].push(pq[pqi].top());
pq[pqi].pop();
}
pqi = 1 - pqi;
pq[pqi].push(*m0); // add the better node instead
}
else delete m0; // garbage collection
}
}
delete n0; // garbage collection
}
return ""; // no route found
}
int main()
{
srand(time(NULL));
// create empty map
for (int y = 0; y<m; y++)
{
for (int x = 0; xx++) map[x][y] = 0;
}
// fillout the map matrix with a '+' pattern
for (int x = n / 8; x7 / 8; x++)
{
map[x][m / 2] = 1;
}
for (int y = m / 8; y<m * 7 / 8; y++)
{
map[n / 2][y] = 1;
}
// randomly select start and finish locations
int xA, yA, xB, yB;
switch (rand() % 8)
{
case 0: xA = 0; yA = 0; xB = n - 1; yB = m - 1; break;
case 1: xA = 0; yA = m - 1; xB = n - 1; yB = 0; break;
case 2: xA = n / 2 - 1; yA = m / 2 - 1; xB = n / 2 + 1; yB = m / 2 + 1; break;
case 3: xA = n / 2 - 1; yA = m / 2 + 1; xB = n / 2 + 1; yB = m / 2 - 1; break;
case 4: xA = n / 2 - 1; yA = 0; xB = n / 2 + 1; yB = m - 1; break;
case 5: xA = n / 2 + 1; yA = m - 1; xB = n / 2 - 1; yB = 0; break;
case 6: xA = 0; yA = m / 2 - 1; xB = n - 1; yB = m / 2 + 1; break;
case 7: xA = n - 1; yA = m / 2 + 1; xB = 0; yB = m / 2 - 1; break;
}
cout << "Map Size (X,Y): " << n << "," << m << endl;
cout << "Start: " << xA << "," << yA << endl;
cout << "Finish: " << xB << "," << yB << endl;
// get the route
clock_t start = clock();
string route = pathFind(xA, yA, xB, yB);
if (route == "") cout << "An empty route generated!" << endl;
clock_t end = clock();
double time_elapsed = double(end - start);
cout << "Time to calculate the route (ms): " << time_elapsed << endl;
cout << "Route:" << endl;
cout << route << endl << endl;
// follow the route on the map and display it
if (route.length()>0)
{
int j; char c;
int x = xA;
int y = yA;
//对首尾及路径标记
map[x][y] = 2;
for (int i = 0; ilength(); i++)
{
c = route.at(i);
j = atoi(&c);
x = x + dx[j];
y = y + dy[j];
map[x][y] = 3;
}
map[x][y] = 4;
//输出可视化美观
// display the map with the route
for (int y = 0; y<m; y++)
{
for (int x = 0; xx++)
if (map[x][y] == 0)
cout << ".";
else if (map[x][y] == 1)
cout << "O"; //obstacle
else if (map[x][y] == 2)
cout << "S"; //start
else if (map[x][y] == 3)
cout << "R"; //route
else if (map[x][y] == 4)
cout << "F"; //finish
cout << endl;
}
}
getchar(); // wait for a (Enter) keypress
return(0);
} 相关参考网页：
《A* Pathfinding for Beginners》
《A*算法原理——面向初学者》
百度百科《A*算法》