Departamento de Ingeniera Informtica y Ciencias de la Computacin

Facultad de Ingeniera
Universidad de Concepcin

Asignatura: Anlisis de algoritmos

Tarea 1

Integrantes:
Pablo Flores Torres
Matas Lermanda Sandoval
Profesora:
Mara Andrea Rodrguez Tastets
Ayudante:
Erick Elejalde Sierra
Fecha:
20 de Abril de 2015

1. Considere el siguiente algoritmo donde la entrada es una matriz de

n x (n + 1) de nmeros reales.

for i = 0 to n-1 do
for j = i + 1 to n- 1 do
for k = i to n do
A[j, k]
<- A[j, k] - A[I, k] *A[j, i]/A[I, i]

Indique qu hace el algoritmo y demuestre que hace lo que Usted dice.

El algoritmo recibe una matriz nxn+1 en la cual realiza un conjunto de operaciones

matemticas que dan como resultado cambiar una cantidad j de nmeros por ceros que sean
igual al nmero de fila que corresponda. En la fila en donde i=0, no se cambia ningn
numero por ceros, en la fila donde i=1, el primer numero de la fila se cambia por un cero,
en la fila en donde i=2, se cambian los primeros dos nmeros de la fila por ceros y as
sucesivamente en todas las filas.

public class matriz {

public static void main(String[] args) {
int matriz[][] = new int[3][4]; // Creamos una matriz de 3x4 como ejemplo
int i, j, k, n = 3;
// Inicializamos los valores de la matriz
matriz[0][0] = 2;
matriz[0][1] = 4;
matriz[0][2] = 4;
matriz[0][3] = 7;
matriz[1][0]
matriz[1][1]
matriz[1][2]
matriz[1][3]

=
=
=
=

6;
6;
9;
13;

matriz[2][0]
matriz[2][1]
matriz[2][2]
matriz[2][3]

=
=
=
=

8;
10;
12;
33;

// Recorremos la matriz para verificar su configuracin inicial

for (int x = 0; x < matriz.length; x++) {
for (int y = 0; y < matriz[x].length; y++) {
System.out.print(matriz[x][y]);
}
System.out.println();
}
//proceso sealado en la tarea
for (i = 0; i <= n - 1; i++) {
for (j = i + 1; j <= n - 1; j++) {
for (k = i; k <= n; k++) {
matriz[j][k] = matriz[j][k] - matriz[i][k] * matriz[j][i] / matriz[i][i];
}
}
}
System.out.println("************");
for (int x = 0; x < matriz.length; x++) {
for (int y = 0; y < matriz[x].length; y++) {
System.out.print(" " + matriz[x][y]);
}
System.out.println();
}
}
}

Derive la complejidad del algoritmo.

Desarrollando cada for y la cantidad de veces en que se realiza cada uno podemos llegar a
la siguiente sumatoria:
S=

4*n(n-i+1)(n-i)

Extendiendo esta sumatoria se tiene:

i=0 -> 4n3 + 4n2
i=1-> 4n3 - 4n2
i=2-> 4n3 -12n2 +8n
.
.
.
i=n-1-> 8n
Por lo cual el trmino dominante es n3 y por lo tanto nuestra sumatoria S esta acotada de la
siguiente forma:
S cn3

con c R, n0 n

Lo que nos indica que en notacin Big-O la complejidad de este algoritmo es O(n3).

Existe alguna mejora posible al algoritmo?

Para mejorar el algoritmo cambiamos la funcin Enigma por el siguiente cdigo:
for (i = 1; i <= n -1; i++) {
for (j = 0; j <= i ; j++) {
matriz[i][j]=0;
}
}

Al analizar este cdigo y ver que es mejor, usamos su complejidad para demostrarlo, la cual
est representada a travs de la siguiente sumatoria:
S=

(n-1)*i

Extendiendo esta sumatoria se tiene:

i=1-> n-1
i=2-> 2n-2
i=3-> 3n-3
.
.
.
i=n-1-> n2 -2n + 1

