Estructuras de Datos. Estructuras de Datos para Conjuntos Disjuntos

Transcripción

1 Estructuras de Datos. Estructuras de Datos para Conjuntos Disjuntos Santiago Zanella Introducción Para ciertas aplicaciones se requiere mantener n elementos distintos agrupándolos en una colección de conjuntos disjuntos, permitiendo dos operaciones: (1) la unión de dos conjuntos de la colección y (2) conocer en qué conjunto se encuentra un elemento dado. Entre estas aplicaciones se cuentan el algoritmo de Kruskal para la determinación del árbol de expansión mínimo de un grafo, la inferencia de tipos, la determinación de las componentes conexas de un grafo, el reconocimiento de objetos en imágenes, étc... 2 Definición de la Estructura Una estructura de datos de conjuntos disjuntos (disjoint-set data structure) mantiene una colección de conjuntos disjuntos entre sí con elementos dentro de un cierto universo S = {S 1, S 2,...,S k } i, j {1,..., k} i j S i S j = U = {x 1,...,x n } Cada conjunto de la colección se identifica por un representante que puede ser un miembro cualquiera del conjunto. Solo se requiere que al consultar por el representante de un conjunto dos veces consecutivas sin modificar el conjunto el resultado sea el mismo. Sin perder generalidad se puede asumir que U = {1,..., n}. Si no fuera así se puede encontrar una función biyectiva que realice la traducción entre U y el conjunto {1,...,n}. Sean x, y U se desea implementar las siguientes operaciones: 1

2 MakeSet(x): Crea un nuevo conjunto cuyo único miembro (y representante) es x. Se requiere que x no esté en ningún conjunto de la estructura. pre: x U k i=1 S i pos: S = S {x} Union(x, y): Une los conjuntos que contienen a x y a y, digamos S x y S y. El representante del conjunto resultante puede ser cualquier miembro de S x S y. Como se requiere que la colección sea disjunta, se eliminan los conjuntos S x y S y de la colección S. pre: x S x y S y S x S y pos: S = S (S x S y ) {S x, S y } Find(x): Encuentra el representante del único conjunto al que pertenece x o 0 si x no está en ningún conjunto de la colección. pre: x U pos: (x S i i = 1,...,k Find(x) S i ) (x / k i=1 S i Find(x) = 0) En lo que sigue se intentará analizar el costo de diferentes implementaciones de la estructura al ejecutar una secuencia σ de m de estas operaciones, de las cuales n son operaciones MakeSet, q son operaciones Union y f son operaciones Find (Ver Tabla 1). Como los conjuntos son disjuntos, cada operación Union reduce el número de conjuntos en 1. Luego de n 1 operaciones Union solamente queda un conjunto, por lo tanto el número de operaciones Union es a lo sumo n 1. σ MakeSet Union Find Número de Operaciones m n q n 1 f = m (n + q) Tabla 1: Número de operaciones de cada tipo en la secuencia σ. Se considerará además que en cada una de las operaciones Union(x, y), x e y son los representantes de los conjuntos a los que pertencen. 3 Aplicación Una aplicación simple de la estructura de conjuntos disjuntos es determinar si dos vértices de un grafo no-dirigido pertenecen o no a la misma componente conexa. 1 procedure connected components (G) 2 foreach v V(G) 2

3 3 MakeSet (v ) ; 4 end 5 foreach (u, v) E(G) 6 if Find (u) Find (v) then 7 Union(u, v ) ; 8 end 9 end 10 end 1 procedure same component (u, v) 2 if Find (u) = Find (v) then 3 return True ; 4 else 5 return False ; 6 end 7 end Ejemplo a b c d e g h i Figura 1: Un grafo no-dirigido con 8 vértices y 3 componentes conexas. Paso Arista Procesada S 0 inicio {a} {b} {c} {d} {e} {g} {h} {i} 1 (a,b) {a, b} {c} {d} {e} {g} {h} {i} 2 (a,e) {a, b, e} {c} {d} {g} {h} {i} 3 (a,g) {a, b, e, g} {c} {d} {h} {i} 4 (c,d) {a, b, e, g} {c, d} {h} {i} 5 (c,i) {a, b, e, g} {c, d, i} {h} Tabla 2: Colección de conjuntos disjuntos luego de proecesar cada arista. La Tabla 2 muestra la colección S que mantiene la estructura en cada paso del procedimiento. Al finalizar, dos vértices se encuentran en el mismo conjunto de la colección si y solo sí se encuentran en la misma componente conexa. Luego, Find(u) = Find(v) si y solo si u y v están en la misma componente conexa. 3

