Organização e Recuperação da Informação (ORI)

Complexidade de Algoritmos

Existem várias formas de se resolverum problema e, portanto, várias for-mas de se construir algoritmos pararesolvê-los.

Comparações entre soluções Métodos para comparações Estimativas de tempo...

O que é complexidade?

A complexidade de um algoritmo consiste na quantidade de "trabalho" necessária para a sua execução, expressa em função das operações fundamentais, as quais variam de acordo com o algoritmo, e em função do volume de dados. 

O que é complexidade?

• Ou seja, normalmente, programas demoram mais para executar de acordo com sua estruturação de instruções e na medida em que se aumenta a quantidade de dados de entrada.

• Esta “demora” pode ser linearmente proporcional, quadrática...

• Em alguns casos, o tempo de execução não depende somente da quantidade de dados, mas sim de sua forma.

Para que?

Para permitir a comparação teórica de soluções diferentes para o mesmo problema e identificar as melhores soluções (eficiência).

Exemplo

Suposição: uma operação leva 1 ms para ser efetuada. A tabela a seguir apresenta o tempo necessário p/ resolver um mesmo problema de cinco maneiras diferentes.

Podemos pensar no “conceito” T(n), que é apresentado na tabela, como sendo o número de comandos executados por um programa (Pascal, C, ...).

Tabela

A1 A2 A3 A4 A5

n n log n n2 n3 2n

16 0.016s 0.064s 0.256s 4s 1m4s

32 0.032s 0.16s 1s 33s 46 dias

512 0.512s 9s 4m22s 1dia +

13h

1037

séculos

n

T(n)

Conceitos

• Benchmark (prática)– Quando se compara 2 ou mais programas projetados

para resolver a mesma tarefa, normalmente um conjunto padrão de dados é reservado para avaliar o desempenho da solução. Isso significa que este conjunto deve ser representativo do universo de dados aos quais o programa estará exposto e pode servir como referência de teste para outras soluções.

• Análise (teórica)• Exemplos : reconhecimento de face, fala...

Consideração sobre Benchmark

Supondo que tenhamos escrito, depurado e testado um programa e que tenhamos selecionado um particular conjunto de dados de entrada para executa-lo. Ainda assim, dependemos da configuração do computador a ser utilizado e da eficiência do compilador.

Tipos de complexidade

Espacial memória

Temporal tempo

(a) tempo real

(b) número de instruções

Regra 90-10

• Muitos programas executam um pequeno conjunto de instruções muitas vezes (90% do tempo de execução em 10% do código).

Perspectivas de análise

• Pior caso

• Caso médio

• Melhor caso

Perspectivas de análise

Pior caso

Este método é normalmente representado por O ( ). Por exemplo, se dissermos que um determinado algoritmo é representado por g(x) e a sua complexidade no pior caso é n, será representada por g(x) = O(n).Consiste, basicamente, em assumir  o pior dos casos que podem acontecer, sendo muito usado e sendo normalmente o mais fácil de se determinar.

Perspectivas de análise

Caso médio

Representa-se por θ().Este método é, dentre os três, o mais difícil de se determinar pois necessita de análise estatística (muitos testes). No entanto, é muito usado pois é também o que representa mais corretamente a complexidade do algoritmo.

Perspectivas de análise

Melhor caso

Representa-se por Ω ( )

Método que consiste em assumir que vai acontecer o  melhor. Pouco usado. Tem aplicação em poucos casos.

Limite SuperiorSeja dado um problema, por exemplo, multiplicação de duas matrizes quadradas de ordem n (n*n). Conhecemos um algoritmo para resolver este problema(pelo método trivial) de complexidade O(n3). Sabemos assim que a complexidade deste problema não deve superar O(n3), uma vez que existe um algoritmo desta complexidade que o resolve. Um limite superior ( upper bound ) deste problema é O(n3). O limite superior de um algoritmo pode mudar se alguém descobrir um algoritmo melhor. Isso de facto aconteceu com o algoritmo de Strassen que é de O(n log 7). Assim o limite superior do problema de multiplicação de matrizes passou a ser O (nlog 7). Outros pesquisadores melhoraram ainda mais este resultado. Atualmente, o melhor resultado é o de Coppersmith e Winograd de O (n 2.376).O limite superior de um algoritmo é parecido com o record mundial de uma modalidade de atletismo. Ele é estabelecido pelo melhor atleta ( algoritmo ) do momento. Assim como o record mundial o limite superior pode ser melhorado por um algoritmo ( atleta ) mais veloz.

