注：本文为半转载文章，原文链接为A_L_A_N的博文 ~~总之比原文充实…~~

/*
	Name: A*
	Copyright: CQHFBZ
	Author: YJ
	Date: 2020/01/26 18:45
	Description: 咕咕咕，一个让人咕的寻路算法...
*/

$1\space Meet\space A*$

$A*$ 是一个~~让人咕咕咕的~~优秀的寻路 $or$ 搜索算法

$TA$ 的中心思路是贪心， $BFS$ ，和预估函数

$TA$ 的时间复杂度是 $\theta($ 出的题能过 $)$ ~~并不是我懒~~

$2\space Do\space A*$

此处有一地图：

绿色代表起点( $A$ )，红色代表终点( $B$ )，蓝色代表障碍(即不可行的状态)，小方格代表一种状态(起点，终点皆为一种状态)

那我们开始搜索c

定义两个列表 $OpenList, CloseList$ 代表待搜索列表和已搜索列表( $Hash$ 映射也行)

1. 将起点 $A$ 加入 $OpenList$

2. 寻找起点 $A$ 周围可以到达的格子，将他们加入 $OpenList$ ，并将他们的父节点设为起点 $A$

3. 将起点 $A$ 弹出 $OpenList$ 并加入 $CloseList$

如图，描有浅绿色的边的格子代表在 $OpenList$ 里面的格子

描有浅蓝色的边的格子代表在 $CloseList$ 里面的格子

我们要比出那个格子最靠谱，接下来，就是A*算法最核心的公式 $F=G+H$

~~路人：一个三元一次不等式…~~

其中， $F$ 代表的经过方格 $X$ 的预估距离

$G$ 代表从起点 $A$ 到方格 $X$ 的实际距离

$H$ 代表从方格 $X$ 到终点 $B$ 的预估距离

注意1：计算出的 $F$ 值得尽量小于而又尽量接近实际距离，这跟一个好的 $H$ 密切相关

如上图，我们为了方便讲解，将横着的一步的距离设为 $10$ ，斜着的一步的距离设为 $14$ ，且斜走时旁边不能有障碍~~我不会告诉你我是为了抠图…~~

每个已遍历方格的左下角是 $G$ ，右下角是 $H$ ，左上角是 $F$

4. 可见 $F$ 值最小的是起点 $A$ 的左边方格 $C$ ，将 $TA$ 周围可到达的格子(除障碍物与在 $CloseLsit$ 内的格子)加入 $OpenList$ …

停！

我们这时候就要来分类讨论了：

4.1. 某方格 $D$ 已经在 $OpenList$ 里面了

这时候我们就要与前面的 $G$ 值作比较，取最小的 $F$ 值，更新路径(即父节点)

4.2. 某方格 $D$ 还不在 $OpenList$ 里面了

~~那还不加入…~~

如上图，那 $C$ 方格的上面 $D$ 方格来讲，他的新 $G$ 值是 $10+10=20$ ，而原 $G$ 值是 $14$ ，所以要保留原来路径，不要绕路

5. 现在我们开始寻找 $OpenList$ 中寻找"最靠谱"的方格，但我们发现 $C$ 上面和下面的F值都是 $54$ ，我们这时候就只能靠运气，随便选一个，就拿下面方格举例，称他为 $D$ ，将 $TA$ 的周围顶点如 $4.1, 4.2$ 一样做处理

注意2：方格 $D$ 并不是由方格 $C$ 走来的， $TA$ 是由 $TA$ 的父节点 $A$ 走来的，这是一个很常见的错误?(顺便说一下，我上一句谈到 $C$ 只因为让读者知道位置，而非表达一个递进关系…)

完成后如图：

看看与你是否想的一样

…

( $N$ 个…)

最后，我们会得到两种结果：

$N$ .1. 终点 $B$ 已加入 $OpenList$ ，查找成功

那么就沿着父节点向前搜索，直到起点，再反向输出路径：

$\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow\Downarrow$

$N$ .2. $OpenList$ 已经为空，查找失败

return -1;

$3\space summary\space A*$

上伪代码(本人第一次写伪代码，写的不好~~可以揍我~~可以喷我，但不可以揍我，因为我是练习时长两年半的个人 $Oier$ ： $YJ$ …)：

//A_star伪代码//
//前置芝士: 指针//
/*****定义*****/
struct node {
    pair<int, int> pos;
    int G, H, F;
    int father;//0~7, 从上面开始顺时针标号
} Start, End;
int way[2][8] = {{1, 0}, {1, -1}, {0, -1}, {-1, -1}, ......};
vector<node*> OpenList;
vector<node*> CloseList;
/*****定义*****/
/*****过程*****/
node* InList(list<node*> &L, node* find);//寻找find是否在L里面(有返回指针，没返回NULL)
node* MinF();//找出带有最小F值的node指针
bool CanGo(pair<int, int> posx, int wayi);//判断可不可以到达
int GetG(node* X, int wayi);//求G
int GetH(node* X, node* E);//一个优秀的函数
bool AStar(node* S, node* E) {
    S -> G = 0;
    S -> H = S -> F = Get_H(S, E);
    S -> father = -1;
    S加入OpenList;
    while (OpenList不为空) {
        node* X = MinF();
        删除OpenList里面的X;
        X加入CloseList;
        for (i : 0 ~ 7) {
            node* Y = 新的node;
            if (一大堆要求 and CanGo(X -> pos, i) and InList(CloseList, Y) == NULL) {
                if (Y是E) return 1;
                求Y的GHF;
                node* InListY = InList(OpenList, Y);
                if (InList == NULL) {
                    Y -> father = i;
                    Y加入OpenList;
                }
                else {
                    if (Y -> G < InListY -> G) {
                        更改InListY的G, F, father;
                    }
                }
            }
        }
    }
    return 0;
}
vector<node*> GetPath(node* S, node* E) {
    vector<node*> path;
    //读者们请自行思考
    return path;
}
/*****过程*****/
/*****main*****/
int main() {
    //读者们请自行思考
    return 0;
}