4 La relación R donde u R v si y solo sí u y v están en la misma componente conexa es una relación de equivalencia. En general, siempre que se divide un grupo de objetos en conjuntos disjuntos, la relación R donde xry si y solo sí x e y están en el mismo conjunto es una relación de equivalencia. 4 Representación por Arreglos Una manera simple de implementar la estructura es utilizando un arreglo rep de tamaño n de tal forma que rep[x] indique el representante del conjunto al que pertence x. Se incializan todas las posiciones del arreglo rep en 0. La operación Makeset(x) asigna rep[x] := x. O(1). La operación Find(x) simplemente devuelve el valor de rep[x]. O(1). Para la operación Union(x, y) se recorre el arreglo rep y se cambian, por ejemplo, todas las posiciones iguales a y por x. O(n). 1 procedure MakeSet (x) 2 rep [ x ] := x ; 3 end 1 function Find ( x) 2 return rep [ x ] ; 3 end 1 procedure Union(x, y) 2 for i :=1 to n do 3 if rep [ i ] = y then 4 rep [ i ] := x ; 5 end 6 end 7 end El costo de m operaciones está dominado por la cantidad de operaciones Union, cada una de las cuales tiene costo O(n). El orden de una secuencia σ de m operaciones resulta O(n + qn + f). En el peor caso, q = n 1 = Θ(m) y la secuencia σ completa tiene un orden de tiempo de O(m 2 ). 4

5 (a) (b) rep rep b c d e f g h c c f c f f c b c d e f g h c c c c c c c Figura 2: (a) Representación por arreglos de los conjuntos {c, h, e, b} con c como representante y {f, g, d} con f como representante. (b) Resultado luego de ejecutar Union(c, f). 5 Representación por Listas Se puede mejorar el costo de la operación Union si en lugar de recorrer todas las entradas del arreglo rep se recorren solamente aquellas que corresponden a uno de los dos conjuntos. Esto se puede lograr representando los conjuntos mediante listas usando arreglos. Se representa la estructura usando un arreglo rep como en el caso anterior, un arreglo next que indica el sucesor de un elemento en la lista a la que pertenece y un arreglo last que almacena el último elemento de cada lista. El primer elemento de cada lista sirve como representante del conjunto. Se incializan todas las posiciones del arreglo rep en 0. La operación Makeset(x) crea una nueva lista que contiene solo al elemento x en O(1). La operación Find(x) simplemente devuelve el valor de rep[x]. O(1). Para la operación Union(x, y) se recorre, por ejemplo, la lista que comienza en x cambiando las entradas correspondientes en el arreglo rep por y y luego se concatena al final de la lista que comienza en y. (Fig. 3) c h e b f g d c h e b f g d (a) (b) Figura 3: (a) Representación en forma de lista de los conjuntos {c, h, e, b} y {f, g, d}. (b) Resultado luego de ejecutar Union(c, f). 5

6 1 procedure MakeSet (x) 2 rep [ x ] := x ; 3 next [ x ] := 0; 4 last [ x ] := x ; 5 end 1 function Find ( x) 2 return rep [ x ] ; 3 end 1 procedure Union(x, y) 2 p := x ; 3 do 4 rep [ p ] := y ; 5 p := next [ p ] ; 6 while p 0 7 next [ last [ y ] ] := x ; 8 last [ y ] := last [ x ] ; 9 end Para realizar una operación Union se recorre toda la lista x, lo que lleva un tiempo proporcional a la longitud de la lista. Se puede construir una secuencia de m operaciones que lleve tiempo Θ(m 2 ). Considere la secuencia de m operaciones con n = m/2 + 1 y q = m n = m/2 1 que se muestra en la Tabla 3. Operación Número de Actualizaciones a rep MakeSet(x 1 ) 1.. MakeSet(x n ) 1 Union(x 1, x 2 ) 1 Union(x 2, x 3 ) 2 Union(x 3, x 4 ) 3.. Union(x q 1, x q ) q 1 Tabla 3: Una secuencia de m operaciones que toma tiempo Θ(m 2 ). Cada operación MakeSet realiza una actualización a rep. La i-ésima operación Union realiza i actualizaciones. El número de actualizaciones en las q operaciones Union es q 1 i = Θ(q 2 ) i=1 6

