Complexidade de Algoritmos e Análise de Desempenho

Assunto

1. Recursão
2. Divisão e Conquista
   • Muitos algoritmos úteis são recursivos na sua estrutura. Para resolver um problema eles chamam a si mesmos resolvendo instâncias mais simples do mesmo problema, resolvendo os subproblemas recursivamente e combinando as soluções para resorver o preblema original
   • Passos do paradigma Divisão e Conquista:

     1. Divisão

        Divide o problema em subproblemas que são instâncias menore que o problema original

     2. Conquista

        Resolve os problemas menores, onde, em alguns casos, a solução é trivial.

     3. Combinação

        Combina as soluções dos subproblemas para resolver o problema original.

   • Exemplo: Merge Sort

     • Divisão

       Divide a sequência de $n$ elementos a ser ordenada em duas subsequências de n/2 elementos cada.

     • Conquista

       Ordena as duas subsequências recursivamente, utilizando o merge sort.

     • Combinação

       Junta as duas sequências, mantendo o resultado ordenado, para produzir a resposta.

     • Note que a recursão termina quando a ordenação do array é trivial e não precisa ser executada (array de um elemento).
     • A operação chave é a combinação dos dois arrays ordenados, onde a complexidade de tempo é $\mathrm{\Theta }(n)$
   • Análise de complexidade em algoritmos de divisão e conquista
     • Podemos descrever o tempo de execução do algoritom utilizando uma equação de recorrência, que descreve o tempo de execução do problema de tamanho $n$ em termos do tempo de execução dos problemas menores.
     • Dado que $T(n)$ o tempo de execução do problema de tamanho $n$.
     • Dado que para um problema pequeno o suficiente, quando $n\le c$ para uma constante $c$, a solução trivial é executada em tempo constante, $\mathrm{\Theta }(1)$
     • Se dividirmos o problema em $a$ subproblemas, cada um com tamanho $\frac{1}{b}$ do tamanho original, e levando $D(n)$ tempo para a divisão e $C(n)$ tempo para combinar as soluções, obtemos então a equação de recorrência: $T(n)=\{\begin{array}{ll}\mathrm{\Theta }(1)& sen\le c\\ aT(n/b)+D(n)+C(n)& casocontrário\end{array}$
   • Análise do Merge Sort
     • Para simplificar a análise do merge sort, assumimos que o tamanho da entrada é uma potência de 2 $(n=2^{\mathrm{\Theta }(1)})$.
     • A cada divisão os subproblemas tem os $n$ elementos divididos em $\frac{n}{2}$ elementos.
     • Quando o subproblema tem $n=1$ elementos, a ordenação é trivial, não necessitando de nenhuma operação, logo $\mathrm{\Theta }(1)$ se $n=1$.
     • Para $n \gt 1:

       • Divisão

         Basta calcular o índice do elemento do meio do subarray, que pode ser feito em tempo constante, logo $D(n)=\mathrm{\Theta }(1)$

       • Conquista

         Recursivamente se resolve dois subprobleams ($a=2$) de tamanho $\frac{n}{2}$ ($b=2$), que contribui com $2T(\frac{n}{2})$ para o tempo de execução

       • Combinação

         Já vimos que a complexidade de tempo para combinar os elementos é $\mathrm{\Theta }(n)$, logo, $C(n)=\mathrm{\Theta }(n)$

     • Logo a recorrência para o tempo de execução do pior caso do merge sorte é dada por: $T(n)=\{\begin{array}{ll}\mathrm{\Theta }(1)& sen=1\\ 2T(n/2)+\mathrm{\Theta }(n)& sen>1\end{array}$

     • Intuitivamente, podemos resolver essa recorrência. Reescrevemos a recorrência como: $T(n)=\{\begin{array}{ll}c& sen=1\\ 2T(n/2)+cn& sen>1\end{array}$

     • Sabemos que o tempo total de execução é $T(n)$, que é o tempo da combinação $cn$ somado aos tempos dos subproblemas de tamanho $\frac{n}{2}$, ou seja, $T(\frac{n}{2})$.
     • Cada subproblema $T(n/2)$ leva $\frac{cn}{2}$ mais $T(n/4)$, e assim sucessivamente até que o problema seja trivial ($n=1$) onde o custo de resolver cada um dos problemas é $c$
     • Se representarmos esse problema como uma árvore de recursão, a soma dos tempos de cada nível da árvore é $cn$, e a altura da árvore é $1+\log (n)$ (mais especificamente $1+{\log }_{2}n$)
     • Logo o tempo total de execução é $cn\log n+cn$, onde, pela análise assintótica, temos $\mathrm{\Theta }(n\log n)$.
3. Método Master
   • Podemos resolver as recorrências dos algoritmos recursivos através de:

     • Método da Substituição

       Escolhemos um limite e utilizamos indução matemática para provar que nossa escolha estava correta.

     • Método da árvore de recursão

       Convertemos a recorrência numa árvore onde os nós representam os custos de execução em cada um dos níveis da recursão e utilizamos técnicas para encotrar os limites dos somatórias para resolver a recorrência

     • Método master

       Que provê limites para recorrências do tipo $T(n)=aT(\frac{n}{b})+f(n)$, quando $a\ge 1$, $b>1$.

   • Para utilizar o método master é preciso decorar três casos, e, com isso, você consegue determinar os limites assintóticos para diversas recorrências.
   • O método master depende do Teorema Master:
     • Sejam $a\ge 1$ e $b>1$ constantes, seja $f(n)$ uma função, e $T(n)$ definido para inteiros não-negativos pela recorrência $T(n)=aT(\frac{n}{b})+f(n)$, onde $\frac{n}{b}$ significa $\lceil \frac{n}{b}\rceil$ ou $\lfloor \frac{n}{b}\rfloor$,
     • Então $T(n)$ tem os seguintes limites assintóticos:

       • Caso 1

         Se $f(n)=O(n^{{\log }_{b}a-ϵ})$ para alguma constante $ϵ>0$, então $T(n)=\mathrm{\Theta }(n^{{\log }_{b}a})$

         ou seja, o tempo de resolver os subproblemas se sobropõe ao tempo de dividir/combinar.

       • Caso 2

         Se $f(n)=\mathrm{\Theta }(n^{{\log }_{b}a}{\log }^{k}n)$, então $T(n)=\mathrm{\Theta }(n^{{\log }_{b}a}{\log }^{k+1}n)$

         ou seja, os tempos de resolver os subproblemas e de dividir/combinar são semelhantes. $T(n)=\mathrm{\Theta }(n^{{\log }_{b}a}\log n)=\mathrm{\Theta }(f(n)\log n)$

       • Caso 3

         Se $f(n)=\mathrm{\Omega }(n^{{\log }_{b}a+ϵ})$ para alguma constante $ϵ>0$, e se $af(\frac{n}{b})\le cf(n)$ para alguma constante $c<1$ e todo $n$ suficientemente grande, então $T(n)=\mathrm{\Theta }(f(n))$

         ou seja, o tempo de dividir/combinar se sobrepõe ao tempo de resolver os subproblemas.

   • Para os casos entre o caso 2 e 3, temos as seguintes extensões:

     • Caso 2a

       Se $f(n)=\mathrm{\Theta }(n^{{\log }_{b}a-ϵ}{\log }^{k}n)$ para $k>-1$, então $T(n)\mathrm{\Theta }(n^{{\log }_{b}a-ϵ}{\log }^{k+1}n)$

     • Caso 2b

       Se $f(n)=\mathrm{\Theta }(n^{{\log }_{b}a-ϵ}{\log }^{k}n)$ para $k=-1$, então $T(n)\mathrm{\Theta }(n^{{\log }_{b}a-ϵ}\log \log n)$

     • Caso 2c

       Se $f(n)=\mathrm{\Theta }(n^{{\log }_{b}a-ϵ}{\log }^{k}n)$ para $k<-1$, então $T(n)\mathrm{\Theta }(n^{{\log }_{b}a-ϵ})$

   • Exemplos de aplicação do método master
     • $T(n)=9T(\frac{n}{3})+n$
       • a = 9
       • b = 3
       • $f(n)=n$
       • Onde temos que $n^{{\log }_{b}a}=n^{{\log }_{3}9}=\mathrm{\Theta }(n^2)$
       • Como $f(n)=O(n^{{\log }_{3}9})$, com $ϵ=1$, podemos aplicar o caso 1
       • Logo $T(n)=\mathrm{\Theta }(n^2)$
     • $T(n)=T(\frac{2n}{3})+1$
       • a = 1
       • b = $\frac{3}{2}$
       • $f(n)=1$
       • Onde temos que $n^{{\log }_{b}a}=n^{{\log }_{\frac{3}{2}}1}=n^0=1$
       • Como $f(n)=\mathrm{\Theta }(1)$ podemos aplicar o caso 2
       • Logo $T(n)=\mathrm{\Theta }(\log n)$
     • $T(n)=3T(\frac{n}{4})+n\log n$
       • a = 3
       • b = 4
       • $f(n)=n\log n$
       • Onde temos que $n^{{\log }_{b}a}=n^{{\log }_{4}3}=O(n^{0.793})$
       • Como $f(n)=\mathrm{\Omega }(n^{{\log }_{4}3+ϵ})$, onde $ϵ\approx 0.2$ podemos aplicar o caso 3, caso possamos mostrar que a condição de regularidade é valida para $f(n)$.
       • Para um $n$ suficientemente largo, temos $af(\frac{n}{b})=3(\frac{n}{4})\log (\frac{n}{4})\le (\frac{3}{4})n\log n=cf(n)$ para $c=\frac{3}{4}$.
       • Logo, podemos aplicar o caso 3, e $T(n)=\mathrm{\Theta }(n\log n)$
     • $T(n)=2T(\frac{n}{2})+n\log n$
       • a = 2
       • b = 2
       • $f(n)=n\log n$
       • $n^{{\log }_{b}a}=n$
       • Aparentemente, poderíamos aplicar o caso 3, uma vez que $f(n)=n\log n$ é assintóticamente maior que $n^{{\log }_{b}a}=n$, porém não é polinomialmente maior.
       • A razão $\frac{f(n)}{n^{{\log }_{b}a}}=\frac{(n\log n)}{n}=\log n$, que é assintoticamente menor que $n^{ϵ}$ para qualquer $ϵ$ positivo e constante, porém não é polinomialmente maior.
       • Porém, podemos aplicar o caso 2a, uma vez que $k=1$, logo temos $T(n)=\mathrm{\Theta }(n^{{\log }_{2}2}{\log }^{1+1}n)=\mathrm{\Theta }(n{\log }^{2}n)$
4. Árvores Binárias de Pesquisa
   • Regra de criação:
     • insert(node.left, k) if k < node.key else insert(node.right, k)
   • Complexidade do pior caso:
     • Inserção: $O(n)$
     • Exclusão: $O(n)$
     • Busca: $O(n)$
   • Complexidade do melhor caso:
     • Inserção: $O(\log n)$
     • Exclusão: $O(\log n)$
     • Busca: $O(\log n)$
   • Árvores Binárias de Pesquisa auto-balanceáveis
     • Árvores AVL
       • Algoritmos:

         • Inserção

           após a inserção na BST, os nós, a partir do nó-pai do nó inserido, tem os fatores de balanceamento corrigidos até que a altura do nó não se altere, ou seja corrigida a raiz da árvore.

         • Exclusão

           após a exclusão na BST, os nós, a partir do nó-pai do nó removido, tem os fatores de balanceamento corrigidos até que a altura do nó não se altere, ou seja corrigida a raiz da árvore.

         • Validação de um nó AVL:
           • Fator de Balanceamento: $FB=H(left)-H(right)$

           • Fator de balanceamento válido: $

             FB

             \lt 2$

         • Correção do nó AVL:

           if FB(node) == -2:
             if FB(node.left) == +1:
             rotate_left(node.left)
             rotate_right(node)
           if FB(node) == +2:
             if FB(node.right) == -1:
             rotate_right(node.right)
             rotate_left(node)
           

       • Complexidade:
         • Busca: $\mathrm{\Theta }(\log n)$
         • Inserção: $\mathrm{\Theta }(\log n)$
         • Exclusão: $\mathrm{\Theta }(\log n)$
       • Rotações: $O(\log n)$
     • Outros modelos:
       • Árvores Red-Black
       • B-Trees
   • Binary Search Sorting
     • Complexidade de tempo quando se utiliza uma árvore auto-balanceável…
     • Assumindo uma máquina de ponteiros:$\mathrm{\Theta }(n\log n)$
       • Utiliza ponteiros, e cada nó deve armazenar meta dados da estruturas
     • Assumindo uma máquina de acesso aleatório: $O(n\log n),amortizado$
       • Cada posiçõa deve armazenar meta dados da estruturas

Questões

1. Implemente uma árvore binária de pesquisa.
2. Implemente uma árvore binária de pesquisa do tipo AVL.
3. Implemente uma função que verifica se uma sub-árvore é uma árvore AVL válida, com a interface is_valid_avl(node). Qual a complexidade de tempo dessa função?

Recursos para essa aula

Bibliografia

1. Cormen, E. et al. Introduction to Algorithms. Caps. 2 e 3.
2. Master Theorem (Analysis of Algorithms)
3. Árvores AVL (Wikipedia)
4. AVL Trees (Geeks For Geeks)