Ejercicios del Tema 1:

Anlisis de algoritmos. Eficiencia. Ordenacin

Profesores de IIP y PRG - Curso 2010/11
Departamento de Sistemas Informticos y Computacin
Universidad Politcnica de Valencia

1. Considrese dos algoritmos A y B que resuelven el mismo problema y cuyos costes respectivos son
1000n y n2 (en unidades de tiempo), dnde n es el tamao del problema. Para qu valores de n es
preferible cada uno de los algoritmos anteriores?.
2. Los algoritmos con coste exponencial son impracticables, y este hecho es independiente de los avances
tecnolgicos. Supngase que en un determinado sistema, para un algoritmo de coste (k n ) los tiempos
de ejecucin son aceptables hasta una cierta talla m. Demustrese que si la velocidad del procesador
mejora en un factor c, en el mismo tiempo que antes se resolva el problema para talla m, se resuelve
ahora para una talla m + logk (c), y que la mejora es por tanto despreciable.
3. Se sabe que cierto algoritmo tiene un coste temporal cuadrtico T (n) = k n2 . Ante una talla del
problema n igual a 1000 el algoritmo tarda 3,3 segundos en ejecutarse sobre un sistema determinado.
Cunto tardar en ejecutarse dicho algoritmo, de forma aproximada, para una talla del problema
n = 10000 (esto es, 10 veces mayor)?
4. Dado el siguiente algoritmo de bsqueda, cuyo propsito es buscar un elemento x en un array ordenado.
Supngase un array de tipo int, a={1,2,3,...,n}, cuyas componentes son los sucesivos enteros desde
1 hasta n.
int i=0;
while( i < a.length

&&

a[i] < x ) i++;

if ( i == a.length )
System.out.println( "El elemento no est." );
else if ( a[i] > x )
System.out.println( "El elemento no est." );
else /* a[i] == x */
System.out.println( "El elemento est en " + i );
Completa en la siguiente tabla el nmero de iteraciones que realizar el bucle segn el valor de x a
buscar:
x = -7

x = 10

x = n+25

Cules son el caso mejor y el caso peor de este algoritmo, y sus cotas de complejidad?

5. Dados dos algoritmos, A1 y A2, que resuelven el mismo tipo de problema y cuyas funciones de coste
temporal son:
TA1 (n) = k1 n2 k2 n + k3

TA2 (n) = k4 n2 + k5 n k6

respectivamente.

Indica, considerando todas las constantes k 1:

a) su comportamiento asinttico:
TA1 (n) (

TA2 (n) (

b) y cul es preferible en trminos asintticos.

6. Estudiar el siguiente algoritmo:
static int[] subvector2maximos(int[] v){
int[] w = new int[2];
if (v[0]>v[1]) { w[0]=v[0]; w[1]=v[1]; }
else { w[0]=v[1]; w[1]=v[0]; }
for(int i=2; i<v.length; i++)
if ( v[i]>w[0] ) { w[1]=w[0]; w[0]=v[i]; }
else if ( v[i]>w[1] ) w[1]=v[i];
return w;
}
a) Determinar nmero de operaciones ejecutadas, y elegir posibles operaciones bsicas.
b) Realizar su anlisis temporal por casos.
7. El algoritmo siguiente encuentra la posicin del elemento ms pequeo en un vector de n enteros
(n 1):
static int posMinimo(int v[]){
int pos, min;
pos=0;
min=v[pos];
for(int i=1; i<n; i++)
if (v[i]<min) { pos=i; min=v[pos]; }
return pos;
}
a) De qu va a depender el coste temporal de la funcin posMinimo?. Y por lo tanto, cul es el
tamao del problema?.
b) Existen instancias significativas?
c) Cul podra ser la instruccin crtica en este algoritmo?. Cuntas veces se repite?.
d ) Cul es la complejidad temporal de posMinimo expresada en trminos del nmero de veces que
se repite la instruccin crtica?. Cul es la complejidad asinttica de la funcin?.
8. Estdiese la complejidad asinttica de los algoritmos iterativos obtenidos de la implementacin directa
(sin mejoras especiales) de las definiciones de las siguientes operaciones:
a) Producto escalar de dos vectores de dimensin n.
b) Suma de dos matrices cuadradas de dimensin n n.
c) Producto de matrices cuadradas de dimensin n n.

9. El siguiente algoritmo calcula la suma de las componentes de un array de n naturales (n 1):