7 El número total de actualizaciones es de orden Θ(n + q 2 ) = Θ(m 2 ) porque n = Θ(m) y q = Θ(m). En promedio cada una de las m operaciones tiene orden Θ(m). 5.1 Unión por Tamaño En la implementación anterior no se consideraba la longitud de cada lista al realizar una operación Union. Qué sucede si se considera y se actualizan siempre los representantes de la lista de menor tamaño? Claramente, la secuencia anterior de operaciones se ejecutaría en orden Θ(m). Aunque el anterior es un caso particular, se observa una mejora en general. 1 procedure Union(x, y) 2 if size [ x ] > size [ y ] then 3 swap (x, y ) ; 4 end 5 6 p := x ; 7 8 do 9 rep [ p ] := y ; 10 p := next [ p ] ; 11 while p 0 12 next [ last [ y ] ] := x ; 13 size [ y ] := size [ x ] + size [ y ] ; 14 end Teorema 5.1 Usando la representación por listas y la técnica de unión por tamaño una secuencia de m operaciones MakeSet, Union y Find, n de las cuales son operaciones MakeSet, toma tiempo O(m + n log n). Demostración Se trata de encontrar para cada elemento x una cota superior del número de veces que se actualiza rep[x]. Cada vez que se actualiza rep[x] al realizar una operación Union(S x, S y ) el elemento x se debe encontrar en la lista de menor tamaño: S x S y y la lista resultante tiene tamaño S x + S y 2 S x Es decir, cada vez que el conjunto al que pertence un elemento x participa en una unión, y se modifica rep[x], el elemento termina dentro de un conjunto que es al menos dos veces mayor. Luego de actualizar log k veces el representante de un elemento, el conjunto en el que está debe tener al menos k miembros. Como un conjunto no puede tener más de n elementos, a lo sumo se actualiza el representante de un elemento log n veces. El número de 7

8 actualizaciones en todas las operaciones Union es por lo tanto de orden O(q log n). Cada operación MakeSet y cada operación Find toma tiempo O(1), por lo tanto la secuencia completa toma tiempo O(n + q log n + f). En el peor caso, cuando n = Θ(m), q = Θ(m) y f = Θ(m), el orden es O(m log m). 6 Representación por Árboles Se puede representar la colección S como una colección de árboles donde cada árbol representa un conjunto y cada nodo es un miembro del conjunto. El representante de un conjunto es el nodo raíz en el árbol y para cada nodo solo se mantiene un puntero a su nodo padre en un arreglo llamado father (Fig. 4). c f f h e d c d b g h e g (a) b (b) Figura 4: Un bosque de conjuntos disjuntos. (a) Dos árboles representando los conjuntos de la Fig. 3. El árbol de la izquierda representa el conjunto {b, c, e, h}, con c como el representante, y el árbol de la derecha representa el conjunto {d, f, g} con f como representante. (b) El resultado luego de Union(c, f). Se incializan todas las posiciones del arreglo father en -1. La operación Makeset(x) crea un nuevo árbol que solo contiene al elemento x en O(1). La operación Find(x) recorre el árbol donde está x hasta la raíz para buscar el representante del conjunto. El orden temporal está dado por la altura del árbol. La operación Union(x, y) asigna, por ejemplo, f ather[x] := y en O(1). (Fig. 3) 1 procedure MakeSet (x) 2 father [ x ] := 0; 3 end 1 function Find ( x) 2 if father [ x ] = 1 then 3 return 0; 8

9 4 end; 5 while father [ x ] 0 do 6 x := father [ x ] ; 7 end 8 return x ; 9 end 1 procedure Union(x, y) 2 father [ x ] := y ; 3 end Hasta el momento, no se obtuvo ninguna mejora sobre la representación por listas en el orden de tiempo que lleva ejecutar una secuencia de m operaciones. Es posible crear una secuencia de aproximadamente m/3 operaciones MakeSet seguidas de aproximadamente m/3 operaciones Union de tal forma que se obtenga un único conjunto representado como un árbol lineal una cadena de nodos. Se puede encontrar luego una secuencia de aproximadamente m/3 operaciones Find cada una de las cuales lleve tiempo Θ(m/3). La secuencia completa se ejecutará en tiempo Θ(m 2 ). 6.1 Heurísticas Utilizando dos simples heurísticas en las operaciones Union y Find se puede mejorar el orden de tiempo para ejecutar una secuencia σ de m operaciones Unión por Tamaño La heurística de unión por tamaño no es más que una extensión de la heurística de unión por tamaño para la representación por listas. La idea consiste en modificar la operación Union para que agregue el árbol con menos nodos como subárbol del árbol con más nodos Compresión de Caminos Cada vez que se ejecuta una instrucción Find(x) se recorre el camino desde x hasta la raíz del árbol que lo contiene. Se puede mejorar el tiempo que llevarán futuras operaciones si durante la operación se convierte cada nodo en el camino de búsqueda en un hijo de la raíz. (Fig. 5) 6.2 Implementación La cantidad de nodos en el subárbol de un nodo x se conserva en size[x]. Cuando se aplica Union sobre dos árboles, el árbol de menor tamaño se convierte en un subárbol de la raíz del árbol con mayor tamaño. En caso de empate se realiza una elección arbitraria. 9

