COMPLEJIDAD DE ALGORITMOS

5°Semestre Ing de sistemas

2018

Jaime Eduardo Cortés

jcortes@uco.edu.co
3116322941
Contenido
● Conectividad dinámica - Quick Union
● Demo quick union
● Análisis de quick union
● Conectividad dinámica weighted quick union.
● Demo Weighted Quick Union.
● Analisis Weighted Quick Union.
Conectividad dinámica – Quick union
Nueva interpretación para el mismo arreglo: id[i] es
padre de i. Es un conjunto de arboles a los que llaman
bosque.

0 1 2 3 4 5 6 7 8 9

Id[] 0 1 9 4 9 6 6 7 8 9

La raíz de 3 es 9
Conectividad dinámica – Quick union

Cuales son las raices de 3 y 7 respectivamente?

Conectividad dinámica – Quick union
Se puede implementar la operación find() , chequeando si
dos elementos están conectados observando si ambos
tienen la misma raíz.

La raíz de 3 es 9 y la raíz de 5 es 6. 3 y 5 no están

conectados.

La raíz de 3 es 9 y la raíz de 2 es 9. 3 y 2 están conectados.

Conectividad dinámica – Quick union
Se puede implementar la operación union() , mezclando las
componentes que contienen a p y q, colocando el
identificador de la raíz de p al identificador de la raíz de q.

0 1 2 3 4 5 6 7 8 9

0 1 9 4 9 6 6 7 8 6
Id[]
Demo Quick union

0 1 2 3 4 5 6 7 8 9

0 1 2 3 4 5 6 7 8 9
Demo Quick union

union(4,3)

0 1 2 3 4 5 6 7 8 9

0 1 2 3 3 5 6 7 8 9
Demo Quick union

union(3,8)

0 1 2 3 4 5 6 7 8 9

0 1 2 8 3 5 6 7 8 9
Demo Quick union

union(6,5)

0 1 2 3 4 5 6 7 8 9

0 1 2 8 3 5 5 7 8 9
Demo Quick union

union(9,4)

0 1 2 3 4 5 6 7 8 9

0 1 2 8 3 5 5 7 8 8
Demo Quick union

union(2,1)

0 1 2 3 4 5 6 7 8 9

0 1 1 8 3 5 5 7 8 8
Demo Quick union

connected (8,9)✔

0 1 2 3 4 5 6 7 8 9

0 1 1 8 3 5 5 7 8 8
Demo Quick union

connected (5,4)✖

0 1 2 3 4 5 6 7 8 9

0 1 1 8 3 5 5 7 8 8
Demo Quick union

union (5,0)

0 1 2 3 4 5 6 7 8 9

0 1 1 8 3 0 5 7 8 8
Demo Quick union

union (7,2)

0 1 2 3 4 5 6 7 8 9

0 1 1 8 3 0 5 1 8 8
Demo Quick union

union (6,1)

0 1 2 3 4 5 6 7 8 9

1 1 1 8 3 0 5 1 8 8
Demo Quick union

union (7,3)

0 1 2 3 4 5 6 7 8 9

1 8 1 8 3 0 5 1 8 8
Análisis – Quick union
public class QuickUnionUF
{ private int[] id; //access to component id(site indexed)

public QuickUnionUF(int N)
{ id=new int[N]; Establecer el ID del objeto así mismo
for(int i=0;i<N; i++) id[i]=i; ( N accesos al aarreglo )
}

private int root(int i)

{ while(i!=id[i]) i=id[i]; Perseguir los punteros padre hasta llegar a la raíz
return i; profundidad de i accesos al arreglo.
}

public boolean connected(int p, int q)

{ return root(p)==root(q);} Verificar si p y q tienen la misma raíz
Accesos al arreglo con la profundidad de p y q
public void union(int p, int q)
{ int i = root(p); Cambio de la raíz de p para que apunte a la raíz de q
int j = root(q); Accesos al arreglo con la profundidad de p y q
id[i]=j;
}

public static void main(String[] args)

{ }
}
Análisis – Quick union
El modelo de costo utilizado es el número de accesos al
arreglo.
Quick –find defect
*union es muy costoso (N accesos al arreglo)
*Los arboles son muy planos, pero es muy costoso
mantenerlos planos.
Quick-union defect
*los arboles pueden ser muy altos.
*find() puede ser muy costoso (N accesos al arreglo)
Algoritmo inicialización union Find

