Enfoque+Divide+y+Vencerás

=Introducción=

El nombre de este enfoque hace referencia a la brillante estrategia empleada por el emperador francés Napoleón, en la batalla de Austerlitz el 2 de Diciembre de 1805. Un ejército combinado de Austriacos y Rusos superaban en número al ejército de Napoleón por 15,000 soldados. El ejército Austro-Ruso lanzó un ataque masivo en contra del flanco derecho francés. Anticipando sus ataques, Napoleón condujo a su ejército al centro del ejército Austro-Ruso y dividió las fuerzas en dos. Ya que los dos ejércitos pequeños no representaron problemas para Napoléon, cada uno de ellos sufrío algunas pérdidas y fueron obligados a retirarse.

Dividiendo al gran ejército en dos ejércitos más pequeños y conquistando cada uno de ellos de forma individual, Napoleón fue capaz de conquistar (derrotar) al gran ejército.
El enfoque divide y vencerás aplica la misma estrategia sobre un problema. Esto es, dividive el problema en dos subproblemas. Si la solución de los subproblemas se puede obtener de forma directa, la solución al problema original puede obtenerse mediante la combinación de las soluciones. Si los subproblemas siguen siendo demasiado grandes para ser resueltos de una forma directa, estos pueden a su vez ser dividos en subsubproblemas. Este proceso de dividir en subproblemas continua de forma recursiva hasta que el subproblema sea lo suficientemente pequeño para ser resuelto de forma directa.

El enfoque divide y vencerás es un enfoque **top-down**. Es decir, la solución a de un nivel superior (top-level) se obtiene yendo más abajo y obteniendo la solución de los subproblemas.

Por la naturaleza del enfoque, es fácil escribir la soluciones de forma recursiva (manipulación del stack). Después de esto, algunas veces se puede crear una versión iterativa eficiente del algoritmo.

=La Búsqueda Binaria= Ejemplifica el enfoque top-down de los algoritmos divide y vencerás

El algoritmo localiza una clave x en un arreglo ordenado (de forma creciente), comparando x con el elemento medio del arregol. Si son iguales, el algoritmo termina. Si no, el arreglo se divide en dos subarreglos, uno que contiene todos los elementos de la izquierda y el otro con todos los elementos de la derecha. Si x es más pequeño que el elemento medio, se procede a buscar en el subarreglo izquierdo. De otra forma se busca sobre el subarreglo derecho. Este procedimiento sse repite hasta que x sea encontrada o que se determine que x no está en el arreglo.

En resumen.

Si x es igual al elemento medio, termina. Si no:
 * 1) **Dividir** el arreglo en dos subarreglos por la mitad. Si x es más pequeño que el elemento medio, elegimos el subarreglo izquierdo. Si x es mayor que el elemento medio, escogemos el subarreglo derecho.
 * 2) **Conquistar** (solucionar) el subarreglo determinando si x está en el subarreglo. A menos que el subarreglo sea lo suficiente pequeño, aplicar la recursión para lograrlo.
 * 3) **Obtener** la solución del arreglo a partir de la solución de los subarreglos.

La búsqueda binaria es el tipo de algoritmo divide y vencerás más simple ya que el tipo de recursión que se aplica es simple, es decir, solo se realiza una llamada recursiva para cada caso recursivo. Así que no existe una función combinación para las salidas.

La solución al problema original es simplemente la solución al subproblema más pequeño.
Pasos realizados por un humano usando la búsqueda binaria (x=18).

Versión recursiva de la búsqueda binaria code format="cpp" //PROBLEMA: determinar si x está en un arreglo de enteros //ordenados de forma ascendente con un tamaño n //ENTRADA: un entero positivo n, un arreglo ordenado de //elementos clave indexados de 0 a n-1, una clave x. //SALIDA: la posición de x en el arreglo (-1 si no está en S) int Arreglo[]={1,2,3,4,5,6,7,8,9,10}; //Nota: Arreglo se declara de forma global int busqueda_binaria(int x, int a,int b){ int medio; if (a > b)       return -1; else{ medio = (a+b)/2; if (x==Arreglo[medio]) return medio; else if (x < Arreglo[medio]) return busqueda_binaria(x,a,medio-1); else //x > Arreglo[medio] return busqueda_binaria(x,medio+1,b); } }
 * 1) include

main{ int n=10,pos; //10 elementos for (int i=0; i<=10;i++) if ((pos=busqueda_binaria(i,0,n))!=-1) printf ("%2d está en la posición %2d del arreglo.\n",i,pos); else printf ("%2d no está en el arreglo.\n",i); } code fuente: **Foundations of Algorithms Using C++ Pseudocode**, Third Edition by Richard Neapolitan and Kumarss Naimipour