CODIGOS DE HUFFMAN
Definición : La codificación de Huffman es una técnica para la compresión de datos, ampliamente usada y muy efectiva
Ejemplo : Fichero con 100.000 caracteres. Se sabe que aparecen 6 caracteres diferentes y la frecuencia de aparición de cada uno de ellos es :
a
b
c
d
e
f
Frecuencia
( en miles )
45
13
12
16
9
5
¿ Cómo codificar los caracteres para comprimir el espacio ocupado utilizando un código binario ?
Solución 1 : Código de longitud fija
Para 6 caracteres se necesitan 3 bits (300000 bits)
Fija
000
001
010
011
100
101
Solución 2 : Código de longitud variable en el que los más frecuentes tienen el código más corto. Restricción : ningún código es prefijo de otro.
( 224000 bits )
Variable
0
101
100
111
1101
1100
Esta técnica de codificación se denomina código prefijo.
Codificación : Basta con concatenar el código de cada uno de los caracteres.
Ejemplo :
aabacd 001010100111 001010100111
Descodificación : Fácil porque ningún código es prefijo de otro código NO hay ambigüedad.
Ejemplo :
101011101111011100 badadcf
¡ Es la única posibilidad !
Un árbol binario es una forma de representar el código prefijo que simplifica el proceso de descodificación :
las hojas son los caracteres,
el camino de la raíz a la hojas con la interpretación 0 a la izquierda y 1 a la derecha nos da el código de cada hoja.
Este sería el árbol binario de la codificación de longitud fija:
Y éste el de la codificación de longitud variable :
Dado T el árbol binario que corresponde a una codificación prefijo, es fácil averiguar el número de bits necesarios para codificar el fichero :
Para cada carácter c diferente del alfabeto C que aparece en el fichero,
sea f(c) la frecuencia de c en la entrada,
sea dT(c)la profundidad de la hoja c en el árbol T, entonces el número de bits requeridos es :
B(T) = f(c) dT(c)
c C
B(T) nos da el coste de T.
Algoritmo Greedy
Huffman inventó un algoritmo voraz que construye una codificación prefijo óptima.
Construye un árbol binario de códigos de longitud variable de manera ascendente de modo que [MIN] B(T).
Ejemplo de funcionamiento
Fase 1. : Caracteres colocados en orden creciente de frecuencia.
Fase 2. y posteriores : Fusionar hasta obtener un sólo árbol manteniendo la ordenación creciente.
Implementación del algoritmo
Se usa una cola de prioridad, Q, con clave la frecuencia lo que permite seleccionar los dos objetos de la cola con la frecuencia más baja.
El resultado de fusionar dos objetos es un nuevo objeto cuya frecuencia es la suma de frecuencias de los dos objetos fusionados.
función COD_HUF ( C es conj_ )
{ Pre : C está bien construido y no es vacio }
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();
/* elección 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 solución */
Q:= insertar_ordenado ( Q, z);
fpara
{ Post : Q contiene un único elemento que es un árbol de codificación de prefijo óptimo }
dev ( primero(Q))
ffunción
Demostración de optimalidad del criterio
Sea T un árbol binario de codificación óptimo.
Sean b y c dos hojas hermanas en T que se encuentran a profundidad máxima.
Sean x e y dos hojas de T tales que son los 2 caracteres del alfabeto C con la frecuencia más baja.
árbol T
Vamos a ver que T, que es un árbol óptimo, se puede transformar en otro árbol T’’, también óptimo, en el que los 2 caracteres, x e y, con la frecuencia más baja serán hojas hermanas que estarán a la máxima profundidad El árbol que genera el algoritmo voraz cumple exactamente esa condición.
Podemos suponer que f[b] f[c] y que f[x] f[y]. Además, se puede deducir que f[x] f[b] y f[y] f[c].
Se puede construir un nuevo árbol, T’, en el que se intercambia la posición que ocupan en T las hojas b y x.
árbol T’
B(T) – B(T’) = f[c].dT(c) – f[c].dT’(c) =
cC 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) –
f[x].dT (b) –f[b].dT (x) =
= ( f[b] – f[x] ) . ( dT(b) – dT (x) ) 0
De forma similar, se construye el árbol T’’ intercambiando c e y.
árbol T’’
Con este intercambio tampoco se incrementa el coste y B(T’) B(T’’) 0.
Por tanto, B(T’’) B(T) y como T es óptimo, entonces T’’ también lo es y B(T’’) = B(T).
Y ya para acabar la demostración :
Sea T un árbol binario que representa un código prefijo óptimo para un alfabeto C. Consideremos 2 hojas hermanas, x e y, de T y sea z el padre de ambas. Consideremos que la frecuencia de z es f[z] = f[x] + f[y].
Entonces, el árbol T’ = T–{x,y} representa un código prefijo óptimo para el alfabeto C’ = C – {x, y} {z}.
Precisamente eso es lo que hace el algoritmo voraz : una vez que ha fusionado los dos caracteres de frecuencia más baja, inserta un nuevo elemento en el alfabeto con su frecuencia y repite el proceso de seleccionar los dos elementos con frecuencia más baja ahora para un alfabeto con un elemento menos.
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=, como la suma de los valores de las aristas que lo componen.
k
peso(p) = valor(G,vi-1,vi)
i=1
Se define el camino de peso mínimo del vértice u al v en G, con u,v V, con la siguiente función :
MIN{ peso(p) : u v }
si hay camino de u a v
(u,v) =
en otro caso
El camino más corto, camino mínimo, de u a v en G, se define como cualquier camino p tal que peso(p) = (u,v).
Los problemas de caminos mínimos
1/ Single_source shortest_paths problem :
Encontrar el camino más corto entre un vértice fijado, source, y todos los vértices restantes del grafo.
2/ Single_destination shortest_paths problem
Encontrar el camino más corto desde todos los vértices a uno fijado, destination.
3/ Single_pair shortest_paths problem : Fijados dos vértices del grafo, source y destination, encontrar el camino más corto entre ellos.
4/ All_pairs shortest_paths problem : Encontrar el camino más corto entre los vértices u y v, para todo par de vértices del grafo.
El algoritmo de Dijkstra (1959)
Resuelve el problema de encontrar el camino más corto entre un vértice dado y todos los restantes del grafo.
función DIJKSTRA ( g es grafo; v_ini es vértice )
dev ( D es vector[1..n] de naturales )
{ Pre : g=(V,E) es un grafo etiquetado con valores naturales dirigido. Se supone que el grafo está implementado en una matriz y que M[i,j] contiene el valor de la arista que va del vértice i al j y, si no hay arista, contiene el valor infinito }
Para cada vV hacer D[v] := M[v_ini, v] fpara;
D[v_ini]:= 0;
VISTOS := añadir( conjunto_vacio, v_ini );
{ Inv : u : u VVISTOS: D[u] contiene la longitud del camino más corto desde v_ini a u que no sale de VISTOS, es decir, el camino está formado por v_ini y una serie de vértices todos ellos pertenecientes a VISTOS excepto el propio u.
u : u VISTOS: D[u] contiene la longitud del camino más corto desde v_ini a u }
*[ |VISTOS| < |V| --->
u := MINIMO( D, uVVISTOS );
/* el candidato es el vértice uV-VISTOS que tiene D mínima */
VISTOS := VISTOS {u};
Para cada v suc(g,u) t.q. v VVISTOS hacer
/* Ajustar D : Recalcular los valores para aplicar la función de selección 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 más corto desde v_ini a u que no sale de VISTOS, y como VISTOS ya contiene todos los vértices, se tienen en D las distancias mínimas definitivas }
dev ( D )
ffunción
Coste
Grafo implementado en matriz (n2):
El bucle que inicializa el vector D cuesta (n).
El bucle principal efectúa n-1 iteraciones.
Coste de cada iteración : la obtención del mínimo, coste lineal, y el ajuste de D que también es (n).
Grafo implementado con listas + Heap de mínimos ((n+|E|).log n) :
La construcción del Heap (n.log n),
Seleccionar el mínimo cuesta (1),
Cada operación de ajuste requerirá (log n).
En total se efectuan (|E) operaciones de ajustar D.
Demostración:
Sea u un vértice tal que uVVISTOS.
Supongamos que D[u] contiene información cierta, es decir, contiene la distancia mínima entre el vértice inicial y u siguiendo por un camino que sólo contiene vértices que pertenecen a VISTOS.
Si u es el vértice con el valor de D más pequeño, el criterio de selección lo elegirá como candidato e inmediatamente pasará a formar parte de VISTOS y se considerará que su D[u] es una distancia definitiva.
Supongamos que no es CIERTO, es decir, que existe un camino más corto, aún no considerado, desde el vértice inicial a u que pasa por v, obviamente vVVISTOS. Si v se encuentra en el camino más corto desde el vértice inicial a u, ¡ es que D[v]
siempre que D contenga información correcta, la función de selección elige un vértice con un valor de D ya definitivo (ninguno de los vértices que no están en VISTOS lograrán que se reduzca ).
Ejemplo de funcionamiento
Vértice inicial : vértice con etiqueta 0.
D : 0 1 2 3 4 5 VISTOS
0 2 5 2 { 0 }
0 2 3 2 3 {0,1}
0 2 3 2 3 8 {0,1,3}
0 2 3 2 3 5 {0,1,3,2}
0 2 3 2 3 4 {0,1,3,2,4}
0 2 3 2 3 4 {0,1,3, 2,4,5}
RECONSTRUCCION DE CAMINOS MINIMOS
En primer lugar hay que almacenar información para saber que vértices forman parte del camino de longitud mínima que parte del vértice inicial.
función DIJKSTRA_CAM ( g es grafo;
v_ini es vértice )
dev ( D, CAMINO es vector[1..n] de natural )
{ Pre : la misma que DIJKSTRA }
Para cada vV hacer
D[v] := M[v_ini, v]; CAMINO[v]:= v_ini;
fpara;
D[v_ini]:= 0;
VISTOS := añadir( conjunto_vacio, v_ini );
*[ |VISTOS| < |V| --->
u := MINIMO( D, uVVISTOS );
VISTOS := VISTOS{u};
Para cada v suc(g,u) t.q. v VVISTOS hacer
[ D[v] > D[u] + valor( g,u,v ) --->
D[v] := D[u] + valor( g,u,v );
CAMINO[v]:= u;
[] D[v] D[u] + valor ( g,u,v ) ---> seguir
]
fpara;
]
{ Post : La misma de Dijkstra y u : uV: CAMINO[u] contiene el otro vértice de la última arista del camino mínimo de v_ini a u}
dev ( D, CAMINO )
ffunción
En segundo lugar utilizar un procedimiento recursivo, RECONSTRUIR, que recibe el vértice para el cual se quiere reconstruir el camino, v, y el vector CAMINO.
función RECONSTRUIR ( v, v_ini es vértice;
CAMINO es vector[1..n] de vértices )
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 mínimo desde v_ini a v }
dev ( s )
ffunción
