Prctica 2 MTP

1
Práctica 2 MTP

• Divide y Vencerás
• José Manuel Sánchez Díaz
• jomasadi_at_lycos.es
• http//perso.wanadoo.es/jmsanchezdiaz

2
Enunciado

• Érase una vez un castillo que estaba amenazado
  por un terrible ejercito de enemigos.
• Dicho castillo estaba protegido en su cara norte
  y en su cara oeste por unas montañas imposibles
  de atravesar. Para proteger el castillo del
  ataque de los enemigos el señor del castillo
  ordena a su ejercito que formen un cuadrado tal
  que cada soldado pueda ver al este y al sur sin
  verse entorpecido por sus compañeros.
• Observación un soldado puede ver en una
  dirección si no tiene delante a otro soldado
• más alto que él.

3
Ejemplo para ilustrar la estrategia Divide y
Vencerás

• La primera estrategia que se me ocurrió, dado que
  el enunciado de la práctica que no dice nada
  acerca de la representación de la entrada era
  usar como entrada un vector de N elementos con
  las alturas de los soldados del ejército.
  Simplemente los ordenaba de mayor a menor altura
  usando Mergesort (ordenación que usa estrategia
  Divide y Vencerás) y mi salida consistía en
  rellenar una matriz NN desde dicho vector
  ordenado recorriéndolo una vez. Así siempre se
  consigue configurar la formación adecuadamente.
• Al parecerme una solución trivial, pregunté al
  profesor vía mail, y resultó que la entrada que
  se debe suponer es una matriz con las alturas de
  los soldados

4
Estrategia definitiva implementada ilustrada con
un ejemplo

• Dado el array 88 de alturas de soldados,
  definida por los índices comienzo de fila0, fin
  de fila7, comienzo de columna0, fin de
  columna7
• 1 5 3 4 6 2 5 4
• 5 3 6 4 2 1 2 3
• 5 6 1 2 4 1 4 3
• 3 4 5 3 5 3 5 2
• 7 6 4 3 5 4 3 4
• 6 3 2 5 1 2 4 3
• 6 4 5 7 6 3 5 7
• 6 7 5 7 4 5 7 5
• Nota en el ejemplo los valores reflejan medidas
  cualitativas de alturas de los soldados a menor
  número, más alto. En la implementación opté por
  usar reales para modelar exactamente la altura de
  cada soldado en centímetros(de esta última forma
  la ordenación es de mayor a menor altura, al
  contrario que en el ejemplo).

5

• Calculo el número de casillas que tiene dicho
  array.
• División del problema en subproblemas
• En el caso general(más de 4 casillas) descompongo
  el array en 4 cuadrantes para ello calculo el
  punto medio de filas y columnas, y la
  descomposición para
• el ejemplo deja los siguientes cuatro
  fragmentos
• 1 5 3 4 6 2 5 4
• 5 3 6 4 2 1 2 3
• 5 6 1 2 4 1 4 3
• 3 4 5 3 5 3 5 2
• 7 6 4 3 5 4 3 4
• 6 3 2 5 1 2 4 3
• 6 4 5 7 6 3 5 7
• 6 7 5 7 4 5 7 5

6

• Siguiendo con el ejemplo, para cada fragmento
  seguimos descomponiendo. Concretamente me centro
  en el primer cuadrante que surgió
• 1 5 3 4
• 5 3 6 4
• 5 6 1 2
• 3 4 5 3
• Ahora nos encontramos en un caso base, 4
  casillas. En este caso uso una ordenación por
  método de inserción eficiente para tamaños
  pequeños. Ordeno por filas. El fragmento del
  ejemplo queda
• 1 3 3 4
• 5 5 4 6
• 3 4 1 2
• 5 6 3 4
• Otros 2 casos base posibles es tener 2 casillas
  (ordenación mediante una comparación) o 1
  casilla(ordenación trivial)

7

• Combinación de resultados (carga de trabajo)
• Fusiono los elementos del cuadrante 1 con los del
  cuadrante 2 después de las dos primeras
  subdivisiones.
• Fusiono los elementos del cuadrante 3 con los del
  cuadrante 4 después de las dos últimas
  subdivisiones.
• Fusiono ambas fusiones.
• Todas las fusiones son iguales
• Se crea un array auxilar donde se van guardando
  los elementos ya ordenados, y un array auxiliar
  por cada uno de los cuadrantes.