Quick –f ind N N 1

Quick - union N N N peor caso

Weighted quick union.

Este algoritmo modifica el algoritmo Quick-union para

evitar arboles altos.

Hacer seguimiento del tamaño de cada árbol y

mantenerlo balanceado enlenzando la raíz del árbol
mas pequeño a la raíz del árbol mas grande.
Demo Weighted Quick-union

0 1 2 3 4 5 6 7 8 9

0 1 2 3 4 5 6 7 8 9
Demo Weighted Quick-union

Union(4,3)

0 1 2 3 4 5 6 7 8 9

0 1 2 4 4 5 6 7 8 9
Demo Weighted Quick-union

Union(3,8)

0 1 2 3 4 5 6 7 8 9

0 1 2 4 4 5 6 7 4 9
Demo Weighted Quick-union

Union(6,5)

0 1 2 3 4 5 6 7 8 9

0 1 2 4 4 6 6 7 4 9
Demo Weighted Quick-union

Union(6,5)

0 1 2 3 4 5 6 7 8 9

0 1 2 4 4 6 6 7 4 9
Demo Weighted Quick-union

Union(9,4)

0 1 2 3 4 5 6 7 8 9

0 1 2 4 4 6 6 7 4 4
Demo Weighted Quick-union

Union(2,1)

0 1 2 3 4 5 6 7 8 9

0 2 2 4 4 6 6 7 4 4
Demo Weighted Quick-union

Union(5,0)

0 1 2 3 4 5 6 7 8 9

0 2 2 4 4 6 6 7 4 4
Demo Weighted Quick-union

Union(5,0)

0 1 2 3 4 5 6 7 8 9

6 2 2 4 4 6 6 7 4 4
Demo Weighted Quick-union

Union(7,2)

0 1 2 3 4 5 6 7 8 9

6 2 2 4 4 6 6 2 4 4
Demo Weighted Quick-union

Union(6,1)

0 1 2 3 4 5 6 7 8 9

6 2 6 4 6 6 6 2 4 4
Demo Weighted Quick-union

Union(7,3)

0 1 2 3 4 5 6 7 8 9

6 2 6 4 4 6 6 2 4 4
Weighted Quick-union
Weighted Quick-union

La estructura de datos utilizada es la misma que la de

Quick-union.

Se agrega arreglo sz[] para contar el numero de objetos

en el árbol cuya raíz esta en i.
Weighted Quick-union
El método union() se modifica :
*Enlazar la raíz del árbol mas pequeño a la raíz del árbol
mas grande.

*Se actualiza el arreglo sz[].

int i = root(p);
int j = root(q);
if (i == j) return;
// Make smaller root point to larger one.
if (sz[i] < sz[j]) { id[i] = j; sz[j] += sz[i]; }
else { id[j] = i; sz[i] += sz[j]; }
Demo Weighted Quick-union
Find() toma un tiempo proporcional a la profundidad de p y
de q.

Union () toma un tiempo constante, dadas las raíces.

La profundidad de cada nodo x es como mucho log N.

Algoritmo inicialización union Find

Quick –f ind N N 1

Quick - union N N N

Weighted Quick-union N Lg N Lg N
WQU - Path compression
Justo después de calcular la raíz de p, coloque el id de cada
nodo examinado a apuntar a la raíz.
WQU - Path compression
Justo después de calcular la raíz de p, coloque el id de cada
nodo examinado a apuntar a la raíz.
WQU - Path compression
Justo después de calcular la raíz de p, coloque el id de cada
nodo examinado a apuntar a la raíz.
WQU - Path compression
Justo después de calcular la raíz de p, coloque el id de cada
nodo examinado a apuntar a la raíz.
WQU - Path compression
Justo después de calcular la raíz de p, coloque el id de cada
nodo examinado a apuntar a la raíz.
Implementar WQU - Path compression
Implementación de dos pasadas:
Añadir un segundo loop al método root() para setear el id[]
de cada nodo examinado hacia el root.

Variante de una pasada (mas simple):

Haga que cada nodo en el path apunte a su abuelo,
dividiento por lo tanto a la mitad la longitud del path.
private int root(int i)
{ while(i!=id[i])
{
id[i]=id[ id[i] ];
i = id[i];
}
return i;
}