Análisis de Algoritmos

María Fernanda Mora Alba

Luis Manuel Román García

 

26 de agosto del 2015

Contenido

  • P, NP, NP-completo, NP-duro

  • Inserción Directa vs Mezcla Directa

  • Mínima n

  • Grandes valores de n

  • Tabla de complejidad

P, NP, NP-completo, NP-duro

Motivación

Everyone who could appreciate a symphony would be Mozart; everyone who could follow a step-by-step argument would be Gauss; everyone who could recognize a good investment strategy would be Warren Buffett.

- Aaronson, MIT

  • La Teoría de la Complejidad (computacional) estudia qué tan difícil/fácil es resolver un problema
  • Puede volverse muy técnica pero los conceptos básicos son muy intuitivos
  • Nos permite entender el problema P vs NP sin necesidad de tener conocimientos matemáticos/formales
  • Los problemas en Complejidad vienen en pares: Search Version and Verification Version

Preliminares: Teoría de la Complejidad

Búsqueda

Entrada: lista de números

 

 

Salida: Lista       , que es el ordenamiento de

Verificación

Entrada: listas de números      

y  

 

Salida:  "Sí" si         es la versión ordenada de      . "NO" si no.

Problema: Ordenamiento

L_1
L1L_1
L_2
L2L_2
L_1
L1L_1
L_1
L1L_1
L_2
L2L_2
L_2
L2L_2
L_1
L1L_1

6

1

3

4

Desordenado

6

1

1

6

1

Paso

1

6

1

3

6

2

3

6

3

6

3

1

1

3

3

1

3

4

4

6

4

6

4

6

4

5

3

4

4

3

O

Entrada: lista de números

 

Salida: Sublistas         y         de en donde la suma de        es igual a la suma de       . Adicionalmente una lista      del mismo tamaño de       que indica en qué sublista quedó cada elemento

Entrada: listas de números       y   

  

Salida:  "Sí" si  las sublistas correspondientes a        suman mismo. "No" si no.

Problema: Partición de números

L
LL
L_2
L2L_2
L_1
L1L_1
L
LL
P
PP
L_1
L1L_1
L_2
L2L_2
L
LL
P
PP
L
LL
P
PP
4
44
6
66
5
55
2
22
3
33 
Búsqueda
Verificación

Entrada: gráfica con nodos y aristas                  y un conjunto de colores      

 

Salida: Lista      del mismo tamaño de       tal que ningún nodo adyacente tenga el mismo color

Entrada: gráfica con nodos y aristas                  y una lista       que asigna colores a los nodos

   

Salida:  "Sí" si todos los nodos adyacentes tienen colores diferentes. "No" si no.

Problema: Coloración de gráficas

(N,A)
(N,A)(N,A)
N
NN
C
CC
L
LL
(N,A)
(N,A)(N,A)
L
LL 
Búsqueda
Verificación

Clase     

P
PP

Un problema está en        si su Versión de Búsqueda tiene una solución rápida (aká, se resuelve en tiempo polimonial, i.e. existe un algoritmo que lo resuelve en tiempo                para alguna     )

P
PP
O(n^k)
O(nk)O(n^k)
k
kk

Clase  

NP
NPNP

Un problema está en          si su Versión de Verificación tiene una solución rápida (aká, se resuelve en tiempo polimonial, i.e. existe un algoritmo que lo resuelve en tiempo                para alguna     )

NP
NPNP
O(n^k)
O(nk)O(n^k)
k
kk
NP
NPNP

Si la versión de Búsqueda de un problema tiene una solución rápida, entonces su versión de Verificación también, pues si podemos resolver la forma general del problema, podemos resolver casos particulares del mismo

P
PP
\subseteq
⊆\subseteq

Equivale a preguntarnos si:

 

¿Existen problemas cuya versión de verificación se puede resolver fácilmente (aká eficientemente, en tiempo polinomial) pero cuya versión de búsqueda no?

P=NP
P=NP P=NP
NP \subseteq P
NP⊆P NP \subseteq P

      ¿                      (                  )  ?

Problema: Ordenamiento

  • Ambas versiones: Búsqueda y Verificación pueden resolverse fácilmente.
  • Veremos dos algoritmos de Ordenamiento: Inserción Directa y Mezcla Directa.
  • Entonces el problema de Ordenamiento está en       y en         .

 

 

P
PP
NP
NPNP

Problemas: Partición de números y Coloración

  • La versión de Verificación pueden resolverse fácilmente.
  • A la fecha no se conocen algoritmos que resuelvan rápidamente la versión de Búsqueda.
  • Estos problemas están en         pero no se sabe si están en    .

 

 

P
PP
NP
NPNP
NP-duros
NP−durosNP-duros
  • Hay problemas que pueden ser traducidos a otros problemas de tal forma que al tener una solución eficiente a los segundos, se tiene una solución a los primeros.
  • Existe una clase de problemas tal que cualquier problema en          puede ser traducida a un problema de esta subclase.
  • De modo que si encontramos una solución eficiente  para un problema de esta subclase, hemos encontrado un solución eficiente a todos los problemas en 
  • Esta subclase de problemas son los

 

