路径优化（基于python的DFS、BFS、A*算法的分析）

路径搜索问题

1. 创建一个随机的二维迷宫

得到一个二维迷宫，其中大小为10*20，起点是（0,0），终点是（19,19），生成障碍的概率是0.2，换而言之障碍的稀疏率为20%。（0表示为该坐标可以行进，x表示为障碍，S和G分别是起点个目标点。）
根据上面这个迷宫，我们不难发现从S->G的路径有多条。那么怎么通过计算机程序去自己识别路径，是一个很有意思也很需要的，那么本文将介绍常见的三种路径搜索算法以供大家参考和共同学习。

2. DFS算法（深度优先搜索）

深度优先顾明思意，就是先顺着一个方向走到底（达到深度最大），然后没法走且还没到目标，那么就返回上一个决策点（决策点：有分叉路的点），然后选择另一条路走到底。这个深度优先搜索的思想很简单，再明白一点就是不拐弯，不决策，走不动再说。
以下图为例，起点是A0目标点是D2，其中的搜索路径是A0→B0→C1→D1然后深度达到了max，需要返回上一个决策点也就是B0，就从B0选另一条路走也就是B0→C2，同理B0这个点的所有决策的全深度都遍历过了，没法达到终点，那就继续返回上一个决策点。

根据这个解释和路径的搜索方式，相信大家都可以想到栈的用法，而使用DFS算法的时候调用栈的概念是可以大幅度降低编程难度的。
根据上面的迷宫得到下面的路径：

3. BFS算法（广度优先搜索）

深度优先顾明思意，就是先广度搜索，也就是横着走，把所有点都走一遍。这样会导致大部分情况下都比DFS算得慢，但是BFS总会给我们得出一个最短的路径解。

可以对比DFS可以看出之前的DFS采用的是栈，而实现BFS则是采用队列（queue）的数据结构。栈是LIFO（先进后出），而队列是FIFO（先进先出）。

3. A*算法

首先明确采用A算法的目的，由于BFS和DFS前者是可以求出最短路径，而DFS是可以在最快的方式下找到一条合适的路径。而A算法综合了两个的优点，利用距离的因素对每个取点进行一次加权的判断。对比BFS算法来说，同样是得到最短路径，但用时相对而言降低不少；对比DFS算法来说，可以在短时间内找到最优路径。取两者的长处已经摒弃短处。
A*算法是结合了代价函数g(n)和启发函数h(n)，启发函数是对问题解决方式的一种直觉，目的是尽可能的寻求下一个最短路上的点，
采用的距离可以选择欧拉距离或曼哈顿距离：

def manhatan_disance(goal: MazeLocation) -> Callable[[MazeLocation], float]:  # 曼哈顿距离（横纵坐标差绝对值之和）
    def distance(ml: MazeLocation) -> float:
        xdist: int = abs(ml.column - goal.column)
        ydist: int = abs(ml.row - goal.row)
        return xdist + ydist
    return distance

4. 放大迷宫，对比各种算法求解迷宫问题的差别

可以看出：
BFS算法对比DFS算法来说可以得到更优的路线，但是运算时间较长，大概是DFS算法的一倍；
BFS算法对比采用曼哈顿距离的A算法来说，虽然路线长度一致，但A算法明显运算效率更高，大概只是BFS算法运行时间的20%；
DFS算法对比采用曼哈顿距离的A算法来说，虽然运算时间大致一样，但A算法可以得到更短的路线，而在现实长距离的问题中更具有实际意义；
A算法采用曼哈顿距离和采用欧拉距离虽然得到一样的路线，但是求解欧拉距离的时候运算量比曼哈顿距离多，使用时间接近7倍。
综上所述，求解迷宫问题，求解路径问题（二维），在该3种算法中，大概率还是使用A（曼哈顿距离）算法最具好处。
最终程序（text.py）

from __future__ import annotations
from typing import TypeVar, Generic, List, Callable, Set, Optional, Deque, Dict
from heapq import heappush, heappop
T = TypeVar('T')


class Stack(Generic[T]):
    def __init__(self) -> None:
        self._container: List[T] = []

    @property
    def empty(self) -> bool:
        return not self._container

    def push(self, item: T) -> None:
        return self._container.append(item)

    def pop(self):
        return self._container.pop()

    def __repr__(self) -> str:
        return repr(self._container)


class Node(Generic[T]):
    def __init__(self, state: T, parent: Optional[Node], cost: float = 0, heuristic: float = 0) -> None:
        self.state: T = state
        self.parent: Optional[Node] = parent
        self.cost: float = cost
        self.heuristic = heuristic

    def __lt__(self, other):
        return (self.cost + self.heuristic) < (other.cost + other.heuristic)


def dfs(initial: T, goal_test: Callable[[T], bool], successors: Callable[[T], List[T]]) -> Optional[Node[T]]:
    frontier: Stack[Node[T]] = Stack()
    frontier.push(Node(initial, Node))
    explored: Set[T] = {
   initial}

    while not frontier.empty:
        current_node: Node[T] = frontier.pop()
        current_state: T = current_node.state
        if goal_test(current_state):
            return