Trayectoria más larga en un árbol no dirigido con un solo recorrido

Existe este algoritmo estándar para encontrar la ruta más larga en árboles no dirigidos utilizando dos búsquedas de profundidad:

• Inicie DFS desde un vértice aleatorio y encuentre el vértice más alejado de él; di que es v ′ .$v$$v'$
• Ahora comience un DFS desde para encontrar el vértice más alejado de él. Esta ruta es la ruta más larga en el gráfico.$v'$

La pregunta es, ¿se puede hacer esto de manera más eficiente? ¿Podemos hacerlo con un solo DFS o BFS?

(Esto puede describirse de manera equivalente como el problema de calcular el diámetro de un árbol no dirigido).

Realizamos una búsqueda profunda en orden posterior y agregamos resultados en el camino, es decir, resolvemos el problema de forma recursiva.

Para cada nodo con hijos u 1 , ... , u k (en el árbol de búsqueda) hay dos casos:$v$$u_1,\dots,u_k$

• El camino más largo en encuentra en uno de los subárboles T u 1 , ... , T u k .$T_v$$T_{u_1},\dots,T_{u_k}$
• La ruta más larga en contiene v .$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\}$

En pseudocódigo, el algoritmo se ve así:

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$

Esto se puede resolver de una mejor manera. Además, podemos reducir la complejidad del tiempo a O (n) con una ligera modificación en la estructura de datos y utilizando un enfoque iterativo. Para un análisis detallado y múltiples formas de resolver este problema con varias estructuras de datos.

Aquí hay un resumen de lo que quiero explicar en una publicación mía del blog :

Enfoque recursivo: diámetro del árbol Otra forma de abordar este problema es la siguiente. Como mencionamos anteriormente, el diámetro puede

1. mentir completamente en el subárbol izquierdo o
2. mentir completamente en el subárbol derecho o
3. puede extenderse a través de la raíz

Lo que significa que el diámetro puede derivarse idealmente por

1. el diámetro del árbol izquierdo o
2. el diámetro del árbol derecho o
3. la altura del subárbol izquierdo + la altura del subárbol derecho + 1 (1 para agregar el nodo raíz cuando el diámetro se extiende por el nodo raíz)

Y sabemos que el diámetro es el camino más largo, por lo que tomamos el máximo de 1 y 2 en caso de que se encuentre en cualquiera de los lados o tome 3 si se extiende a través de la raíz.

Enfoque iterativo: diámetro del árbol

Tenemos un árbol, necesitamos una metainformación con cada nodo para que cada nodo sepa lo siguiente:

1. La altura de su hijo izquierdo,
2. La altura de su hijo derecho y
3. La distancia más lejana entre sus nodos de hoja.

Una vez que cada nodo tiene esta información, necesitamos una variable temporal para realizar un seguimiento de la ruta máxima. Cuando termina el algoritmo, tenemos el valor del diámetro en la variable temporal.

Ahora, necesitamos resolver este problema en un enfoque ascendente, porque no tenemos idea de los tres valores para la raíz. Pero conocemos estos valores para las hojas.

Pasos para resolver

1. Inicialice todas las hojas con leftHeight y rightHeight como 1.
2. Inicialice todas las hojas con maxDistance como 0, señalamos que si cualquiera de leftHeight o rightHeight es 1, hacemos maxDistance = 0
3. Mueva hacia arriba de a uno por vez y calcule los valores para el padre inmediato. Sería fácil porque ahora conocemos estos valores para los niños.

4. En un nodo dado,

   • asigne leftHeight como máximo de (leftHeight o rightHeight de su hijo izquierdo).
   • asigne el rightHeight como máximo de (leftHeight o rightHeight de su hijo derecho).
   • si alguno de estos valores (leftHeight o rightHeight) es 1, haga maxDistance como cero.
   • si ambos valores son mayores que cero, haga maxDistance como leftHeight + rightHeight - 1
5. Mantenga maxDistance en una variable temporal y si en el paso 4 maxDistance es mayor que el valor actual de la variable, reemplácelo con el nuevo valor maxDistance.
6. Al final del algoritmo, el valor en maxDistance es el diámetro.

A continuación se muestra un código que devuelve una ruta de diámetro utilizando solo un recorrido transversal DFS. Requiere espacio adicional para realizar un seguimiento del mejor diámetro visto hasta ahora, así como el camino más largo que comienza en un nodo particular en el árbol. Este es un enfoque de programación dinámica basado en el hecho de que una ruta de diámetro más largo no incluye la raíz o es una combinación de las dos rutas más largas de los vecinos de la raíz. Por lo tanto, necesitamos dos vectores para realizar un seguimiento de esta información.

 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);
}