Самый длинный путь в неориентированном дереве с одним обходом

Существует этот стандартный алгоритм поиска самого длинного пути в ненаправленных деревьях с использованием двух поисков в глубину:

• Запустите DFS из случайной вершины и найдите самую дальнюю из нее; скажи это .$v$$v'$
• Теперь запустите DFS из чтобы найти самую дальнюю вершину. Этот путь является самым длинным путем в графе.$v'$

Вопрос в том, можно ли сделать это более эффективно? Можем ли мы сделать это с одной DFS или BFS?

(Это можно эквивалентно описать как проблему вычисления диаметра ненаправленного дерева.)

Мы выполняем поиск в глубину по порядку и собираем результаты по пути, то есть рекурсивно решаем проблему.

Для каждого узла с (в дереве поиска) существует два случая:$v$$u_1,\dots,u_k$

• Самый длинный путь в лежит в одном из поддеревьев .$T_v$$T_{u_1},\dots,T_{u_k}$
• Самый длинный путь в содержит .$T_v$$v$

Во втором случае мы должны объединить один или два самых длинных пути из в одно из поддеревьев; это, безусловно, те, что до самых глубоких листьев. Длина пути тогда если , или если , с множественный набор высот поддерева¹.$v$$H_{(k)} + H_{(k-1)} + 2$$k>1$$H_{(k)}+1$$k=1$$H = \{ h(T_{u_i}) \mid i=1,\dots,k\}$

В псевдокоде алгоритм выглядит так:

procedure longestPathLength(T : Tree) = helper(T)[2]

/* Recursive helper function that returns (h,p)
 * where h is the height of T and p the length
 * of the longest path of T (its diameter) */
procedure helper(T : Tree) : (int, int) = {
  if ( T.children.isEmpty ) {
    return (0,0)
  }
  else {
    // Calculate heights and longest path lengths of children
    recursive = T.children.map { c => helper(c) }
    heights = recursive.map { p => p[1] }
    paths = recursive.map { p => p[2] }

    // Find the two largest subtree heights
    height1 = heights.max
    if (heights.length == 1) {
      height2 = -1
    } else {
      height2 = (heights.remove(height1)).max
    }

    // Determine length of longest path (see above)        
    longest = max(paths.max, height1 + height2 + 2)

    return (height1 + 1, longest)
  }
}

1. $A_{(k)}$ является наименьшим значением в (статистика заказа).$k$$A$

Это может быть решено в лучшую сторону. Кроме того, мы можем уменьшить временную сложность до O (n) с небольшим изменением структуры данных и используя итеративный подход. Для подробного анализа и нескольких способов решения этой проблемы с различными структурами данных.

Вот краткое изложение того, что я хочу объяснить в моем блоге :

Рекурсивный подход - диаметр дерева. Другой способ решения этой проблемы заключается в следующем. Как мы уже упоминали выше, диаметр может

1. полностью лежать в левом поддереве или
2. полностью лежать в правом поддереве или
3. может распространяться через корень

Это означает, что диаметр может быть идеально получен

1. диаметр левого дерева или
2. диаметр правильного дерева или
3. высота левого поддерева + высота правого поддерева + 1 (1 для добавления корневого узла, когда диаметр проходит через корневой узел)

И мы знаем, что диаметр - это самый длинный путь, поэтому мы берем максимум 1 и 2 на случай, если он лежит на одной из боковых сторон, или на 3, если он проходит через корень.

Итерационный подход - диаметр дерева

У нас есть дерево, нам нужна мета-информация с каждым узлом, чтобы каждый узел знал следующее:

1. Высота его левого ребенка,
2. Высота его правого ребенка и
3. Самое дальнее расстояние между его листовыми узлами.

Как только у каждого узла есть эта информация, нам нужна временная переменная для отслеживания максимального пути. Ко времени завершения алгоритма у нас есть значение диаметра в переменной temp.

Теперь нам нужно решить эту проблему восходящим подходом, потому что мы понятия не имеем о трех значениях для корня. Но мы знаем эти значения для листьев.

Шаги для решения

1. Инициализируйте все листья с leftHeight и rightHeight как 1.
2. Инициализируем все листья с maxDistance как 0, мы отмечаем, что если значение leftHeight или rightHeight равно 1, то maxDistance = 0
3. Двигайтесь вверх по одному за раз и вычислите значения для ближайшего родителя. Это было бы легко, потому что теперь мы знаем эти ценности для детей.

4. В данном узле

   • присвойте leftHeight максимальное значение (leftHeight или rightHeight его левого дочернего элемента).
   • присвойте rightHeight максимальное значение (leftHeight или rightHeight его правого потомка).
   • если любое из этих значений (leftHeight или rightHeight) равно 1, то maxDistance будет равно нулю.
   • если оба значения больше нуля, присвойте maxDistance значение leftHeight + rightHeight - 1
5. Сохраните значение maxDistance в переменной temp, и если на шаге 4 значение maxDistance больше текущего значения переменной, замените его новым значением maxDistance.
6. В конце алгоритма значением в maxDistance является диаметр.

Ниже приведен код, который возвращает путь диаметра, используя только один обход DFS. Требуется дополнительное пространство для отслеживания наилучшего видимого диаметра, а также самого длинного пути, начинающегося в конкретном узле дерева. Это подход динамического программирования, основанный на том факте, что путь с самым длинным диаметром либо не содержит корня, либо является комбинацией двух самых длинных путей соседей корня. Таким образом, нам нужно два вектора, чтобы отслеживать эту информацию.

 int getDiam(int root, vector<vector<int>>& adj_list, int& height, vector<int>& path, vector<int>& diam) {
    visited[root] = true;
    int m1 = -1;
    int m2 = -1;
    int max_diam = -1;
    vector<int> best1 = vector<int>();
    vector<int> best2 = vector<int>();
    vector<int> diam_path = vector<int>();
    for(auto n : adj_list[root]) {
        if(!visited[n]) {
            visited[n] = true;
            int _height = 0;
            vector<int> path1;
            vector<int> path2;
            int _diam = getDiam(n, adj_list, _height, path1, path2);
            if(_diam > max_diam) {
                max_diam = _diam;
                diam_path = path2;
            }
            if(_height > m1) {
                m2 = m1;
                m1 = _height;
                best2 = best1;
                best1 = path1;
            }
            else if(_height > m2) {
                m2 = _height;
                best2 = path1;
            }
        }
    }

    height = m1 + 1;

    path.insert( path.end(), best1.begin(), best1.end() );
    path.push_back(root);

    if(m1 + m2 + 2 > max_diam) {
        diam = path;
        std::reverse(best2.begin(), best2.end());
        diam.insert( diam.end(), best2.begin(), best2.end() );
    }
    else{
        diam = diam_path;
    }


    return max(m1 + m2 + 2, max_diam);
}