Limite InferiorÀs vezes é possível demonstrar que para um dado problema, qualquer que seja o algoritmo a ser usado o problema requer pelo menos um certo número de operações. Essa complexidade é chamada Limite inferior (Lower Bound). Veja que o limite inferior dependo do problema mas não do particular algoritmo. Usamos a letra Ω em lugar de O para denotar um limite inferior.

Para o problema de multiplicação de matrizes de ordem n, apenas para ler os elementos das duas matrizes de entrada leva O(n2). Assim uma cota inferior trivial é Ω(n2).Na analogia anterior, um limite inferior de uma modalidade de atletismo não dependeria mais do atleta. Seria algum tempo mínimo que a modalidade exige, qualquer que seja o atleta. Um limite inferior trivial para os 100 metros seria o tempo que a velocidade da luz leva a percorrer 100 metros no vácuo.Se um algoritmo tem uma complexidade que é igual ao limite inferior do problema então o algoritmo é ótimo.O algoritmo de CopperSmith e Winograd é de  O(n2.376) mas o limite inferior é de Ω(n2). Portante não é ótimo. É possível que este limite superior possa ainda ser melhorado. 

Comparando

Tempo Tam. A

Tam.

B

1s 10 22

10s 100 70

100s 1.000 223

1.000s 10.000 707

T(n)=2n2

T(n)=10n

Teoria

Seja T(n) o tempo de execução de um programa, medido em função do tamanho do conjunto de entrada n.

n é um valor não negativo T(n) é um valor não negativo V n

Seja f(n) outra função também definida no conjunto dos inteiros não negativos. Se T(n) é no máximo uma constante vezes f(n) – excetuando-

se, possivelmente, alguns valores pequenos de n – pode-se dizer que T(n) é O(f(n)).

Teoria

• Definição formal– T(n) é O(f(n)) se existe um inteiro n0 e uma

constante c (c > 0) | V n > n0 T(n) ≤ c. f(n)

Exemplo

Suponha que tenhamos um programa que tenha os seguintes tempos de execução:

T(0) = 1; T(1) = 4; T(2) = 9em geral podemos resumir em T(n)=(n+1)2

Assim, teríamos que T(n) é O(n2) Prova: Pela definição tem-se que se escolhermos uma constante c e um valor n0 tais que T(n) ≤ c . n2, então T(n) será O(n2).

Para c = 4 e n0 > 1 temos esta relação.

Exemplo

função f(n)=(n+1)2

n2 + 2.n + 1 ≤ n2 + 2.n2 + n2

≤ 4 . n2

Princípios Gerais

1. Constantes não são importantesSe T(n) é O(d .T(n)) para qualquer d > 0

e se

n0 = 0 e c ≥ 1/d Então

T(n) ≤ c . (d . T(n))≤ c . d . T(n)≤ 1 . T(n)

Princípios Gerais

2. Termos de ordem menor não são importantes.Seja T(n) um polinômio da forma:

ak.nk + ak-1.nk-1 + ... + a1.n + a0 (ak>0)

Seja n0 = 1 e c = ∑ ai se ai > 0 T(n) não é superior a c.T(n)Exemplo: 2 . n3 é O (0.001 . n3)

Seja n0 = 0 e c = 2 / 0.001 (2000)2.n3 ≤ 2000 . (0.001 . n3)

≤ 2 n3

Princípios Gerais

Outro exemplo:

T(n) = 3 . n5 + 10 . n4 – 4 . n3 + n + 1

3.n5 + 10.n4 – 4.n3 + n + 1 ≤ 3.n5 + 10.n5 + n5 + n5

≤ 15 n5

Constatando através das proporções...

3 n2 + 10 n + 10 é O(n2)

p/ n = 10 73.2%; 24.4% e 2.4%

p/ n = 100 96.7%; 3.2%; ...

Princípios Gerais