Por lo cual el trmino dominante es n2 y por lo tanto nuestra sumatoria S esta acotada de la
siguiente forma:
S cn2

con c R, n0 n

Lo que nos indica que en notacin Big-O la complejidad de este algoritmo es O(n2). Siendo
mejor que el anterior algoritmo que tenia complejidad O(n3).

A continuacin se muestra el cdigo para que pueda ser probado y comprobar que realiza lo
mismo que el cdigo original.
public class matriz {
public static void main(String[] args) {
int matriz[][] = new int[3][4]; // Creamos una matriz de 3x4 como ejemplo
int i, j, k, n = 3;
// Inicializamos los valores de la matriz
matriz[0][0] = 2;
matriz[0][1] = 4;
matriz[0][2] = 4;
matriz[0][3] = 7;
matriz[1][0] = 6;
matriz[1][1] = 6;
matriz[1][2] = 9;
matriz[1][3] = 13;
matriz[2][0] = 8;
matriz[2][1] = 10;
matriz[2][2] = 12;
matriz[2][3] = 33;
// Recorremos la matriz para verificar su configuracin inicial
for (int x = 0; x < matriz.length; x++) {
for (int y = 0; y < matriz[x].length; y++) {
System.out.print(matriz[x][y]);
}
System.out.println();
}
//proceso mejorado
for (i = 1; i <= n -1; i++) {
for (j = 0; j <= i ; j++) {
matriz[i][j]=0;
}
}
System.out.println("************");
for (int x = 0; x < matriz.length; x++) {
for (int y = 0; y < matriz[x].length; y++) {
System.out.print(" " + matriz[x][y]);
}
System.out.println();
}
}
}

2. Quickselect es el siguiente algoritmo simple para encontrar el k-esimo

elemento ms pequeo en un conjunto desordenado S.
QuickSelect(S; k)
Tome un elemento pivote p aleatoriamento de
Comparando p a cada uno de los elementos de
S1 = {x S : x < p} and S2 = {x S : x
if jS1j = k - 1 then return p
if jS1j > k - 1 then return QuickSelect(S1;
if jS1j < k - 1 then return QuickSelect(S2;

S
S, divide S en dos partes:
> p}
k)
k -|S1|- 1)

Determine el nmero esperado de comparaciones hechas por el QuickSelect en el

conjunto S de tamao n. Puede asumir que inicialmente k = n/2, el cual es el peor caso.

Primero que todo, por simplicidad suponemos que los nmeros del conjunto S no se repiten
y adems k |S| para conservar la correctitud del algoritmo de bsqueda.
Definimos nuestra variable aleatoria.
- X: nmero de iteraciones que realiza el algoritmo.
En donde xi seala la i-sima iteracin.
Por lo tanto nuestra ecuacin para determinar la esperanza queda de la siquiente forma:
E[X] = E[ xi] =

Expandiendo la sumatoria descrita anteriormente tenemos:

=

.
.
.

Probabilidad de encontrar
el k-simo elemento en la
iteracin n

Probabilidad de no haber
encontrado el elemento
anteriormente

En donde el Si es el conjunto no seleccionado en la i-sima iteracin.

Al hacer los supuestos expuestos anteriormente y expandir la sumatoria nos damos cuenta
que es un caso muy complejo de analizar, por lo cual realizamos este intento por simplificar
el estudio del caso de las comparaciones y llegamos a buscar en internet si alguien ms
haba solucionado esta incgnita y nos encontramos con el estudio del matemtico y
experto en ciencias de la computacin Donald Knuth (1971) que demostr que Ckn ,el
nmero medio de comparaciones necesarias para seleccionar el k-simo de entre n es:
Ckn = 2((n + 1)Hn - (n + 3 - j)Hn+1-k - (j + 2)Hk + n + 3)
El valor mximo se alcanza para k = n/2; entonces:
Ckn = 2(ln 2 + 1)n + O(n).
Lo que nos indica que el valor esperado de comparaciones para el k-simo elemento es
O(n)