Recursion 返回最小生成树中两个节点之间的路径

我使用Kruskal算法创建了一个最小生成树，它存储在key:string和data:set（string）的映射中

我正在尝试编写一个算法，该算法将返回指定的开始节点和结束节点之间的路径

$ findPath A F
> A B D E F

$ findPath F C
> F E D B C

我认为我应该使用某种改进的深度优先搜索，但我不确定如何实现算法或如何存储形成路径的节点。我认为我不必担心将节点标记为“已访问”，因为MST中没有循环

有一些类似的问题，但我还没有找到任何可以应用于我的特定场景的问题，它们似乎只处理非MST，并且只有在两个节点之间可以找到路径时才返回，在我的例子中，我已经知道每个节点之间都有一条路径，我还需要路径上的节点列表

编辑 答案转换为C++，可能不是最干净的代码，但它工作

vector<string> findPath(map<string, set<string>> mst, string src, string dest, vector<string> path) {
    if(src == dest) {
        return path;
    }
    set<string> possible = mst[src];
    for(vector<string>::iterator it = path.begin(); it != path.end(); it++) {
        if(possible.find(*it) != possible.end())
            possible.erase(*it);
    }
    for(set<string>::iterator it = possible.begin(); it != possible.end(); it++) {
        vector<string> a = path;
        if(find(a.begin(), a.end(), src) == a.end())
                a.push_back(src);
        vector<string> p = findPath(mst, *it, dest, a);
        if(p[0] != "FALSEBEGINNING") {
            return p;
        }
    }
    vector<string> p = path;
    p[0] = "FALSEBEGINNING";
    return p;
}

vector findPath（映射mst、字符串src、字符串dest、向量路径）{
如果（src==dest）{
返回路径；
}
设置可能=mst[src]；
for（vector:：iterator it=path.begin（）；it！=path.end（）；it++）{
if（可能的.find（*it）！=可能的.end（））
可能。删除（*它）；
}
for（set:：iterator it=mable.begin（）；it！=mable.end（）；it++）{
向量a=路径；
if（find（a.begin（），a.end（），src）=a.end（））
a、 推回（src）；
向量p=findPath（mst，*it，dest，a）；
如果（p[0]！=“错误开始”）{
返回p；
}
}
向量p=路径；
p[0]=“错误开始”；
返回p；
}

const mst={
A:[B']，
B:[A'，C'，D']，
C:[B']，
D:[B'，'E']，
E:['D'，'F']
}
常量findPathTraversal=（mst、src、dest、path）=>{
常量findPath=（mst、src、dest、path）=>{
if（src==dest）返回路径
让可能=mst[src]
可能=可能的.filter（v=>！path.includes（v））
for（设i=0；ilog（findPathTraversal（mst，'A'，'F'，[]））

此算法运行完美！我试图在C++中实现它，但是我遇到了一些麻烦，它每次返回一个空路径，即使我可以看到它正在访问正确的路径。

vector<string> findPath(map<string, set<string>> mst, string src, string dest, vector<string> path) {
    if(src == dest) {
        return path;
    }
    set<string> possible = mst[src];
    for(vector<string>::iterator it = path.begin(); it != path.end(); it++) {
        if(possible.find(*it) != possible.end())
            possible.erase(*it);
    }
    for(set<string>::iterator it = possible.begin(); it != possible.end(); it++) {
        vector<string> a = path;
        if(find(a.begin(), a.end(), src) == a.end())
                a.push_back(src);
        vector<string> p = findPath(mst, *it, dest, a);
        if(p[0] != "FALSEBEGINNING") {
            return p;
        }
    }
    vector<string> p = path;
    p[0] = "FALSEBEGINNING";
    return p;
}