迷宫的最优路径

对于迷宫最优路径，其中之一方法就是把所有路径都找出来如下：

1   1    *     *   *

*    1    *     *   *

*    1    *     *   *

*    1    1    1   1

*    1    *     *   1                对于这样的迷宫，从（0 0）到（4 4）所有路径有（00）（01）（11）（21）（31）（41）（31）（32）（33）（34）（44）以及

（00）（01）（11）（21）（31）（32）（33）（34）（44）  这样在一条路径重复走同一节点，这样浪费了空间也同时浪费了时间。

当然求解迷宫的最优路径肯定需要重复走同一节点，但是对于每条路径是没有重复节点。换个方式从整体和局部上看，整体就是所有能从起点到终点的路径，局部就是整体中的每一条路径。对于整体是有重复节点，而在局部上是没有重复节点的。

这样我们可以给每个点也就是（1或者*）给个value，初始都为零。这样每走一步就加一，这样就记录了你走过的路径。同时走的路径只能朝着大数走或者是未走过的并且能走的路。这样就即保证了在单一条路径上没有走重复路，同时在其他路径可以重复走之前走过的节点。

#include "iostream"
#include "cstddef"
#include <vector>

using namespace std;

struct Point{
    int _X , _Y;
    Point(int X , int Y) 
        : _X(X) , _Y(Y){};
};//点的位置

int direct[4][2] = {0 , -1 , 1 , 0 , 0 , 1 , -1 , 0};//四个方向
template<typename T>
class MazePath{
private:
    vector<Point> path__;//记录路径
    size_t** Temp;//记录走过的次数
    T** Maze;//迷宫
    size_t width;//迷宫宽
    size_t height;//迷宫高
    T wall;//墙
public:
    MazePath();
    MazePath(size_t X , size_t Y , T);
    void push_back(T , size_t , size_t);
    void PrintMaze();
    bool isCanGo(size_t , size_t , size_t);//判断是否能通过
    int OptimalPath(Point& start , Point& end , vector<Point>& path);//获得最优路径
};

template<typename T> MazePath<T>::MazePath(size_t X , size_t Y , T w): width(X) , height(Y) , wall(w)
{
    this->Maze = new T*[height];
    this->Temp = new size_t*[height];
    for(int i = 0; i < height; ++ i){
        *(Maze + i) = new T[width];
        *(Temp + i) = new size_t[width];
        memset(*(Temp + i) , 0 , sizeof(size_t) * width);
    }
}

template<typename T> void MazePath<T>::push_back(T data , size_t X , size_t Y)
{
    if(X < this->width && Y < this->height) *(*(this->Maze + X) + Y) = data;
    else cout << "Out of the border!" << endl;
}

template<typename T> void MazePath<T>::PrintMaze()
{
    if(this->path__.size() != 0){
        for(int i = 0; i < this->path__.size(); ++ i)
            *(*(this->Maze + path__[i]._X) + path__[i]._Y) = '0';
    }
    for(int i = 0; i < this->height; ++ i){
        for(int j = 0; j < this->width; ++ j)
            cout << *(*(this->Maze + i) + j) << " ";
        cout << endl;
    }
}

template<typename T> bool MazePath<T>::isCanGo(size_t nX , size_t nY , size_t PrePoint)
{
    if(nX < 0 || nX > this->width - 1 || nY < 0 || nY > this->height - 1 || *(*(this->Maze + nX) + nY) == this->wall) return false;
    if(*(*(this->Temp + nX) + nY) == 0) return true;
    else return (PrePoint + 1) < *(*(this->Temp + nX) + nY); 
}

template<typename T> int MazePath<T>::OptimalPath(Point& start , Point& end , vector<Point>& path)
{
    if(start._X == end._X && start._Y == end._Y){
        if(this->path__.size() > path.size() || !this->path__.size())
            this->path__ = path;
        return 0;
    }
    for(int i = 0; i < 4; ++ i){
        int _NextPosX = start._X + direct[i][0];
        int _NextPosY = start._Y + direct[i][1];
        if(isCanGo(_NextPosX , _NextPosY , *(*(this->Temp + start._X) + start._Y))){
            *(*(this->Temp + _NextPosX) + _NextPosY) = *(*(this->Temp + start._X) + start._Y) + 1;
            path.push_back(Point(_NextPosX , _NextPosY));
            OptimalPath(Point(_NextPosX , _NextPosY) , end , path );
            path.erase(path.begin() + path.size() - 1);
        }
    }
    return 0;
}

int main()
{
    int wid , hei;
    cin >> wid >> hei;
    MazePath<char> _Maze(wid , hei , '*');
    for(int i = 0; i < hei; ++ i){
        for(int j = 0; j < wid; ++ j){
            char c;
            cin >> c;
            _Maze.push_back(c , i , j);
        }
    }
    _Maze.PrintMaze();
    Point start(0 , 0) , end(8 , 8);
    vector<Point> path;
    _Maze.OptimalPath(start , end , path);
    _Maze.PrintMaze();
    return 0;
}

结果图如下：