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

Apresentação em tema: "Organização e Recuperação da Informação (ORI)"— Transcrição da apresentação:

1 Organização e Recuperação da Informação (ORI)
Complexidade de Algoritmos

2

3 Existem várias formas de se resolver
um problema e, portanto, várias for- mas de se construir algoritmos para resolvê-los. Comparações entre soluções Métodos para comparações Estimativas de tempo...

4 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. 

5 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.

6 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).

7 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, ...).

8 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 T(n) n

9 Conceitos Benchmark (prática) Análise (teórica)
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...

10 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.

11 Tipos de complexidade Espacial  memória Temporal  tempo
(a) tempo real (b) número de instruções

12 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).

13 Perspectivas de análise
Pior caso Caso médio Melhor caso

14 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.

15 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.

16 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.

17 Limite Superior Seja 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.

18 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. 

19 Comparando Tempo Tam. A Tam. B 1s 10 22 10s 100 70 100s 1.000 223
10.000 707 T(n)=2n2 T(n)=10n

20 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)).

21 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)

22 Exemplo Suponha que tenhamos um programa que tenha os seguintes tempos de execução: T(0) = 1; T(1) = 4; T(2) = 9 em 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.

23 Exemplo função f(n)=(n+1)2 n2 + 2.n + 1 ≤ n2 + 2.n2 + n2 ≤ 4 . n2

24 Princípios Gerais 1. Constantes não são importantes
Se 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)

25 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 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 ( n3) Seja n0 = 0 e c = 2 / (2000) 2.n3 ≤ ( n3) ≤ 2 n3

26 Princípios Gerais Outro exemplo:
T(n) = 3 . n n4 – 4 . n3 + n + 1 3.n n4 – 4.n3 + n + 1 ≤ 3.n n5 + n5 + n5 ≤ 15 n5 Constatando através das proporções... 3 n n é O(n2) p/ n = 10  73.2%; 24.4% e 2.4% p/ n = 100  96.7%; 3.2%; ...

27 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.

28 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 = 1024 103 = 1000

29 Princípios Gerais Tabela O(1) Constante O(log n) Logarítmica
O(n) Linear O(n log n) n log n O(n2) Quadrática O(n3) Cúbica O(2n) Exponencial

30 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.

31 Analisando tempo de execução
Comandos simples  atribuição, leitura, escrita... O(1) Exemplo: a  1 leia (x) escreva (z)

32 Analisando tempo de execução
Repetiçõ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ça Para j  1 até n faça a[i][j]  i*j Como tem-se outro loop (externo): n . O(n) = O(n2)

33 Analisando tempo de execução
Repetiçõ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ça i  i + 1 O(n)

34 Analisando tempo de execução
Comandos 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*j senão a[i][j]  10 Quando não se tem idéia do que acontecerá  assumir pior caso

35 Analisando tempo de execução
Procedimentos 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...

36 Analisando tempo de execução
Procedimentos Recursivos Aná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)

37 Analisando tempo de execução
Induçã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 + a T(3) = b + T(2) = b + b + a = 2.b + a T(4) = b + T(3) = b + 2.b + a = 3.b + a ... T(n) = (n-1).b + a O(1)

38 Analisando tempo de execução
Substituiçã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

39 Analisando tempo de execução
Substituiçã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)

40 Classificação e Pesquisa
Métodos de Classificação Bolha Inserção Quicksort Mergesort Pesquisa Seqüêncial Binária

41 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.

42 Classificação - Bolha

43 Classificação - bolha Algoritmo Para passo  1 até n-1 faça
Para pos  1 até n-1 faça Se 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)

44 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

45 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.

46 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.

47 Classificação – mergesort
Mergesort(vetor a[]; inteiro p, r) Inicio Se (p < r) então q  (p + r) / 2; mergesort(a, p, q) mergesort(a, q+1, r); unir(a, p, q, r); Fim_se Fim

48 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

49 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

50 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.

51 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.

52 Classificação - Quicksort
Exemplo (p=1 e r=8). Elegemos (arbitrariamente) o primeiro elemento do vetor (neste caso o valor 8) para ser o “pivô". Com isso temos dois novos subvetores: e Neste exemplo a função particionar retornaria q=7 (o índice no vetor onde terminou o primeiro subvetor).

53 Classificação - Quicksort
n 2. n/2 h 4. n/4 8. n/8 Deve-se repetir o processo de ordenação dos n elementos h vezes (altura da árvore binária). h = log n

54 Pesquisa Sequencial Binária