Question

我正在开发一个C ++程序，我们必须以一种方式遍历顶点和加权边的图形，我们从用户指定的顶点开始，然后在经过一定的所需距离后在同一顶点结束。我不知道如何用代码实现这个，但到目前为止我已经这样做了：

void DijkstrasShortestPath()
{
    while (vertices.size() != 0)
    {
        Vertex* u = extract_min(vertices);
        vector<Vertex*>* adjVertex = AdjVertices(u);

        const int size = adjVertex->size();
        for (int i=0; i<size; ++i)
        {
            Vertex* v = adjVertex->at(i);
            int distance = travel_dist(u, v) +
                u->distFromStart;

            if (distance < v->distFromStart)
            {
                v->distFromStart = distance;
                v->previous = u;
            }
        }
        delete adjVertex;
    }
}

Vertex* extract_min(vector<Vertex*>& vertices)
{
    int size = vertices.size();
    if (size == 0) {
        return NULL;
    }
    int minimum = 0;
    Vertex* min = vertices.at(0);
    int i = 0;
    for( i=1; i<size; ++i)
    {
        Vertex* temp = vertices.at(i);
        if( temp->distFromStart < min->distFromStart) {
            min = temp;
            minimum = i;
        }
    }
    vertices.erase(vertices.begin() + minimum);
    return min;
}

vector <Vertex*>* AdjVertices(Vertex* vert)
{
    vector<Vertex*>* adjVertex = new vector <Vertex*> ();
    const int size = edges.size();
    for(int i=0; i<size; ++i)
    {
        Edge* edge = edges.at(i);
        Vertex* adjacent = NULL;
        if (edge->intersection1 == vert)
        {
            adjacent = edge->intersection2;
        }
        else if (edge->intersection2 == vert)
        {
            adjacent = edge->intersection1;
        }
        if (adjacent && vertices_check(vertices, adjacent))
        {
            adjVertex->push_back(adjacent);
        }
    }
    return adjVertex;
}

int travel_dist(Vertex* u, Vertex* v)
{
    const int size = edges.size();
    for(int i=0; i<size; ++i)
    {
        Edge* edge = edges.at(i);
        if (edge->street_connection(u, v))
        {
            return edge->distance;
        }
    }
    return -1;
}

bool vertices_check(vector<Vertex*>& vertices, Vertex* vert)
{
    const int size = vertices.size();
    for(int i=0; i<size; ++i)
    {
        if (vert == vertices.at(i))
        {
            return true;
        }
    }
    return false;
}

这实际上是Dijkstra的最短路径算法，这不是我想要的。我正在尝试做的是让程序计算一个距离在用户指定距离的1个单位内并在同一个顶点开始和结束的路线。有什么方法可以通过改变我的方式来做到这一点吗？

这是否需要广度优先搜索或深度优先搜索而不是Dijkstra算法？

Answer 1

Dijkstra算法只存储从起始节点到任何其他节点的最短路径。您想要的是跟踪通往节点的所有路径。如果你有这些，你可以检查每次找到一个到节点的新路径，如果有一个路径已经找到，之前的长度加上新路径的长度在用户指定距离的一个单位内。如果你然后向前走一条路，而另一条向后走，你就有了回路。

Answer 2

一种可能的方法。

您可以使用有界best-first search。

创建一个结构P，它存储形成潜在循环的节点列表，以及到目前为止创建的循环的长度。

通过为S链接到的每个节点创建单独的P结构，在指定的顶点S播种搜索。将这些P结构添加到优先级队列中，该队列按P结构描述的路径长度排序。

考虑这些节点中的每一个依次从优先级队列中移除它们的P结构，复制它们的P结构，并附加它们链接到的节点。如果要添加的节点已经存在于P结构中而不是S，则丢弃该结构并且不再考虑该路由。同样，如果任何路径超过指定的成本C，则丢弃该路径，不再考虑它。如果路径尚未被丢弃，请将其关联的P结构添加到优先级队列。

如果S确实出现在P结构中两次并且P结构描述的路径长度在允许的范围内，则成功退出。如果没有，继续搜索，直到priortiy-queue为空。

您可以使用admissible heuristic来估算从给定节点到S的距离，并将其添加到正在进行的路径的既定成本，并使用sum作为优先级队列的排序键。这种启发式是A* algorithm的核心，这可能是你感兴趣的。

这是否清楚？如果没有，我可以写一个简短的示例代码。

从起点遍历图表并在起始点C ++处结束

2 个答案: