El código del programa ponlo entre etiquetas de código GeSHi, encima del cuadro de texto.

El <while> divide cada número hasta que los dos son 0. Entonces el resultado es 0 * 0 = 0. Además usas un contador <i> que no tiene ninguna utilidad.Si el número tiene que tener dos cifras obligatoriamente, sólo necesitas dividir el número entre 10 una vez.
En un caso general con cualquier número de cifras tienes que hacer un bucle como el que tienes pero fíjate que la primera cifra de cada número se guarda en r1 y r2 respectivamente, no en n1 y n2 (estos valdrán 0). Suerte

PD: Los problemas relacionados con este tipo de ejercicios se solucionan cogiendo un papel y un boli o pensando lo que estás haciendo, no poniendo código sin pensar...

Para que funcione tienes que distinguir 3 casos (te falta 1):
- Si inicio y fin son iguales -> return v[inicio]
- Si la diferencia entre inicio y fin es 1 -> return sumaDyV(v, inicio, inicio) + sumaDyV(v, fin, fin)
- Si la diferencia es mayor que 1 -> return sumaDyV(v, inicio, fin/2) + return sumaDyV(v, fin/2+1, fin)
Suerte.

Si te manda errores, la pregunta correcta no es "qué le falta?" sino "qué le falla". Si tienes un error especifica cual es el problema que tienes, puedes copiar el mensaje de error que te sale o si el programa compila decir en que momento el programa falla.
Sino dudo que alguien vaya a mirar todo ese código para buscar un fallo que no sabemos ni de qué tipo es. 

Y para que podamos ver mejor el programa, modifica el primer mensaje y añade las etiquetas de código GeSHi.

Si tienes que hacer un programa que haga una serie de cosas que has comentado y tienes un código hecho simplemente mira que ese código haga todo lo que tiene que hacer tu programa. Si hay una cosa que no hace, eso es lo que te falta...
Y el código de los programas entre etiquetas de Código GeSHi. Suerte.

Mi pregunta es si es posible definir una función con varios <templates>. Para que se entienda mejor os pongo un ejemplo sencillo, imaginad tener una función que devuelve el tamaño de una pila <stack> de cualquier tipo (sí, ya se que eso ya existe pero para hacer sencillo el ejemplo):

template <class T>
size_t stackSize(const stack<T> &s){
    return s.size();
} 

Hasta aquí todo bien pero si queremos hacer una función que reciba dos pilas de distinto tipo y devuelva el tamaño de la más grande... La idea es algo así, pero tendríamos errores de compilación por un conflicto entre el tipo de la primera pila y el de la segunda si no son iguales.

template <class T>
size_t biggestStackSize(const stack<T> &st1, const stack<T> &st2){
    size_t size = st1.size();
    if(st2.size() > size)
        size = st2.size();
    return size;
} 

Ya sé que en este caso podría hacerse sin tanta función ni <template> pero es posible hacerlo así definiendo dos <template> distintos??

Lo único que los dos primeros condicionales son el mismo...   
Me he dado cuenta después y aunque lo he añadido al mensaje anterior igual lo he puesto demasiado tarde

Para dejar de verificar condiciones lo que se suele hacer es incluir que <igual> sea <true> en cada <if>.

bool iguales(punto_geografico p, punto_geografico q){
	bool igual=true;
	if(igual && (p.latitud.direccion!=q.latitud.direccion || p.longitud.direccion!=q.longitud.direccion))
		igual=false;
	if(igual && (p.latitud.direccion!=q.latitud.direccion || p.longitud.direccion!=q.longitud.direccion))
		igual=false;
	// asi con todos
	return igual;
} 

Sin embargo esto se hace más cuando en vez de <if> tienes un <while> o un <for>. Para un <if> es mejor usando <else>. Así en cuanto se cumpla un <if> el resto se los va a saltar.

bool iguales(punto_geografico p, punto_geografico q){
	bool igual=true;
	if(p.latitud.direccion!=q.latitud.direccion || p.longitud.direccion!=q.longitud.direccion)
		igual=false;
	else if(p.latitud.direccion!=q.latitud.direccion || p.longitud.direccion!=q.longitud.direccion)
		igual=false;
        else if(p.latitud.grados!=q.latitud.grados || p.longitud.grados!=q.longitud.grados)
                igual=false;
	// asi con todos
	return igual;
} 

Y otra opcion es asignar cada condición dentro de cada <if> a la propia variable <igual> ya que es booleana. En este caso tendrías que hacerlo negándolas, algo así:

