Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Codigo de Huffman
Codigo de Huffman
Frecuencia
( en miles )
a
45
b
13
c
12
d
16
e
9
f
5
0
1
a:45
b:13
58
0
100
28
c:12
d:16
14
e:9
14
1
f:5
a:45
55
25
0
c:12
30
0
1
b:13
0
f:5
14
d:16
1
e:9
Algoritmo Greedy
Huffman invent un algoritmo voraz que construye
una codificacin prefijo ptima.
Construye un rbol binario de cdigos de
longitud variable de manera ascendente de
modo que [MIN] B(T).
Ejemplo de funcionamiento
Fase 1. : Caracteres colocados en orden creciente de
frecuencia.
f:5
e:9
c:12
b:13
d:16
a:45
c:12
14
b:13
0
e:9
d:16
14
e:9
c:12
25
0
c:12
a:45
25
f:5
a:45
f:5
d:16
1
b:13
30
1
b:13
14
0
f:5
a:45
1
d:16
1
e:9
a:45
55
1
30
25
0
c:12
b:13
14
0
d:16
1
f:5
0 100
e:9
a:45
55
25
0
c:12
30
1
b:13
bb:1
0
3
f:5
1
d:16
14
1
e:9
n := C ;
CO:= ordenar_crec_por_frec(C) ;
/* se ordena crecientemente por frecuencia el
conjunto de caracteres de la entrada */
Q := Insertar_todos (CO);
/* la cola contiene todos los elementos */
Para i=1 hasta n-1 hacer
z:= crear_objeto();
/* eleccin de los candidatos */
x := izq(z) := primero(Q); Q:= avanzar(Q);
y:= der(z) := primero(Q); Q:= avanzar(Q);
frec[z] := frec[x] + frec[y];
/* actualizar solucin */
Q:= insertar_ordenado ( Q, z);
fpara
{ Post : Q contiene un nico elemento que es un
rbol de codificacin de prefijo ptimo }
dev ( primero(Q))
ffuncin
7
rbol T
b
y
x
cC
= f[x].dT(x) + f[b].dT(b)
f[x].dT(x) f[b].dT(b) =
= f[x].dT(x) + f[b].dT(b)
rbol T
b
c
x
10
11
CAMINOS MINIMOS
Shortest-paths problem
Definiciones
Sea G=(V,E) un grafo dirigido y etiquetado con valores
naturales.
Se define el peso del camino p, con p=<v0,v1,v2, ...,vk>,
como la suma de los valores de las aristas que lo
componen.
k
peso(p) =
valor(G,v
i-1
,vi)
i=1
Se define el camino de peso mnimo del vrtice u al v
en G, con u,v V, con la siguiente funcin :
MIN{ peso(p) : u v }
si hay camino de u a v
(u,v) =
en otro caso
El camino ms corto, camino mnimo, de u a v en G, se
define como cualquier camino p tal que peso(p) =
(u,v).
Los problemas de caminos mnimos
1/ Single_source shortest_paths problem :
12
D[v_ini]:= 0;
VISTOS := aadir( conjunto_vacio, v_ini );
{ Inv : u : u V VISTOS: D[u] contiene la longitud
del camino ms corto desde v_ini a u que no sale de
VISTOS, es decir, el camino est formado por v_ini y
una serie de vrtices todos ellos pertenecientes a
VISTOS excepto el propio u.
u : u VISTOS: D[u] contiene la longitud del
camino ms corto desde v_ini a u }
*[ |VISTOS| < |V| --->
u := MINIMO( D, uVVISTOS );
/* el candidato es el vrtice uV-VISTOS que
tiene D mnima */
VISTOS := VISTOS {u};
Para cada v suc(g,u) t.q. v VVISTOS hacer
/* Ajustar D : Recalcular los valores para
aplicar la funcin de seleccin sobre los
candidatos que quedan */
[ D[v] > D[u] + valor( g,u,v ) --->
D[v] := D[u] + valor( g,u,v );
[] D[v] D[u] + valor ( g,u,v ) ---> seguir
]
fpara;
]
{ Post : u : uV: D[u] contiene la longitud del
camino ms corto desde v_ini a u que no sale de
VISTOS, y como VISTOS ya contiene todos los vrtices,
se tienen en D las distancias mnimas definitivas }
14
dev ( D )
ffuncin
Coste
Grafo implementado en matriz (n2):
El bucle que inicializa el vector D cuesta (n).
El bucle principal efecta n-1 iteraciones.
Coste de cada iteracin : la obtencin del mnimo,
coste lineal, y el ajuste de D que tambin es (n).
Grafo implementado con listas + Heap de mnimos
((n+|E|).log n) :
La construccin del Heap (n.log n),
Seleccionar el mnimo cuesta (1),
Cada operacin de ajuste requerir (log n).
En total se efectuan (|E) operaciones de ajustar D.
Demostracin:
Sea u un vrtice tal que uVVISTOS.
Supongamos que D[u] contiene informacin cierta, es
decir, contiene la distancia mnima entre el vrtice
inicial y u siguiendo por un camino que slo contiene
vrtices que pertenecen a VISTOS.
Si u es el vrtice con el valor de D ms pequeo, el
criterio de seleccin lo elegir como candidato e
inmediatamente pasar a formar parte de VISTOS y
15
1 1
1
1
2
2
2
6
4
1
5
0
0
0
0
1
2
2
2
2
5
3
3
3
2
2
2
3
3
VISTOS
{0}
{0,1}
{0,1,3}
16
0
0
0
2
2
2
3
3
3
2
2
2
3
3
3
5
4
4
{0,1,3,2}
{0,1,3,2,4}
{0,1,3, 2,4,5}
]
{ Post : La misma de Dijkstra y u : uV: CAMINO[u]
contiene el otro vrtice de la ltima arista del camino
mnimo de v_ini a u}
dev ( D, CAMINO )
ffuncin
En segundo lugar utilizar un procedimiento recursivo,
RECONSTRUIR, que recibe el vrtice para el cual
se quiere reconstruir el camino, v, y el vector
CAMINO.
funcin RECONSTRUIR ( v, v_ini es vrtice;
CAMINO es vector[1..n] de vrtices )
dev ( s es secuencia_aristas )
[ v = v_ini ---> s := secuencia_vacia;
[] v v_ini --->
u := CAMINO[v];
s := RECONSTRUIR( u,v_ini,CAMINO);
s := concatenar( s, (u, v) );
]
{ Post : s contiene las aristas del camino mnimo desde
v_ini a v }
dev ( s )
ffuncin
18