Tarea 3

CC3001- Algoritmos y Estructura de Datos.

Nombre Alumno : Profesor :

Jaime Aranda Benjamn Bustos Ignacio Reyes 25 Septiembre 2013.

Profesor Auxiliar : Fecha :

NDCE
Contenido
INTRODUCCIN ................................................................................................................................... 2 PARTE I ................................................................................................................................................ 3 Parte II ................................................................................................................................................. 4 CONCLUSIONES ................................................................................................................................... 5 ANEXO ................................................................................................................................................. 6

NTRODUCCON
La programacin dinmica es una tcnica que nos permite resolver de manera eficiente problemas (generalmente de optimizacin) cuya solucin ha sido abordada por otras tcnicas y que han fracasado, para que un problema pueda ser abordado por sta tcnica tiene que cumplir dos condiciones, la primera es que se pueda dividir en subproblemas superpuestos y cada uno de ellos tiene que tener una estructura ptima (es decir para encontrar la solucin al problema mas grande, es necesario encontrar la solucin ptima a los subproblemas). Adems recurrentemente se guardan resultado intermedio (se tabulan) para poder utilizarlos posteriormente. La tarea se basa en la implementacin del algoritmo de programacin dinmica para calcular la mejor parentizacin en una secuencia de multiplicaciones de matrices, analizar empricamente su complejidad temporal, y luego disear e implementar un algoritmo que muestre la secuencia ptima de multiplicaciones. Para esto consta de dos partes, la primera tiene que ver con el anlisis emprico de la complejidad del algoritmo y la segunda con la secuencia ptima de multiplicaciones.

PARTE
Se vio en clases un algoritmo de programacin dinmica implementado en la funcin toma tiempo , en esta parte se debe comprobar si los resultado tericos concuerdan con los experimentales. Para ello cabe recordar que si se tienen dos matrices , la condicin para que se puedan multiplicar (matricialmente) es que debe poseer el mismo nmero de columnas que filas de B, es decir si tiene filas y columnas ( ), tiene que poseer las mismas filas y columnas ( ) y la matriz resultante ( ) tendr filas y columnas ( ).

Tambin cabe mencionar que el nmero de multiplicaciones (escalares) a realizar en la multiplicacin matricial corresponde al nmero de filas de una multiplicado por el nmero de columnas (o filas de la otra matriz) y por el nmero de columnas de la ltima matriz (en el ejemplo anterior tenemos que el nmero de multiplicaciones realizadas es de ). Entonces la funcin, nos entrega el nmero mnimo de multiplicaciones (escalares) que se da en una multiplicacin de cadena de matrices ( ). Para esto se deben generar las dimensiones de las matrices a multiplicar (con el nmero de filas y ] ), por lo que generamos un nmero aleatorio (Random x = new columnas entre [ Random();) y hacemos que est entre los lmites mencionados anteriormente (int a = (x.nextInt(100-2+1)+2);) y luego creamos un vector (p) con los coeficientes de las filas y columnas de la cadena de matrices ( si tenemos n matrices, tenemos que crear un vector de dimensin n+1 para guardar las filas y columnas de todas las matrices multiplicables). Para medir el tiempo que toma la funcin se utiliza System.nanoTime(); que mide el tiempo actual
del reloj del computador, y luego de utilizar la funcin se hace de nuevo, y obtenemos la duracin como la resta de ambos. Esto lo hacemos para secuencias de distintos largos y lo repetimos 10 (o 100) veces para luego sacar un promedio y que los datos sean mas certeros. El tiempo (ns) para 10 repeticiones los datos son los siguientes:

0.0037 0.2692

0.0219 0.3418

0.0471 0.4411

0.0145 0.5310

0.0314 0.6483

0.0540 0.7909

0.0754 0.9304

0.1165 1.0982

0.1896 1.2895

0.2213 1.8417

Suponiendo que tenemos una relacin del estilo aplicando logaritmo nos queda y haciendo polyfit de grado 1 en Matlab nos da el coeficiente b.

Para las datos de la tabla anterior tenemos b=2.0102, lo que es una buena aproximacin considerando la cantidad de repeticiones (10) realizadas.
El tiempo (ns) para 100 repeticiones los datos son los siguientes: 0.0041 0.3036 0.0045 0.4027 0.0075 0.5187 0.0140 0.6899 0.0277 0.8175 0.0506 0.8481 0.1094 0.9326 0.1704 1.1062 0.2437 1.2873 0.3119 1.4948

Con los datos anteriores nos da b=2.3531, como podemos observar nuestra obtencin del valor terica va mejorando cada vez que aumentamos las repeticiones y luego las promediamos.

Parte

CONCLUSONES
Podemos observar que los resultados empricos obtenidos tienden al resultado terico, por lo que podemos decir que ste algoritmo implementado independiente del procesador o cumputador, demorar, es en promedio de Orden cbico ( ). Adems podemos mencionar que los algoritmos de programacin dinmica son bastantes tlies en optimizacin de soluciones, dado un problema.

ANEXO
import java.io.*; import java.util.Random; class Metodos{ static public void main(String[]args) throws IOException { int [] S={5,10,15,20,25,30,35,40,45,50,55,60,65,70,75,80,85,90,95,100};//Largo de la secuencia for(int j=0;j<S.length;j++){ int [] p = new int [S[j]+1]; for (int i =0;i<(S[j]+1);i++){ // generamos las dimensiones de las matrices Random x = new Random(); //creamos un objeto de la clase random int a = (x.nextInt(100-2+1)+2); //hacemos que el nmero aleatorio este entre 2 y 100 ambos incluidos p[i]=a;} int [][] m=new int [p.length][p.length]; int [][] s= new int [p.length][p.length]; long ti; double tt; double [] tp=new double [S.length]; for(int l=0;l<tp.length;l++) tp[l]=0; for (int k = 0;k<100;++k){ ti=System.nanoTime(); int A=multiplicacionCadenaMatrices (p,m,s); tt=(System.nanoTime()-ti); tp[j]=tp[j]+tt;} System.out.println(tp[j]/100);}}

public static int multiplicacionCadenaMatrices( int[] p, int[][] m, int[][] s) { // Matriz Ai tiene dimensiones p[i-1] x p[i] para i = 1..n // El primer indice para p es 0 y el primer indice para m y s es 1 int n = p.length - 1; for (int i = 1; i <= n; i++) { m[i][i] = 0; } for (int l = 2; l <= n; l++) { for (int i = 1; i <= n - l + 1; i++) { int j = i + l - 1; m[i][j] = Integer.MAX_VALUE; for (int k = i; k <= j-1; k++) { int q = m[i][k] + m[k+1][j] + p[i-1]*p[k]*p[j]; if (q < m[i][j])

{ m[i][j] = q; s[i][j] = k; } } } } return m[1][n];}}