内存限制：128 MiB 时间限制：1000 ms

给定一张N个点（编号1,2…N），M条边的有向图，求从起点S到终点T的第K短路的长度，路径允许重复经过点或边。

注意：每条最短路中至少要包含一条边。

第一行包含两个整数N和M。

接下来M行，每行包含三个整数A,B和L，表示点A与点B之间存在有向边，且边长为L。

最后一行包含三个整数S,T和K，分别表示起点S，终点T和第K短路。

输出占一行，包含一个整数，表示第K短路的长度，如果第K短路不存在，则输出“-1”。

样例输入

样例输出

1 <= n <= 1000, 0 <= m <= 100000

1 <= a, b <= N, 1 <= T(权值)<= 100

1 <= s, t <= N, 1 <= k <= 1000

由于路径可以重复，所以 $OpenList,CloseList$ 统统不要， $H$ 函数就是由终点道各点的路径( $SPFA$ 即可)

$code:$

#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>

using namespace std;
const int INF = 0x3f3f3f3f;
const int MAXN = 5e5 + 100;
const int MAXM = 3e3 + 10;

template <typename T>
inline void read(T &x) {
    x = 0;
    T ff = 1, ch = getchar();
    while (!isdigit(ch)) {
        if (ch == '-')
            ff = -1;
        ch = getchar();
    }
    while (isdigit(ch)) {
        x = (x << 1) + (x << 3) + (ch ^ 48);
        ch = getchar();
    }
    x *= ff;
}

template <typename T>
inline void write(T x) {
    if (x < 0)
        putchar('-'), x = -x;
    if (x > 9)
        write(x / 10);
    putchar(x % 10 + '0');
}

int n, m, s, t, k;
int f[MAXN], vis[MAXN];
int lin[MAXN], tot = 0, linc[MAXN], totc = 0;
struct edge {
    int y, v, next;
} a[MAXN], e[MAXN];

struct node {
    int pos, H, G;
    bool operator < (node a) const { return a.H + a.G < H + G; }
};

inline void add(int xx, int yy, int vv) {
    a[++tot].y = yy;
    a[tot].v = vv;
    a[tot].next = lin[xx];
    lin[xx] = tot;
}

inline void addc(int xx, int yy, int vv) {
    e[++totc].y = yy;
    e[totc].v = vv;
    e[totc].next = linc[xx];
    linc[xx] = totc;
}

void SPFA() {
    queue<int> q;
    memset(f, 0x3f, sizeof(f));
    memset(vis, false, sizeof(vis));
    q.push(t);
    f[t] = 0;
    vis[t] = true;
    while (!q.empty()) {
        int x = q.front();
        q.pop();
        vis[x] = false;
        for (int i = lin[x], y; i; i = a[i].next) {
            if (f[y = a[i].y] > f[x] + a[i].v) {
                f[y] = f[x] + a[i].v;
                if (!vis[y]) {
                    vis[y] = true;
                    q.push(y);
                }
            }
        }
    }
}

int astar() {
    priority_queue<node> q;
    if (f[s] == INF)
        return -1;
    int ts[MAXN];
    node tmp, h;
    h.pos = s;
    h.H = 0;
    h.G = 0;
    q.push(h);
    while (!q.empty()) {
        node x = q.top();
        q.pop();
        ts[x.pos]++;
        if (ts[x.pos] == k && x.pos == t)
            return x.G;
        if (ts[x.pos] > k)
            continue;
        for (int i = linc[x.pos]; i; i = e[i].next) {
            tmp.pos = e[i].y;
            tmp.H = f[e[i].y];
            tmp.G = x.G + e[i].v;
            q.push(tmp);
        }
    }
    return -1;
}

int main() {
    read(n);
    read(m);
    for (int i = 1; i <= m; ++i) {
        int u, v, w;
        read(u);
        read(v);
        read(w);
        add(v, u, w);
        addc(u, v, w);
    }
    read(s);
    read(t);
    read(k);
    if (s == t)
        ++k;
    SPFA();
    write(astar());
    return 0;
}

来源：CSDN

作者：樱花滴温柔

链接：https://blog.csdn.net/qq_44598375/article/details/104210450

标签

算法

A*算法初探

$1\space Meet\space A*$

$2\space Do\space A*$

$3\space summary\space A*$

489.第k短路

题目描述

输入格式

输出格式

样例

样例输入

样例输出

数据范围与提示

A*算法初探

1 Meet A∗1\space Meet\space A*1 Meet A∗

2 Do A∗2\space Do\space A*2 Do A∗

3 summary A∗3\space summary\space A*3 summary A∗

489.第k短路

题目描述

输入格式

输出格式

样例

样例输入

样例输出

数据范围与提示

$1\space Meet\space A*$

$2\space Do\space A*$

$3\space summary\space A*$