static int suma(int v[]){
int s=0;
for(int i=0; i<n; i++)
for(int j=0; j<v[i]; j++)
s++;
return s;
}
a) Se puede considerar como instruccin crtica de esta funcin la instruccin ms interna de los dos
bucles s++?. Por qu?.
b) Cul es la instruccin crtica para este algoritmo?.
c) Cul es el coste de este algoritmo en trminos del nmero de veces que se repite la instruccin
crtica?. Cul es su complejidad asinttica?.
10. Considrese los dos algoritmos siguientes:
Algoritmo 1
for(int i=0; i<n; i++){
w[i]=0;
for(int j=0; j<=i; j++)
w[i]+=v[j];
}
Algoritmo 2
w[0]=v[0];
for(int i=1; i<n; i++)
w[i]=w[i-a]+v[i];
a) Qu hacen estos dos algoritmos?.
b) Calclese al complejidad asinttica de estos dos algoritmos.
c) A qu se debe que las complejidades obtenidas no coincidan?.
11. Dado el siguiente algoritmo:
int n = ...;
while(n>0 && (n%10)!=0) n=n/10;
Se pide:
a) Identificar cules de los siguientes valores de n corresponden al caso mejor y al caso peor del
algoritmo, en cuanto a su comportamiento temporal:
1)
2)
3)
4)
5)

3568990
9999990
3256796
1453121
2401234

b) Cul o cules de las siguientes opciones expresan el coste del algoritmo en el caso peor?
1) (n)
2) (logn)
3) (m) siendo m el nmero de cifras de n

12. Dado el siguiente procedimiento:

static int cifras(int v[], int m){
int i=0, q=m;
while(q>0){
i++;
v[i]=q%10;
q=q/10;
}
return i;
}
a) Estmese su coste temporal si se toma como talla el valor de m.
b) Estmese su coste temporal si se decide tomar como talla el nmero de cifras de m.
c) Hay alguna contradiccin entre los resultados de los dos apartados anteriores?. Raznese la
respuesta.
13. Disea una funcin iterativa que encuentre el k-simo elemento ms pequeo de un array de n enteros.
Calcula la complejidad temporal del algoritmo diseado.
14. Sobre un array de n enteros, n 1, ordenado de forma creciente, se definen las siguientes funciones:
frec(x,v,i,j): devuelve el no veces que aparece el valor x en el subarray v[i..j].
moda(v,i,j): devuelve el valor que aparece ms veces en el subarray v[i..j], es decir, aquel x
cuya frec(x,v,i,j) sea mxima. Si existen varios valores con frecuencia mxima, cualquiera de
ellos es la moda.
Se debe disear un procedimiento que dado v, escriba por pantalla la moda de ese array y su frecuencia.
Para ello, se recorrer secuencialmente el array, usando unas variables que llamaremos i, x, f y fu, tales
que:
i marca el elemento que se est revisando, y fu es su frecuencia.
x servir para recordar la moda de los elementos ya revisados y f ser la frecuencia de x en ese
subarray.
En el algoritmo slo se podr acceder una vez a cada elemento de v. Analcese la complejidad de dicho
algoritmo.
15. Dado un array de enteros v, ordenado de forma creciente, disear un algoritmo iterativo de coste
O(logn), para determinar si existe algn elemento que coincida con su ndice; es decir, si existe algn
ndice i, con i entre 0 y n 1, tal que v[i] = i.
16. Estdiese la complejidad temporal del siguiente algoritmo recursivo:
// i>=0
static int maximo(int v[], int i){
if (i==0) return v[i];
else {
int m=maximo(v,i-1);
if (m<v[i]) return m;
else return v[i];
}
}
Supngase que v es un vector creado con n enteros, y la llamada a la funcin se realiza como
maximo(v,n-1).

17. Dada la siguiente funcin recursiva:

// 0<=i<=j
static int suma(int v[], int i, int j){
if (i==j) return v[i];
else {
int m=(i+j)/2;
return suma(v,i,m)+suma(v,m+1,j);
}
}
Estdiese la complejidad temporal de esta funcin.
18. Dada la siguiente funcin recursiva:
/* 0<=ini<=fin<=v.length-1 o ini>fin */
static boolean capicua(String v[], int ini, int fin) {
if (ini>=fin) return true;
else if (v[ini].equals(v[fin]))
return capicua(v, ini+1, fin-1);
else return false;
}
La llamada inicial a la funcin es capicua(v,0,v.length-1). Estdiese la complejidad temporal de
esta funcin.
19. Dada la siguiente funcin recursiva:
// 0<a y 0<=b
static int potencia(int a, int b){
if (b==0) return 1;
else if (b==1) return a;
else if (b%2==0) return potencia(a,b/2)*potencia(a,b/2);
else return potencia(a,b/2)*potencia(a,b/2)*a;
}
a) Estdiese la complejidad temporal de esta funcin.
b) La funcin admite una mejora obvia. En qu afecta al coste esta posible modificacin?.
20. Estdiese la complejidad temporal del siguiente algoritmo recursivo:
static void hanoi(int n, String origen, String destino, String auxiliar){
if (n==1) moverDisco(origen,destino);
else {
// Mover n-1 discos de "origen" a "auxiliar"
// torre auxiliar es "destino"
hanoi(n-1,origen,auxiliar,destino);
// Mover el ltimo disco de "origen" a "destino"
moverDisco(origen,destino);
// Mover n-1 discos de "auxiliar" a "destino"
// torre auxiliar es "origen"
hanoi(n-1,auxiliar,destino,origen);
}
}