• Se fijan índices de comienzo de fila y columna
  del array auxiliar del primer cuadrante y de
  comienzo y fin de columna del array auxiliar
  delsegundo cuadrante.
• Se compara un elemento del primer array auxiliar
  con otro del segundo. El que refleje mayor altura
  se inserta en el array auxiliar total y se
  actualizan los índices para acceder al siguiente
  elemento de ese cuadrante.
• Cuando se llega al final de uno de los arrays
  auxiliares de cuadrantes, se rellena la matriz
  auxiliar total con los elementos restantes del
  cuadrante restante.
• Siguiendo con el ejemplo, el primer fragmento
  quedaría fusionado como sigue
• 1 1 2 3
• 3 3 3 4
• 4 4 4 5
• 5 5 6 6

8
Pseudocódigo

• proc FormarEjercito(Formacion array NN de
  real cfila, ffila, ccolum, fcolum entero)
• asumir declaración de las variables internas
  
• numCasillas((ffila-cfila)1)((fcolum-ccolum)
  1)
• casos
• numCasillas1 -gt Ordenación trivial
• numCasillas2 o numCasillas4 -gt
  Ordenar(Formacion,cfila,ffila,ccolum,fcolum,numCas
  illas)
• numCasillasgt4 -gt
• mfila(cfila ffila 1)/2
• mcolum(ccolum fcolum1)/2
• FormarEjercito(Formacion, cfila, mfila-1,
  ccolum, mcolum-1)
• FormarEjercito(Formacion, cfila, mfila-1,
  mcolum, fcolum)
• Fusionar(Formacion, cfila, mfila-1,
  ccolum, mcolum-1, mcolum, fcolum)
• FormarEjercito(Formacion, mfila, ffila,
  ccolum, mcolum-1)

9
Diseño de la clase con diagrama UML
10

• El código fuente en Java (usando JDK
  1.4.2_03-b02) se encuentra adjuntado en este
  mismo fichero zip (ASanchezDiazPrac2.zip), en la
  ruta Practica2/src (La batería de pruebas se
  encuentra en el método main de la clase principal
  Ejercito.java)
• El código compilado se encuentra adjuntado en
  este mismo fichero zip, en la ruta
  Practica2/classes
• El archivo nativo ejecutable se llama
  Practica2.jar y se encuentra en la ruta
  Practica2/
• El archivo ejecutable para la consola de Windows
  se llama Practica2.exe y se encuentra en la
  ruta Practica2/
• La documentación en formato javadoc generada se
  encuentra adjuntada en este mismo fichero zip, en
  la ruta Practica2/doc

11
Complejidad del algoritmo

• Planteo la ecuación de recurrencia para analizar
  el coste en tiempo del algoritmo
• T(n) 1 si n1, 2, 4
• Coste constante por no hacer nada(n1), un
  intercambio como máximo(n2) o coste constante
  por la ordenación por inserción sobre 4
  elementos.
• T(n) 4T(n/4) F(n) si ngt4
• Hago 4 llamadas a FormarEjercito con tamaño (n/4)
  y 2 llamadas a Fusionar con tamaño n/2 más la
  llamada a Fusionar con tamaño n. Coste total de
  las llamadas a Fusionar (lineal con respecto al
  número de elementos) 2n, es decir, coste lineal
  respecto al número de elementos.
• Por el Teorema de la División a4, b4, k1 -gt
  abk -gt T(n) pertenece al orden de nlogn
• Con lo que la complejidad de todo el algoritmo en
  tiempo es O(nlogn)

12
Tiempo de ejecución de la implementación vs.
tiempo teórico

• Tiempos reales tomados de la ejecución del
  algoritmo implementado para tamaños del array
  77, 88, 1616, 2727 y 3232 (N7, N8, N16,
  N27 y N32) en milisegundos.
• La barra de tiempo teórico se calcula dado el N,
  con NlogN.
• Como se puede observar, cuanto mayor es N, mayor
  se aproxima el tiempo real al tiempo teórico
  calculado en el apartado de complejidad. Influye
  el espacio adicional que se usa al crear los
  diferentes arrays auxiliares necesarios.
• Nota las mediciones de tiempo se midieron en un
  equipo con sistema operativo Windows XP SP2,
  procesador Intel Pentium III con frecuencia de
  450 MHz. Es obvio que se pueden producir
  variaciones en las mediciones de tiempos del
  mismo algoritmo sobre diferentes plataformas.

13
Gráfica comparativa
14
Ruegos y Preguntas