NP
NPNP
NP
NPNP
NP-duros
NP−durosNP-duros
NP-completos
NP−completosNP-completos
  • No todos los problemas                          están contenidos en
  •  A los problemas                           que sí están en          se les denomina

 

NP
NPNP
NP-duros
NP−durosNP-duros
NP
NPNP
NP-duros
NP−durosNP-duros
NP-completos
NP−completosNP-completos
NP = P
NP=PNP = P
  • Vimos que si logramos resolver cualquier problema             l                     entonces logramos resolver la versión de Búsqueda de todos los problemas en
  • Si además restringimos nuestro conjunto sólo a los                                   esto significa que si tenemos una solución eficiente a la versión de Verificación, siempre podremos encontrar una solución a su versión de Búsqueda

 

NP
NPNP
NP-duro
NP−duroNP-duro

¿Cómo esto resolvería el problema                 ?

NP-completos
NP−completosNP-completos
NP = P
NP=PNP = P
  • Entonces, bastaría con poder verificar soluciones a un problema y no sería necesario buscar una solución del problema en todo el espacio de búsqueda, pues siempre podríamos encontrar una solución "eficiente".

 

¿Cómo esto resolvería el problema                 ?

Gráficamente:                

  • Entonces, bastaría con poder verificar soluciones a un problema y no sería necesario buscar una solución del problema en todo el espacio de búsqueda, pues siempre podríamos encontrar una solución "eficiente".

 

Posturas           

Un poco de humor...           

Inserción Directa vs Mezcla Directa

Inserción Directa


def inser_sort(array):
    N = array.size
    for i in range(1, N):  
        aux = array[i]
        k = i - 1
        while (k >= 0) == True & (aux < array[k]) == True:
            array[k + 1] = array[k]
            k = k - 1
        array[k + 1] = aux
    return array

Mézcla Directa

def sort(L,R):
    NL = L.size
    NR = R.size
    answer = np.empty(0)
    i = 0
    j = 0
    k = 0
    while (i < NL) == True & (j < NR) == True:
        if L[i] <= R[j]:
            answer = np.hstack([answer, L[i]])
            k = k + 1
            i = i + 1
        else:
            answer = np.hstack([answer, R[j]])
            k = k + 1
            j = j + 1
    if i < NL:
        answer = np.hstack([answer, L[i::]])
    elif j < NR:
        answer = np.hstack([answer, R[j::]])
    return answer

Ordenamiento

Mézcla Directa

