使用 BFS 找到图树直径的中心？

Question

所以这个函数，maximum_dist，找到一个图的直径（任务中给定的图总是一棵树）。

我希望它找到的是找到直径的中心，即与所有其他节点的最大距离最小的节点。

我“有点”理解我们可以通过跟踪每个节点的父节点来找到从u 到 t 的路径（u 和 t 之间的距离是直径）来做到这一点的想法.从那里我选择u和t中间的节点？我的问题是如何在这里为这个函数实现它？这会使其输出该图的节点 2 吗？

int biggest_dist(int n, int v, const vector< vector<int> >& graph)
//n are amount of nodes, v is an arbitrary vertex
{ //This function finds the diameter of thegraph
int INF = 2 * graph.size(); // Bigger than any other length
vector<int> dist(n, INF);

dist[v] = 0;
queue<int> next;
next.push(v);

int bdist = 0; //biggest distance
while (!next.empty()) {
    int pos = next.front();
    next.pop();
    bdist = dist[pos];

    for (int i = 0; i < graph[pos].size(); ++i) {
        int nghbr = graph[pos][i];
        if (dist[nghbr] > dist[pos] + 1) {
            dist[nghbr] = dist[pos] + 1;
            next.push(nghbr);
        }
    }
}

return bdist;
}

Answer 1

事实上，这个函数并不计算直径。它计算距给定顶点 v 最远的顶点。

要计算一棵树的直径，首先需要选择一个任意顶点（比如v），然后找到离v 最远的顶点（比如w），然后找到一个离w 最远的顶点，让我们坐在u。 w 和u 之间的距离是树的直径，但v 和w 之间的距离（你的函数正在做什么）不能保证是直径。

要让你的函数计算直径，你需要让它返回它找到的顶点以及距离。方便的是，它将始终是您处理的最后一个元素，因此只需让您的函数记住它处理的最后一个元素以及与该元素的距离，然后将它们都返回。然后调用你的函数两次，首先从任意顶点，然后从第一次调用返回的顶点。

为了让它真正找到中心，您还可以在 BFS 期间记住每个节点的父节点。为此，请分配一个额外的数组，例如 prev，然后当你这样做时

dist[nghbr] = dist[pos] + 1;

也可以

prev[nghbr] = pos;

然后在第二次调用函数结束时，您可以将 bdist/2 次下降到 prev 中，类似于：

center = lastVertex;
for (int i = 0; i + i < bdist; ++ i) center = prev[center];

因此，对您的函数进行一些调整（使其返回距v 最远的顶点以及位于该路径中间的顶点，并且根本不返回直径），此代码可能会返回您树的中心（我只在您的示例中对其进行了测试，因此可能会出现一些错误）

pair<int, int> biggest_dist(int n, int v, const vector< vector<int> >& graph)
{
    int INF = 2 * graph.size(); // Bigger than any other length
    vector<int> dist(n, INF);
    vector<int> prev(n, INF);

    dist[v] = 0;
    queue<int> next;
    next.push(v);

    int bdist = 0; //biggest distance
    int lastV = v;
    while (!next.empty()) {
        int pos = next.front();
        next.pop();
        bdist = dist[pos];
        lastV = pos;

        for (int i = 0; i < graph[pos].size(); ++i) {
            int nghbr = graph[pos][i];
            if (dist[nghbr] > dist[pos] + 1) {
                dist[nghbr] = dist[pos] + 1;
                prev[nghbr] = pos;
                next.push(nghbr);
            }
        }
    }

    int center = lastV;
    for (int i = 0; i + i < bdist; ++ i) center = prev[center];

    return make_pair(lastV, center);
}

int getCenter(int n, const vector< vector<int> >& graph)
{
    // first call is to get the vertex that is furthest away from vertex 0, where 0 is just an arbitrary vertes
    pair<int, int> firstResult = biggest_dist(n, 0, graph);
    // second call is to find the vertex that is furthest away from the vertex just found
    pair<int, int> secondResult = biggest_dist(n, firstResult.first, graph);
    return secondResult.second;
}