C++ 在递归迷宫解算器中保存路径坐标？

我有一个递归的迷宫求解算法，可以成功地通过迷宫。唯一的问题是，我找不到一种方法来保存起点和终点之间的最短路径。如何保存最短路径的坐标

这是递归函数

void Solve_Maze(int coorx,int coory) {
    if((coorx>=0)&&(coorx<l)&&(coory>=0)&&(coory<w)) {
        if((Map[coorx][coory]==Start)||(Map[coorx][coory]==path)) {
            Map[coorx][coory]=visited;
            Solve_Maze(coorx+1,coory);
            Solve_Maze(coorx-1,coory);
            Solve_Maze(coorx,coory+1);
            Solve_Maze(coorx,coory-1);
        }else if(Map[coorx][coory]==End) {
            delete Map;
            Solved=true;
        }
    }
}

---

它存储了所有的坐标，但它甚至存储了我们不想使用的路径的坐标（（7,2）（8,2）（9,2），然后返回到（7,3））。是否有一种方法可以存储最短路径？

如果当前路径的长度小于以前保存的路径的长度（如果有），则需要显式地存储堆栈，现在它隐式地存在于过程

解算迷宫

调用中，并在到达

解算=true

时从堆栈复制到解向量。当然，当进入程序时，按下

coorx，coory

，退出时弹出它们（不关心状态更改）

---

除了类型为“stack”的外部变量（如果不使用std libs，则可以使用数组）之外，还可以将结构中的coorx、coory绑定在一起，并在分配到Solve_Maze时传递指向它们的指针。但这大大改变了代码：在堆栈中传递要容易得多…

以下是使用向量跟踪解决方案坐标的方法：

#include <iostream>
#include <vector>
#include <map>

using namespace std;

const int w = 10, l = 10;
const char Start = 'S', Path = ' ', End = 'E', Visited = '.', Solution = '*';

char Map[w][l + 1] =
{
    { "  #  # #  " },
    { " S   #  # " },
    { " ###      " },
    { "   #   #  " },
    { "    #   # " },
    { "#        #" },
    { "    ###   " },
    { "  ##E ##  " },
    { "  #       " },
    { "   ##### #" },
};

int Solved = false;
vector<pair<int,int> > SolutionCoors;

void PrintMap()
{
    int x, y;

    for (y = 0; y < w; y++)
    {
        for (x = 0; x < l; x++)
            cout << Map[y][x];

        cout << endl;
    }
}

void Solve_Maze(int CoorX, int CoorY)
{
    if (CoorX >= 0 && CoorX < l && CoorY >= 0 && CoorY < w && !Solved)
    {
        SolutionCoors.push_back(make_pair(CoorX, CoorY)); // Store potential solution

        if (Map[CoorY][CoorX] == Start || Map[CoorY][CoorX] == Path)
        {
            Map[CoorY][CoorX] = Visited;

            Solve_Maze(CoorX + 1, CoorY);
            Solve_Maze(CoorX - 1, CoorY);
            Solve_Maze(CoorX, CoorY + 1);
            Solve_Maze(CoorX, CoorY - 1);
        }
        else if (Map[CoorY][CoorX] == End)
            Solved = true;

        if (!Solved)
            SolutionCoors.pop_back();
    }
}

int main()
{
    PrintMap();

    Solve_Maze(1, 1);

    if (Solved)
    {
        for (vector<pair<int,int> >::iterator it = SolutionCoors.begin();
             it != SolutionCoors.end();
             it++)
        {
            cout << "(" << it->first << "," << it->second << ")" << endl; // Print solution coords
            Map[it->second][it->first] = Solution; // Also mark on the map
        }

        PrintMap();
    }

    return 0;
}

---

另外请注意，我的

Map[][]

有相反的坐标。

一些东西可以让你找到正确的方向：

std:：vector

和

std:：vector:：push_back

。你的算法看起来不错，如果调整得当，它应该能找到最短的路径。我同意chris的建议，并进一步建议您将方法原型更改为类似于

std:：vector Solve_Maze（int coorx，coory，std:：vector path）

。我是否必须有两个向量（一个用于x值，一个用于y值）？这个词与问题的递归性有关，因为如果算法在搜索不同的路径，那么最短路径，坐标也会被保存。

#include <iostream>
#include <vector>
#include <map>

using namespace std;

const int w = 10, l = 10;
const char Start = 'S', Path = ' ', End = 'E', Visited = '.', Solution = '*';

char Map[w][l + 1] =
{
    { "  #  # #  " },
    { " S   #  # " },
    { " ###      " },
    { "   #   #  " },
    { "    #   # " },
    { "#        #" },
    { "    ###   " },
    { "  ##E ##  " },
    { "  #       " },
    { "   ##### #" },
};

int Solved = false;
vector<pair<int,int> > SolutionCoors;

void PrintMap()
{
    int x, y;

    for (y = 0; y < w; y++)
    {
        for (x = 0; x < l; x++)
            cout << Map[y][x];

        cout << endl;
    }
}

void Solve_Maze(int CoorX, int CoorY)
{
    if (CoorX >= 0 && CoorX < l && CoorY >= 0 && CoorY < w && !Solved)
    {
        SolutionCoors.push_back(make_pair(CoorX, CoorY)); // Store potential solution

        if (Map[CoorY][CoorX] == Start || Map[CoorY][CoorX] == Path)
        {
            Map[CoorY][CoorX] = Visited;

            Solve_Maze(CoorX + 1, CoorY);
            Solve_Maze(CoorX - 1, CoorY);
            Solve_Maze(CoorX, CoorY + 1);
            Solve_Maze(CoorX, CoorY - 1);
        }
        else if (Map[CoorY][CoorX] == End)
            Solved = true;

        if (!Solved)
            SolutionCoors.pop_back();
    }
}

int main()
{
    PrintMap();

    Solve_Maze(1, 1);

    if (Solved)
    {
        for (vector<pair<int,int> >::iterator it = SolutionCoors.begin();
             it != SolutionCoors.end();
             it++)
        {
            cout << "(" << it->first << "," << it->second << ")" << endl; // Print solution coords
            Map[it->second][it->first] = Solution; // Also mark on the map
        }

        PrintMap();
    }

    return 0;
}

  #  # #  
 S   #  # 
 ###      
   #   #  
    #   # 
#        #
    ###   
  ##E ##  
  #       
   ##### #
(1,1)
(2,1)
(3,1)
(4,1)
(4,2)
(5,2)
(6,2)
(6,3)
(5,3)
(5,4)
(6,4)
(7,4)
(7,5)
(8,5)
(8,6)
(9,6)
(9,7)
(8,7)
(8,8)
(7,8)
(6,8)
(5,8)
(4,8)
(4,7)
  #  #.#..
 ****#..#.
 ###***...
   #.**#..
    #***#.
#      **#
    ### **
  ##* ##**
  #.*****.
   ##### #