def mix(array):
    N = array.size
    if N == 1:
        return array
    return sort(mix(array[0:N/2]), mix(array[N/2:N])

Mezcla

En vivo

Aquí pueden probar nuestro código.

Análisis teórico

Inserción

El peor caso corre en un tiempo               de n el número de elementos a ordenar.

an^2 + bn +c \approx c_1n^2
an2+bn+c≈c1n2an^2 + bn +c \approx c_1n^2
T_{O(n^2)}
TO(n2)T_{O(n^2)}
T_{O(nlogn)}
TO(nlogn)T_{O(nlogn)}

El peor caso corre en un tiempo                 de n el número de elementos a ordenar.

\approx c_2nlog(n)
≈c2nlog(n)\approx c_2nlog(n)

Mezcla

0 < c_1\leq c_2
0<c1≤c20 < c_1\leq c_2

Análisis teórico

c_1n^2 < c_2 nlog(n)
c1n2<c2nlog(n)c_1n^2 < c_2 nlog(n)

Buscamos n tal que

\Leftrightarrow
⇔\Leftrightarrow
\frac{c_1}{c_2} < \frac{log(n)}{n}
c1c2<log(n)n\frac{c_1}{c_2} < \frac{log(n)}{n}
-\frac{c_1}{c_2} > -log(n)e^{-log(n)}
−c1c2>−log(n)e−log(n)-\frac{c_1}{c_2} > -log(n)e^{-log(n)}
\Leftrightarrow
⇔\Leftrightarrow
e^{-W(-\frac{c_1}{c_2})} < n
e−W(−c1c2)<ne^{-W(-\frac{c_1}{c_2})} < n
\Leftrightarrow
⇔\Leftrightarrow
W(x)=\frac{x}{2\pi}\int_{-\pi}^{\pi}\frac{(1-v*cot(v))^2+ v^2}{x + v*csc(v)e^{-v*cot(v)}}dv
W(x)=x2π∫−ππ(1−v∗cot(v))2+v2x+v∗csc(v)e−v∗cot(v)dvW(x)=\frac{x}{2\pi}\int_{-\pi}^{\pi}\frac{(1-v*cot(v))^2+ v^2}{x + v*csc(v)e^{-v*cot(v)}}dv

donde

siempre que

\frac{c1}{c2}\leq\frac{1}{e}
c1c2≤1e\frac{c1}{c2}\leq\frac{1}{e}

Comparativo

n\in[2,100)
n∈[2,100)n\in[2,100)

Comparativo

n\in[100,4900]
n∈[100,4900]n\in[100,4900]

Mínima n

\displaystyle\min_n\{t_{O(100n^2)}\leq t_{O(2^n)}\}
minn{tO(100n2)≤tO(2n)}\displaystyle\min_n\{t_{O(100n^2)}\leq t_{O(2^n)}\}

Encontrar

Solución

100n^2=2^n
100n2=2n100n^2=2^n
\Leftrightarrow
⇔\Leftrightarrow
2log(\pm10n)=nlog(2)
2log(±10n)=nlog(2)2log(\pm10n)=nlog(2)
\Leftrightarrow
⇔\Leftrightarrow
\frac{log(10n)}{n}=\frac{log(2)}{2}
log(10n)n=log(2)2\frac{log(10n)}{n}=\frac{log(2)}{2}
\Leftrightarrow
⇔\Leftrightarrow
-\log(10n)e^{-log(10n)}=-\frac{log(2)}{20}
−log(10n)e−log(10n)=−log(2)20-\log(10n)e^{-log(10n)}=-\frac{log(2)}{20}
\Leftrightarrow
⇔\Leftrightarrow
n=\frac{e^{-W(\frac{-log(2)}{20})}}{10}
n=e−W(−log(2)20)10n=\frac{e^{-W(\frac{-log(2)}{20})}}{10}
\Rightarrow
⇒\Rightarrow
n= 0.1036578164
n=0.1036578164n= 0.1036578164

Solución (¿Única?)

Solución (¿Única?)

Soluciones

n=-\frac{2W(\frac{log(2)}{20})}{log(2)}
n=−2W(log(2)20)log(2)n=-\frac{2W(\frac{log(2)}{20})}{log(2)}
n=-\frac{2W(-\frac{log(2)}{20})}{log(2)}
n=−2W(−log(2)20)log(2)n=-\frac{2W(-\frac{log(2)}{20})}{log(2)}
n=-\frac{2W_{-1}(-\frac{log(2)}{20})}{log(2)}
n=−2W−1(−log(2)20)log(2)n=-\frac{2W_{-1}(-\frac{log(2)}{20})}{log(2)}

-0.096704034

\approx
≈\approx

0.103657816

\approx
≈\approx

14.324727836

\approx
≈\approx
\displaystyle\min_n\{t_{O(6n^2)}\leq t_{O(32nlog(n) + 5n)}\}
minn{tO(6n2)≤tO(32nlog(n)+5n)}\displaystyle\min_n\{t_{O(6n^2)}\leq t_{O(32nlog(n) + 5n)}\}

Encontrar

6n^2 = 32nlog(n) + 5n
6n2=32nlog(n)+5n6n^2 = 32nlog(n) + 5n
\frac{6n-5}{32}=log(n)
6n−532=log(n)\frac{6n-5}{32}=log(n)
e^{\frac{6n-5}{32}}=n
e6n−532=ne^{\frac{6n-5}{32}}=n
-\frac{6n}{32}e^{-\frac{6n}{32}}=-\frac{6}{32}e^{-\frac{5}{32}}
−6n32e−6n32=−632e−532-\frac{6n}{32}e^{-\frac{6n}{32}}=-\frac{6}{32}e^{-\frac{5}{32}}

Solución

\Leftrightarrow
⇔\Leftrightarrow
n=-\frac{32}{6}W(-\frac{6}{32}e^{-\frac{5}{32}})
n=−326W(−632e−532)n=-\frac{32}{6}W(-\frac{6}{32}e^{-\frac{5}{32}})
n = 1.039392
n=1.039392n = 1.039392
\Leftrightarrow
⇔\Leftrightarrow
\Leftrightarrow
⇔\Leftrightarrow
\Leftrightarrow
⇔\Leftrightarrow
\Rightarrow
⇒\Rightarrow

Solución (¿Única?)

Soluciones

1.039392

n \approx
n≈n \approx

15.425424

n \approx
n≈n \approx

Grandes valores de n

Grandes Valores de n

En esta sección se compara el desempeño de los algoritmos de ordenamiento de inserción directa y mezcla para grandes valores de n.

Mezcla

  • 100,000


  • 1,000,000


  • 10,000,000

9.9338 seg.

1315.5625 seg.

198485.84985 seg.

55.13 hr.

\approx
≈\approx

21.92 min.

\approx
≈\approx

Grandes Valores de n

Inserción

  • 10,000


  • 100,000


  • 1,000,000

46.15705 seg.

4624.5704 seg.

77.07 min.

\approx
≈\approx
\infty
∞\infty

Tabla de complejidad

aaaaaaa

1 segundo 1 minuto 1 hora 1 día 1 mes 1 año 1 siglo

Gracias

Analisis Algoritmos

By Luis Roman

Made with Slides.com

Analisis Algoritmos

  • 1,269

More from Luis Roman