Examen de Algoritmos y Estructuras de Datos 3

NOMBRE:...............................................................................................
Examen de Algoritmos y Estructuras de Datos 3
Escuela y Facultad de Informática. 29 de enero de 2004
Duración. 3 horas.
1 (3,4 puntos) Un programa que utiliza la técnica “Divide y vencerás” divide un problema de tamaño n en a subproblemas de tamaño n/b (a, b > 0). El tiempo g(n) de la resolución directa (caso base) se considera constante.
El tiempo f (n) de combinar los resultados es O(n). Para simplificar consideraremos que f (n) = d n y que la talla
del problema es una potencia de b. Obtener la complejidad temporal del algoritmo t(n) en función de los valores a y b.
Nota:
Pn
i=0
ri = (rn+1 − 1)/(r − 1) si r > 1 y
P∞
i=0
ri = 1/(1 − r) si r < 1.
Respuesta
La complejidad temporal del algoritmo sigue la siguiente relación de recurrencia:
(
at( nb ) + dn si n > 1
t(n) =
1,
si n = 1
Resolviendo por sustitución:
t(n)
n
=
at
=
a3 t
r=logb n
=
a
+ dn = a(at
b
n
b3
logb n
+ a2 d
+ dn
n
b2
n
b2
log b n−1 X
i=0
+ ad
+d
n
n
b
b
) + dn = a2 t
n
+ dn = . . . = ar t
+ ad
b2
n
br
logb n−1 X
a i
a i
logb a
=n
+ dn
.
b
b
i=0
Si a < b entonces la suma está acotada por una constante:
logb n−1 X
i=0
∞
1
a i X a i
<
=
b
b
1 − a/b
i=0
por lo que t(n) ∈ O(n).
Si a = b entonces:
logb n−1 X
i=0
por lo que t(n) ∈ O(n log n).
Si a > b entonces:
logb n−1 X
i=0
por lo que t(n) ∈ O(nlogb a ).
a i
= log b n
b
a i (a/b)log b n − 1
b(nlogb a−1 − 1)
=
=
b
a/b − 1
a−b
n
+ dn
+ dn
b
r−1 X
a i
i=0
b
2 (3,3 puntos) En un sistema que almacena información en una tabla de dispersión se debe mantener siempre un
rendimiento mínimo, independientemente de la cantidad de información almacenada. Para ello, cada vez que la
velocidad del sistema se degrada, se amplía dicha tabla y se hace una redispersión. Por medio de experimentos, se ha
llegado a la conclusión de que se debe realizar dicha ampliación cuando:
el factor de carga sea mayor o igual a 0,7, o
más de un 30 % de las cubetas hayan sufrido, al menos, una colisión.
Implementa una función que indique si hay que ampliar la tabla de dipersión o no.
Nota: La definición de la estructura de datos que se utilizará es la siguiente:
typedef struct snode{struct snode *next; info ...;} node;
typedef tabla **node;
Respuesta
...
int cub_real ...
...
int rehashear(tabla taula) {
int i, n;
node *cap;
int ncolisiones, nelementos;
ncolisiones=0;
nelementos=0;
for(i=0;i<cub_real;i++) {
cap = taula[i];
n=0;
while (cap != NULL) {
n++;
cap=cap->seg;
}
if (n>=2) ncolisiones++;
nelementos+=n;
}
return ((double)nelementos/cub_real>=0.7 ||
(double)ncolisiones/cub_real>=0.3);
}
3 (3,3 puntos) Sea G un grafo dirigido y no ponderado con k vértices numerados desde 0 hasta k − 1. El grafo G tiene
estructura de árbol n-ario si cumple las condiciones siguientes:
Existe un único vértice con grado de entrada 0 (denominado raíz del árbol). Dicho vértice tiene índice 0.
Todos los vértices del grafo distintos de la raíz del árbol tienen grado de entrada 1.
Todos los vértices del grafo tienen grado de salida i, con 0 ≤ i ≤ n.
Cualquier vértice j, directamente accesible desde otro i, cumple que j > i.
Se pide: Dado un grafo dirigido G, implementado mediante una matriz de adyacencia, comprobar si cumple las
condiciones para ser un árbol n-ario.
Nota: La definición de la estructura de datos que se utilizará, para la definición de la matriz de adyacencia es la siguiente:
typedef int GrafM[K][K];
Respuesta
// Declaracions preliminars:
#define BOOLEAN int
#define FALSE 0
#define TRUE 1
#include <stdio.h>
typedef int GrafM[K][K];
BOOLEAN esArbreN (GrafM g, int N) {
/* per al càlcul dels graus d’entrada i eixida de cada node */
int grauEnt = 0;
int grauSal = 0;
/* per a comprovar que els adjacents tenen índex major */
BOOLEAN valid = TRUE;
int node = 0;
while (node < K && valid) {
grauEnt = 0;
grauSal = 0;
for (int i=0; i<K && valid; i++) {
if (g[i][node]) {
grauEnt++;
if (i>=node) valid=FALSE;
}
if (g[node][i]) {
grauSal++;
if (i<=node) valid=FALSE;
}
}
valid = valid && (node==0 && grauEnt==0) &&
(node!=0 && grauEnt==1 && grauSal<=N);
node++;
}
return valid;
} // de esArbreN