Calcular la altura de un árbol general en C++

El siguiente fragmento de código escrito en c++ calcula la altura de un árbol general de forma recursiva empleando plantillas de tipo T. Si bien esta pudiera no ser la forma más eficiente de realizar este procedimiento, es la que mejor escenifica el recorrido de la estructura de un árbol general. Tras el código he añadido un par de explicaciones, que se pueden completar con las dudas que dejes en los comentarios.

template <typename T>
template <typename T>
int Altura(const Agen<T> A, typename Agen<T>::nodo n){
    if( n == Agen<T>::NODO_NULO)
        return -1;
    else{
        // Tomamos al hijo de n
        typename Agen<T>::nodo hijo = A.hijoIzqdo(n);
        int max = -1;
        // Recorremos al mismo y a todos sus hermanos
        while(hijo != Agen<T>::NODO_NULO){
            int aux = Altura(A, hijo);
            if(aux > max)
                max = aux;
            hijo = A.hermDrcho(hijo);
        }
        return max + 1;
    }
}
}

A partir del nodo del árbol A, calculamos la altura, que se define como la longitud de la rama más larga que parte de n. Para aclararnos, la altura de un nodo hoja será 0 (-1 en el algoritmo) y la de la raíz será máxima. Si el nodo que encontramos es nulo, devuelve -1 para ajustar la solución, que de otra forma daría un entero de más. Si no, busca la máxima de las alturas entre el hijo izquierdo del nodo actual y su hermano derecho.

Obtener coordenadas en un plano al hacer clic sobre él | Unity 5.6+

El siguiente snippet pretende ilustrar cómo se pueden obtener las coordenadas del mundo real al realizar un clic sobre la pantalla. Es válido para, al menos, las versiones de Unity 5.6 y superiores y está escrito en C#.

Cuando el usuario realiza una pulsación sobre la pantalla es, a priori, imposible determinar las coordenadas espaciales del punto donde pretendía pulsar, ya que para lograr esto se necesita una referencia. Es como si señaláramos a un cielo estrellado y dijéramos… ¡quiero las coordenadas de ese punto! Bien, ¿pero con respecto a qué?

En primer lugar debemos crear una referencia; en concreto un plano geométrico que nos servirá como base de operaciones. No confundas este plano con la forma geométrica primitiva de Unity que comparte su mismo nombre; este plano es una representación matemática de un plano en el espacio tridimensional. Puedes leer más acerca de los planos en Unity haciendo clic aquí, y sobre los planos geométricos aquí.

Una vez creado nuestro plano, plane, en la función update pedimos que cada vez que el usuario haga clic con el botón izquierdo del ratón, se cree un rayo (o semirrecta) geométrico que comience en el punto de la pantalla donde se ha realizado la pulsación. A continuación creamos una variable, rayDistance, que pasamos por referencia a la función plane.Raycast, la cuál creará la intersección entre nuestro rayo y el plano geométrico anteriormente creado. rayDistance será el resultado del cálculo de la longitud de la semirecta cuyo origen sea la posición del objeto que invoca a la función y el punto de intersección con el plano. Con éste último dato podemos obtener el punto del rayo geométrico situado a la recién calculada distancia. En nuestro caso, como prueba, creamos un cubo en el punto de choque.

Para entender el funcionamiento de este script lo mejor es hacer cuantos experimentos sean necesarios con el código de abajo, y también echarle un vistazo a la siguiente imagen con la que pretendo ilustrar el ejercicio.

  Plane plane = new Plane(Vector3.up, Vector3.zero);
	void Update () {
        if (Input.GetMouseButtonDown(0))
        {
          Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
          float rayDistance;
          if (plane.Raycast(ray, out rayDistance)) // Intersects a ray with the plane.
          {
            pivotPoint = ray.GetPoint(rayDistance);
            GameObject test = GameObject.CreatePrimitive(PrimitiveType.Cube);
            test.transform.position = pivotPoint;
          }
        }
      }