10 (a) f (b) f e e d c b a d c b a Figura 5: Efecto de la compresión de caminos sobre un árbol lineal. (a) (b) Árbol luego de ejecutar Find(a) utilizando compresión de caminos. Árbol original. 1 procedure MakeSet (x) 2 size [ x ] := 0; 3 end 1 function Find ( x) 2 r := x ; 3 while father [ r ] 0 do 4 r := father [ r ] ; 5 end 6 / r es ahora la raíz del árbol / 7 8 p := x ; 9 while p r do 10 t := father [ p ] ; 11 father [ p ] := r ; 12 p := t ; 13 end 14 return r ; 15 end 1 procedure Union(x, y) 2 if size [ x ] > size [ y ] then 3 father [ y ] := x ; 4 size [ x ] := size [ x ] + size [ y ] ; 10

11 5 else 6 father [ x ] := y ; 7 size [ y ] := size [ y ] + size [ x ] ; 8 end 9 end 6.3 Impacto de las Heurísticas Utilizando solamente la heurística de unión por tamaño, cada vez que un nodo se mueve a un nuevo árbol suceden dos cosas: La distancia del nodo a la raíz del árbol donde se encuentra se incrementa en uno. El nuevo árbol tiene al menos dos veces más nodos que el anterior. Si en total existen n elementos en el universo, ningún nodo puede moverse más de log n veces y por lo tanto la distancia de cualquier nodo a la raíz de su árbol no puede exceder log n y cada operación Find requiere tiempo O(logn). El impacto de la compresión de caminos es más difícil de analizar. Cuando se utilizan ambas heurísticas, el orden de complejidad temporal del peor caso es O(m α(m, n)), donde α(m, n) es una función que se define como una especie de inversa de la función de Ackermann y crece en forma extremadamente lenta. Para cualquier aplicación práctica concevible, resulta α(m, n) 4 y por lo tanto el orden de complejidad de la ejecución de una secuencia de m operaciones es prácticamente lineal. En lugar de probar que el orden de complejidad temporal del peor caso al ejecutar una secuencia σ de m operaciones es O(m α(m, n)) se puede probar más fácilmente una cota ligeramente menos ajustada, como se muestra a continuación. 6.4 Análisis de Complejidad Definición F y G Definimos las funciones F y G como sigue: F(k) = { 1 k = 0 2 F(k 1) k 1 (1) G(n) = min{k N F(k) n} (2) La función F crece muy rápidamente y la función G muy lentamente: n = G(n) 5 11

12 n F(n) = = = = = = Tabla 4: Primeros valores de F. n G(n) 0 n < n < n < n < n < n Tabla 5: Primeros valores de G(n). Definición σ σ es la secuencia de operaciones obtenida al eliminar de σ todas las operaciones Find. Definición F F es el bosque resultante luego de ejecutar σ. Definición T i T i es el subárbol con raíz en el nodo i dentro de F. Definición Rango El rango de un vértice i en F, r(i), es la altura de T i. Lema 6.1 Todo nodo i tiene al menos 2 r(i) descendientes, o equivalentemente T i 2 r(i). Demostración Por inducción sobre r(i) Caso Base: r(i) = 0 T i tiene al menos un vértice, i. Por lo tanto T i 1 = 2 0 = 2 r(i). Caso Inductivo: (HI) i F r(i) k T i 2 r(i) 12

13 Sea i un nodo con rango k. En algún momento tuvo rango menor que k y fue unido con otro árbol con raíz en un vértice j de rango k 1 y menos nodos: T i = T i + T j 2 T j 2 2k 1 = 2 k Corolario 6.2 Ningún vértice en F tiene rango mayor que log n. Lema 6.3 Existen a lo sumo n/2 r vértices de rango r en F Demostración Cada vértice de rango r tiene al menos 2 r descendientes. Los nodos de los subárboles de dos nodos en el bosque con el mismo rango son disjuntos. Hay n nodos en total, puede a lo sumo haber n/2 r nodos de rango r. Lema 6.4 Si en algún momento durante la ejecución de σ, w es un descendiente propio de v, entonces el rango de w es estrictamente menor que el rango de v. Demostración Si en algún momento un vértice w es descendiente propio de otro vértice v, lo será hasta que se termine de ejecutar la secuencia (no hay operaciones Find en σ ) y en el bosque resultante F su altura será estrictamente menor. Teorema 6.5 Una secuencia σ de m operaciones de las cuales n 2 son operaciones MakeSet se ejecuta en tiempo O(m G(n)). Demostración Como antes, con q indicaremos el número de operaciones Union y con f el número de operaciones Find. Como cada operación Union y cada operación MakeSet se realiza en tiempo de orden constante y q < n, todas las operaciones MakeSet y Union se realizan en orden O(n). Para acotar el costo de todas las operaciones Find se utiliza una técnica de contabilidad. El costo de ejecutar una sola operación Find se reparte entre la operación misma y algunos vértices en el camino de búsqueda. El costo total se calcula sumando los costos sobre todas las operaciones Find y sobre todos los vértices. Se dividen los rangos de los vértices en F en grupos. Los vértices de rango r se colocan en el grupo G(r). Los vértices con el mayor rango posible, log n. se colocan en el grupo G( log n ) G(n). G(0) = {0, 1} G(1) = {2} G(2) = {3, 4} G(3) = {5, 6,..., 16}... Para los vértices v en el camino de búsqueda de una operación Find(x) (sin contar el propio x), la política para repartir el costo es la siguiente: 13

14 1. Si v es una raíz, o father[v] está en un grupo diferente de v, se le carga una unidad de costo a la operación. 2. Si v y su padre están en el mismo grupo, se le carga una unidad a v Por el Lema 6.4 los vértices en un camino de búsqueda desde un nodo hasta la raíz del árbol crecen estrictamente en rango. Cómo a lo sumo hay G(n) grupos diferentes, ninguna operación Find puede tener costo mayor que G(n). Cada vez que se aplica la segunda regla en un vértice v, se le asigna un nuevo padre que debe tener un rango mayor por el Lema 6.4. Si v está en el grupo g > 0, solamente puede incrementarse su costo F(g) F(g 1) veces por la segunda regla antes de que adquiera un padre en un grupo de rango mayor a su propio rango (el costo de un vértice en el grupo 0 solo puede incrementarse una vez). Cuando pasa a tener un padre en un grupo de rango mayor, nunca más se incrementa su costo porque la segunda regla ya no es aplicable. Para obtener una cota superior de los costos de los vértices, se multiplica el máximo posible costo de un vértice en un grupo por el número de vértices en el grupo. Sea N(g) el número de vértices en el grupo g, por el Lema 6.3: N(g) F(g) r=f(g 1)+1 n/2 r (3) (n/2 F(g 1)+1 ) (1 + 1/2 + 1/4 + ) (4) (n/2 F(g 1)+1 ) 2 (5) = n/2 F(g 1) (6) = n/f(g) (7) El máximo costo para un vértice en el grupo g es menor o igual que F(g) F(g 1), luego el costo máximo de todos los vértices en el grupo g, C(g) resulta C(g) = (F(g) F(g 1)) N(g) (8) n (F(g) F(g 1)) (9) F(g) F(g 1) = n (10) F(g) n (11) Por lo tanto, como no puede haber más de G(n) grupos, el máximo costo asignado a todos los vértices es n G(n). Como el máximo costo asignado a una operación Find es G(n), el máximo costo asignado a todas las operaciones Find es f G(n). Por último, todas las 14

15 operaciones Find se ejecutan en tiempo O((n + f) G(n)). Por todo lo visto, la secuencia σ se ejecuta en tiempo O((n + f) G(n)) y como n + f m en tiempo O(m G(n)). Referencias [AHU74] Alfred V. Aho, J. E. Hopcroft, and Jeffrey D. Ullman. The Design and Analysis of Computer Algorithms. Addison-Wesley, [CSRL01] Thomas H. Cormen, Clifford Stein, Ronald L. Rivest, and Charles E. Leiserson. Introduction to Algorithms. McGraw-Hill Higher Education, [Sed92] Robert Sedgewick. Algorithms in C++. Addison-Wesley, ISBN: