A*算法实践

关于A*算法使用的总结和体会

部分理论叙述转自：https://blog.csdn.net/hitwhylz/article/details/23089415

1. **A算法的使用范围：**最普遍的就是矩形网格上的最短路，可以拓展至其他几何图形网格，但我认为一定得是能够计算出估计值并且满足乐观图条件的网格才能使用A算法。
   

2. A算法的必要组成：
   A算法是一种基于bfs类似dijkstra的启发式算法，其核心便是
   F = G + H 这里，G = 从起点 A 移动到指定方格的移动代价，沿着到达该方格 而生成的路径。H = 从指定的方格移动到终点 B 的估算成本。
   其他成分我做了一个例举：

   1、open list 用于储存被松弛的点，由于A*算法每次都要以F值最小的在列点开始，可以配合结构体使用优先队列来实现。

   2、close list 用于储存“松弛过别的点的点”（注意，不是被松弛过的点，那些点可能会被多次操作），在程序中可以使用布尔数组vis实现。

   3、father记录，每次执行松弛操作后，被松弛的点的父节点改为执行松弛操作的点，可以轻松追溯路径，使用father数组储存。

   4、distance记录，判断能否执行松弛操作的一项值就是distance是否减少，distance储存的是每个节点的G的最小值。

3. H（估计值）的计算方法
   目前我仅了解两种：
   1、曼哈顿估值：
   H=|Xend-Xnow|+|Yend-Ynow|
   很像走曼哈顿街区…

   2、欧几里得估值
   H=sqrt（（Xend-Xnow）x（Xend-Xnow）+（Yend-Ynow）x（Yend-Ynow））
   直接就是几何距离

   要注意所有的估值必须小于真实的最短路径长度才是乐观图

   附一道习题和个人解答：
   习题来自：https://blog.csdn.net/weixin_43501684/article/details/90417115
   棋盘中的马
   问题描述：
   棋盘中有一个马，给出它的位置，它有一个目的地，请问它最少需要多少步才 能走到它的目的地。马是走“日”字的

   输入
   输入：第一行两个整数:n,m，（n<=1000,m<=1000）n,m，（n<=1000,m<=1000）n,m，（n<=1000,m<=1000）表示棋盘有n行m列。
   第一行第一列为(1,1) 。
   第二行：（x1，y1）,表示马的位置。
   第三行：（x2，y2） ,表示它的目的地。
   保证起始和终止位置都在棋盘内。
   如果马不能到达目的地，输出−1.

   输出
   马走到目的地的路径和所需的最少步数

#include <iostream>
#include<queue>
#include<cmath>
using namespace std;
struct node {
    int x, y;
    int f, g, h;
    node()  {f =  g =  h = 0; }
    friend bool operator <(node a, node b);
};
bool operator <(node a, node b) {
    return a.f > b.f;
}
priority_queue <node>q;
node b, e;
int n, m;
int dx[8] = { -2, -2, -1, -1, 2, 2, 1, 1 };
int dy[8] = { 1, -1, -2, 2, -1, 1, -2, 2 };
int father[20][20][2];
int vis[20][20];
int dis[20][20] = { 0 };
int euclide(int x, int y) {
    return (int)sqrt((x - e.x) * (x - e.x) + (y - e.y) * (y - e.y));
}

void ouptu(void) {
    int p, q,x,y;
    x = e.x;
    y = e.y;
    while (x!=0||y!= 0) {
        printf("%d %d,",x,y);
        p = father[x][y][0];
        q = father[x][y][1];
        x = p;
        y = q;
    }


}

int Astar(void) {
    node now;
    while (!q.empty()) {
        node temp = q.top();
        q.pop();
        if (vis[temp.x][temp.y]) continue;
        vis[temp.x][temp.y] = true;
        if (temp.x == e.x && temp.y == e.y) {
            ouptu();
            return dis[e.x][e.y];
        }
        for (int i = 0; i < 8; i++) {
            int fx = dx[i] + temp.x;
            int fy = dy[i] + temp.y;
            if (fx < 1 || fx > n || fy < 1 || fy > m) continue;
            if (!vis[fx][fy]&&(dis[fx][fy]==0|| dis[fx][fy] > dis[temp.x][temp.y] + 1)) {
                father[fx][fy][0] = temp.x;
                father[fx][fy][1] = temp.y;
                dis[fx][fy] = dis[temp.x][temp.y] + 3;
                now.x = fx;
                now.y = fy;
                now.g = temp.g + 3;
                now.h = euclide(fx, fy);
                now.f = now.h + now.g;
                q.push(now);
            }
        }

    }
    return -1;
}

int main()
{
    int x, y;
    int ans;
    scanf("%d%d", &n, &m);
    scanf("%d%d", &x, &y);
    b.x = x;
    b.y = y;
    dis[x][y] = 0;
    father[x][y][0] = 0;
    father[x][y][1] = 0;
    scanf("%d%d", &x, &y);
    e.x = x;
    e.y = y;
    q.push(b);
    ans=Astar();
    printf("\n%d", ans);
}