A eliminação de elementos de menor ordem é conseqüência do fato de que o que é realmente importante é a taxa de crescimento e não o valor exato de T(n).

Desta forma, T(n) = 2n + n3 tem como resultado a avaliação de que T(n) = O(2n) pois n3/2n tende a zero à medida que n cresce.

Princípios Gerais

T(n) = 2n + n3 tem como resultado a avaliação de que T(n) = O(2n)

Prova: Seja n0=10 e c = 2. Deve-se provar que para n ≥ 10 tem-se que 2n + n3 ≤ 2. 2n

Subtraindo-se 2n de ambos os lados temos: n3 ≤ 2n (2 – 1)Para n = 10 tem-se que

210 = 1024103 = 1000

Princípios Gerais

TabelaO(1) ConstanteO(log n) LogarítmicaO(n) LinearO(n log n)n log nO(n2) QuadráticaO(n3) CúbicaO(2n) Exponencial

Princípios Gerais

A relação de big-oh (O) é importante para se estabelecer a relação de ≤ entre as funções. Existem outras definições dentro da análise de algoritmos que apresentam outras relações.

Analisando tempo de execução

Comandos simples

atribuição, leitura, escrita... O(1)

Exemplo:

a 1

leia (x)

escreva (z)

Analisando tempo de execuçãoRepetições

Os limites superiores (loops determinados) indicam o limite superior do número de vezes que os comandos dentro do loop serão repetidos.Exemplo 1: Para j 1 até n faça

a[j] j Como atribuição é O(1) tem-se: n . O(1) = O(n)

Exemplo 2: Para i 1 até n façaPara j 1 até n faça

a[i][j] i*jComo atribuição é O(1) tem-se: n . O(1) = O(n)Como tem-se outro loop (externo): n . O(n) = O(n2)

Analisando tempo de execuçãoRepetições (while e repeat)

Não têm limite superior (indeterminado). Deve-se detectar um limite superior (pior caso).Exemplo 1: i 1

Enquanto i <> a[i] façai i + 1

O(n)

Analisando tempo de execuçãoComandos condicionais

Normalmente o comando condicional é O(1) – a menos que tenha uma chamada de função. Assim, as partes então e senão do comando devem ser analisadas individualmente e uma estimativa deve ser atribuída ao conjunto.Exemplo 1: Se a[1][1] = 0 então

Para i 1 até n faça Para j 1 até n faça

a[i][j] i*jsenão

Para j 1 até n façaa[i][j] 10

Quando não se tem idéia do que acontecerá assumir pior caso

Analisando tempo de execuçãoProcedimentos

Se todos os procedimentos são não recursivos, pode-se começar a computar o tempo de todo o programa à partir dos procedimentos que não chamam outros. Parte-se, então, para aqueles que utilizam os procedimentos cujos valores já foram calculados... E assim por diante...

Analisando tempo de execuçãoProcedimentos RecursivosAnálise um pouco mais difícil.

função fatorial (n)

se n ≤ 1 então

fatorial 1

senão

fatorial n . fatorial (n-1)

O(1)

2.O(1) + O(n-1)

Analisando tempo de execuçãoIndução T(n) = O(1) + T(n-1)

Caso base : T(1) = O(1) = a

Indução: T(n) = b + T(n-1)T(2) = b + T(1) = b + aT(3) = b + T(2) = b + b + a = 2.b + aT(4) = b + T(3) = b + 2.b + a = 3.b + a...T(n) = (n-1).b + a

O(1)

Analisando tempo de execuçãoSubstituição repetida

T(m) = b + T(m-1) m > 1

T(n) = b + T(n-1)

T(n-1) = b + T(n-2)

...

T(2) = b + T(1)

T(1) = a

Analisando tempo de execuçãoSubstituição repetida

T(n) = b + b + T(n-2)

T(n) = b + b + b + T(n-3)

T(n) = b + b + b + b + T(n-4)

T(n) = 3.b + T(n-3) ou 4.b + T(n-4)

...

T(n) = (n-1).b + T(n-(n-1)) = (n-1).b + a

T(n-1)

T(n-2)

T(n-3)

Classificação e Pesquisa

Métodos de ClassificaçãoBolhaInserçãoQuicksortMergesort

PesquisaSeqüêncialBinária