bool iguales(punto_geografico p, punto_geografico q){
	bool igual=true;
	if(igual)
		igual= !(p.latitud.direccion!=q.latitud.direccion || p.longitud.direccion!=q.longitud.direccion)
        if(igual)
		igual= !(p.latitud.direccion!=q.latitud.direccion || p.longitud.direccion!=q.longitud.direccion)
        if(igual)
                igual= !(p.latitud.grados!=q.latitud.grados || p.longitud.grados!=q.longitud.grados)
	// asi con todos
	return igual;
} 

Un poco raro pero se puede hacer. Puedes elegir la que mejor veas.
PD: Me acabo de dar cuenta de que los dos primeros condicionales son el mismo.

Hay varios problemas:
- Cuando indicas grado 3, tienes que meter los coeficientes {0,1,2,3}, es decir, 4 coeficientes.

for(int i = 0; i < 3; i++) 

Ese bucle se repite 3 veces, no 4. Te faltaría añadir el igual en la comparación, es decir, "i <= 3".
- Cuando introduces coeficientes, introduces el primero y lo guardas. Pero el <while> va en el siguiente orden: primero cambias coeficiente, después pides coeficiente. Entonces el último que ingreses no se va a guardar.
- En el método de sumar tienes que crear un polinomio nuevo de tamaño igual al mayor de los dos polinomios que sumas. En tu método, modificas el primero y la suma solo se hace hasta el grado más alto del primer polinomio, si el segundo es mayor, se pierden esos coeficientes. Debes retornar el nuevo polinomio que has creado que es donde has ido almacenando la suma.

No he mirado más código. Personalmente creo que es mejor guardarlo al revés. En la posición 0, el coeficiente de grado 0, en la posición 1, el coeficiente de grado 1, etc... Es más fácil de imaginar y si quieres añadir un grado más grande, puedes hacerlo sin mover todos los elementos que ya tienes dentro.
Para mostrar un polinomio añade el signo si el coeficiente es negativo, nada y si es positivo añade un "+". Es muy complicado ver bien el polinomio cuando se muestra, si de momento no quieres gastar tiempo en eso añade al menos un espacio entre monomios. Suerte

Si tienes que buscar el mayor de un array de enteros, es simple:

int BuscaMayor(int *array, int size){
    int mayor = array[0];
    for(int i = 1; i < size; i++)
        if(array[i] > mayor)
            mayor = array[i]
    return mayor;
} 

Pero esto es porque para saber si un número es mayor que otro basta con el operador ">". Sin embargo cuando comparas estructuras tú decides que campo indica que objeto es mayor que otro. Entonces ya no sirve usar el operador ">", tienes que usar una función que haga lo mismo que ese operador, es decir, que de dos objetos te diga cual es mayor.
Imagina un stuct de persona, con nombre y edad:

struct Persona{
    string nombre;
    int edad;
    int dni;
}; 

Nosotros decidimos cuando una persona es mayor que otra, lo más lógico es con la edad, entonces hacemos una función que reciba dos personas y devuelva un entero positivo (1) si el primero es mayor, un entero negativo (-1) si el primero es menor y un 0 si son iguales...

int compararPorEdad(Persona p1, Persona p2){
    int comparacion = 0;
    if(p1.edad > p2.edad)
        comparacion = 1;
    else if(p1.edad < p2.edad)
        comparacion = -1;
    return comparacion;
} 

Entonces ahora para buscar el mayor de un array de personas sería algo así:

Persona mayorPersona(Persona *personas, int size){
    Persona mayor = personas[0];
    for(int i = 1; i < size; i++)
        if(compararPersonas(personas[i], mayor) == 1)
            mayor = personas[i];
    return mayor;
} 

Aquí en vez de usar el operador ">" hemos tenido que usar la función que hemos creado porque si usas el operador ">" con dos estructuras, el programa no sabe cual es mayor (a no ser que sobrecargues ese operador, que eso lo estudiarás más adelante).

Entonces si tienes más de un criterio de ordenación, por ejemplo quieres que el mayor sea e que tiene el DNI más alto. Entonces tendrías una función como <int compararPorEdad(Persona p1, Persona p2)> pero que será <int compararPorDni(Persona p1, Persona p2)>.

El objetivo es que puedas usar la función <Persona personaMayor(Persona *personas, int size)> con el criterio que quieras. Entonces ese criterio lo pasas como tercer parámetro, pasas la función que compara.

Persona personaMayor(Persona *personas, int size, int (*comparacion)(Persona p1, Persona p2)); 

Y usas la función <int comparacion(Persona p1, Persona p2)> para comparar cada dos personas del array. Suerte

El código entre etiquetas GeSHi. Se seleccionan encima del cuadro de texto que aparece cuando escribes un mensaje, donde pone "Código GeSHi".
Después igual podemos ayudarte...