Classificação - bolha

O algoritmo da bolha, ou em Inglês, Bubblesort, efetua a ordenação através de trocas entre pares de números sucessivos.

Classificação - Bolha

25 57 48 37 12 92 86 33

25 57 48 37 12 92 86 33

25 57 48 37 12 92 86 33

25 48 57 37 12 92 86 33

25 48 57 37 12 92 86 33

25 48 37 57 12 92 86 33

25 48 37 57 12 92 86 33

25 48 37 12 57 92 86 33

25 48 37 12 57 92 86 33

25 48 37 12 57 86 92 33

25 48 37 12 57 86 33 92

25 48 37 12 57 86 92 33

Classificação - bolha

AlgoritmoPara passo 1 até n-1 faça

Para pos 1 até n-1 façaSe x[pos] > x [pos+1] então

troca(x[pos],x[pos+1])Fim_se

Análise:(n-1) . (n-1) = n2 + 2.n + 1 O(n2)

Classificação - Inserção

O algoritmo de ordenação por inserção é bastante simples e eficiente para uma quantidade pequena de números. A idéia de funcionamento é semelhante ao ordenamento de cartas de baralho na mão de um jogador. A mão esquerda começa "vazia" e a mão direita insere uma "carta" de cada vez na posição correta. Ao final, quando todas as "cartas" foram inseridas, elas já estão ordenadas. Para encontrar, durante a inserção, a posição correta para um valor, compara-se este valor um-a-um com as cartas já na mão esquerda, até encontrarmos a posição correta. Exercício: fazer o algoritmo

Classificação – mergesort

A idéia de “aceleração” por trás do algoritmo de Mergesort (e também do Quicksort) é que é mais rápido ordenar 2 seqüências de n/2 números do que uma seqüência de n números (dividir p/ conquistar). A complexidade do Mergesort é proporcional a n . log n, onde log n é o logaritmo de base 2 do número n.

Classificação – mergesort

Neste algoritmo, recursivamente, divide-se a seqüência de números a ser ordenada em 2 subseqüências. Ordena-se cada uma delas e, posteriormente, combinam-se os resultados.

Classificação – mergesort

Mergesort(vetor a[]; inteiro p, r) Inicio

Se (p < r) entãoq (p + r) / 2; mergesort(a, p, q)mergesort(a, q+1, r); unir(a, p, q, r);

Fim_seFim

Classificação - Quicksort

Quicksort é na maioria das vezes a melhor opção prática para ordenação porque ele é muito eficiente na média. O tempo esperado de execução também é proporcional a n . log n

Classificação - Quicksort

procedimento QuickSort (vetor A; inteiros p, r) Inteiro q Inicio     Se p < r então     Inicio_se         q particionar(A,p,r)         QuickSort(A,p,q)         QuickSort(A,q+1,r)     Fim_se Fim

Classificação - Quicksort

A parte não-trivial do Quicksort é a função particionar que divide o vetor original em 2 sub-vetores de maneira que o primeiro não contenha nenhum valor maior do que o segundo.

Classificação - Quicksort

Para ordenar um array A[p..r] o procedimento é o seguinte:– O vetor A[p..r] é dividido em 2 sub-vetores A[p..q] e

A[q+1..r] de tal forma que cada elemento de A[p..q] é menor ou igual a cada elemento de A[q+1..r]. O índice q é calculado como parte deste procedimento de divisão;

– Os 2 sub-vetores A[p..q] e A[q+1..r] são ordenados através de chamadas recursivas ao Quicksort.

Classificação - Quicksort

Exemplo (p=1 e r=8). 8 2 5 7 1 -3 4 12 22 15 9

• Elegemos (arbitrariamente) o primeiro elemento do vetor (neste caso o valor 8) para ser o “pivô". Com isso temos dois novos subvetores:

2 5 7 1 -3 4 8 e 12 22 15 9• Neste exemplo a função particionar

retornaria q=7 (o índice no vetor onde terminou o primeiro subvetor).

Classificação - Quicksortn

2. n/2

4. n/4

8. n/8

h

Deve-se repetir o processo de ordenação dos n elementos h vezes (altura daárvore binária). h = log n

Pesquisa

• Sequencial

• Binária