Complexidade de Algoritmos

Complexidade de Algoritmos! Uma característica importante de qualquer algoritmo é seu tempo de execução! é possível determiná-lo através de métodos empíricos, considerando-se entradas diversas! é também possível obter este tempo a partir de métodos analíticos 1

Complexidade de Algoritmos! Métodos analíticos! objetivo: determinar uma expressão matemática que traduza o comportamento de tempo de um algoritmo.! o tempo de execução independente:! do método utilizado! da linguagem e compiladores empregados! e das condições locais de processamento 2

Complexidade de Algoritmos! obter uma expressão matemática não é simples, mesmo considerando uma expressão aproximada! Várias simplificações são introduzidas! quantidade de dados a serem manipulados pelo algoritmo é suficientemente grande! quantidade de dados de entrada reduzida não serão considerados 3

Complexidade de Algoritmos! somente o comportamento assintótico é avaliado! não serão consideradas constantes aditivas ou multiplicativas na expressão considerada 4

Complexidade de Algoritmos! Qual a variável em relação à qual a expressão matemática avaliará o tempo de execução?! Um algoritmo funciona a partir de uma entrada para produzir uma saída dentro de um tempo! fornecer o tempo de execução em função da entrada 5

Complexidade de Algoritmos! O processo de execução de um algoritmo pode ser dividido em etapas elementares - passos! um número fixo de operações básicas cujo tempo de execução é considerado constante! a operação básica de maior freqüência de execução do algoritmo é denominada operação dominante 6

Complexidade de Algoritmos! expressão de tempo de execução! obtida a menos de constantes aditivas e multiplicativas:! número de passos! número de execuções da operação dominante! A expressão matemática de avaliação do tempo de execução de um algoritmo! função que fornece o número de passos efetuados no algoritmo a partir de uma certa entrada 7

Complexidade de Algoritmos! Por exemplo: algoritmos para ordenar os elementos de uma seqüência dada! cada passo corresponde a comparação entre dois elementos da seqüência! O número de passos de um algoritmo! informação necessária para avaliar seu comportamento no tempo 8

Complexidade de Algoritmos! Inversão de uma seqüência fim = n/2; (++ i for (i=0; i<fim; { temp = S[i]; S[i] = S[n-1-i]; S[n-1-i] = temp; } 9

Complexidade de Algoritmos! n = 5 troca S[i] por S[n-1-i]! fim = 2 ([ S[4 )! i = 0 troca S[0] por S[5-1-0] ([ S[3 )! i = 1 troca S[1] por S[5-1-1] inicial 0 1 2 3 4 M A R I A final 0 1 2 3 4 A I R A M 10

Complexidade de Algoritmos! n = 6 troca S[i] por S[n-1-i]! fim = 3 ([ S[5 )! i = 0 troca S[0] por S[6-1-0] ([ S[4 )! i = 1 troca S[1] por S[6-1-1] ([ S[3 )! i = 2 troca S[2] por S[6-1-2] inicial 0 1 2 3 4 5 final 0 1 2 3 4 5 E S T A D O O D A T S E 11

Complexidade de Algoritmos! n = 50 troca S[i] por S[n-1-i]! fim = 25 ([ S[49 )! i = 0 troca S[0] por S[50-1-0] ([ S[48 )! i = 1 troca S[1] por S[50-1-1] ([ S[47 )! i = 2 troca S[2] por S[50-1-2]... ([ S[26 )! i = 23 troca S[23] por S[50-1-23] ([ S[25 )! i = 24 troca S[24] por S[50-1-24] 12

Complexidade de Algoritmos! o algoritmo executa extamente as mesmas operações para seqüências de tamanho n! cada passo corresponde à troca de posição entre dois elementos da seqüência! a execução das três atribuições! o número de passos é igual ao número de vezes que executa o bloco for n/2, n>1 13

Complexidade de Algoritmos! Problema: determinar a soma C e o produto D de duas matrizes dadas A e B.! A = (a ij ) e B = (b ij ) ambas n x n! C e D também serão matrizes n x n! seus elementos podem ser calculados como: c ij = a ij + b ij d ij = a ik * b kj 1 k n 14

Complexidade de Algoritmos! Soma (++ i for(i=0; i<n; (++ j for(j=0; j<n; c ij = a ij + b ij ;! Produto (++ i for(i=0; i<n; for(j=0; j<n; j++){ } d ij = 0; for(k=0; k<n; k++) d ij = d ij + a ik * b kj ; 15

Complexidade de Algoritmos! Seja A um algoritmo! {E 1,...E m } o conjunto de todas as entradas possíveis de A! seja t i o número de passos efetuados por A quando a entrada for E i 16

Complexidade de Algoritmos! Complexidade do pior caso: max Ei E {t i }! Complexidade do melhor caso: min Ei E {t i }! Complexidade do caso médio: Σ 1 i m p i t i! p i é a probabilidade de ocorrência da entrada E i 17

Complexidade de Algoritmos! De forma análoga podem ser definidas complexidades de espaço de um algoritmo! complexidade tem por objetivo avaliar a eficiência de tempo ou espaço 18

Complexidade de Algoritmos! Complexidade de tempo do pior caso! para a entrada mais desfavorável! é a mais importante das três mencionadas! fornece um limite superior para o número de passos 19

Complexidade de Algoritmos! Complexidade de pior caso! Complexidade de melhor caso! de uso bem menos freqüente! em algumas situações específicas! Complexidade de caso médio! menos utilizada apesar de importante! difícil conhecer a distribuição de probabilidades das diferentes entradas 20

Recursividade! um procedimento recursivo é aquele que contém uma ou mais chamadas a si mesmo! a todo procedimento recursivo corresponde um não recursivo! os programas recursivos são mais concisos! relação direta com a prova por indução matemática 21

Recursividade! Cálculo de fatorial x! = se (x <=0) então 1 senão x * (x-1)! 22

Recursividade Implementação não recursiva x! = se x <=0 1 senão x * (x-1)! ( N int fatorial (int { int result = 1; (++ i for (i=1; i<=n; result = result * i; return (result); } 23

Recursividade Implementação recursiva x! = se x <=0 1 senão x * (x-1)! ( N int fatorial (int { ( 1 (N<= if return(1); else return( N * fatorial(n-1)); } 24

Recursividade ( 4 )! X= fatorial ( fatorial(3)! return( 4* ( fatorial(2)! return( 3* ( fatorial(1)! return( 2* ( 1 return(! 25

Análise de Recursividade! relação de recorrência! a função é definida em termos dela própria, recursivamente! substituição repetida ( N int fatorial (int { ( 1 (N<= if return(1); else return( N * fatorial(n-1)); } 26

Análise de Recursividade ( N int fatorial (int { ( 1 (N<= if return(1); else return( N * fatorial(n-1)); } 27

Análise de Recursividade ( T(n! tempo de processar o algoritmo para entrada n! número de passos ou operações dominantes Fatorial T(n) = 1, se n = 0 = T(n-1) + 1, se n > 0 mas quanto é T(n-1)? ( N int fatorial (int { ( 1 (N<= if return(1); else return( N * fatorial(n-1)); } 28

T(n) - Fatorial Passos iteração = (T(n-1)) + 1-1ª substituição = (T(n-2) + 1) + 1 = T(n-2) + 2 29

T(n) - Fatorial Passos iteração = (T(n-1)) + 1-1ª substituição = (T(n-2) + 1) + 1 = T(n-2) + 2-2ª substitição = (T(n-3) + 1) + 2 = T(n-3) + 3 30

T(n) - Fatorial Passos iteração = (T(n-1)) + 1-1ª substituição = (T(n-2) + 1) + 1 = T(n-2) + 2-2ª substitição = (T(n-3) + 1) + 2 = T(n-3) + 3-3ª substituição 31

T(n) - Fatorial Passos iteração = (T(n-1)) + 1-1ª substituição = (T(n-2) + 1) + 1 = T(n-2) + 2-2ª substitição = (T(n-3) + 1) + 2 = T(n-3) + 3-3ª substituição...... = T(n-k) + k - k-ésima substituição 32

T(n) - Fatorial! Então, T(n) = T(n-k) + k, 1 k n! se a k-ésima interação é a última, então:! n-k = 0 e T(0) = 1! Assim, n = k, e T(n) = n + 1 33

Maior elemento de uma lista maior = a[0]; (++ i for ( i =0; I < N; if (maior < a[i]) maior = a[i]; return (maior); 34

Resolva as recorrências! T(n) = 1, se n = 0 = 2 T(n-1) + 1, se n >0! T(n) = 1 se n = 1 = T(n/2) + 1 se n>1! T(n) = 1 se n = 1 = 2T(n/2) - n se n > 1 35

Qual melhor algoritmo?! Sejam A e B dois algoritmos que o resolvem o problema P, cujos tempos de execução são T A (n) e T B (n)! comportamento assintótico tamanho da entrada arbitrariamente grande ( O! caracterizado pela notação O (big 36

A notação Ο! Sejam f(n) e h(n) funções reais não negativas da variável inteira n 0! f(n) = O (h(n)) quando existir uma constante c> 0 e um valor inteiro n o tal que ( c.h(n n > n o f(n) 37

A notação Ο f(n) = 8n + 128 é O (n 2 )? f(n) c.n 2?! Seja c =1 8n + 128 n 2, então 0 n 2 8n 128 0 (n 16)(n+8) n 0 = 16 c =1, n o = 16, f (n) c.n 2 para todo n n 0 38

A notação Ο! Tempo (ou espaço) é contabilizado em número de ( armazenamento passos do algoritmo (unidade de! Análise do algoritmo determina uma função que depende do tamanho da entrada n. 10n 3 + 4n -10! à medida que n aumenta, o termo cúbico começa a dominar! A constante do termo cúbico tem relativamente a mesma importância que a velocidade da CPU 39

A notação Ο! Complexidade de pior caso! desprezar constantes aditivas ou multiplicativas! número de passos 3n será aproximado para n! interesse assintótico: termos de menor grau podem ser desprezados:! n 2 + n será aproximado para n 2! 6n 3 + 4n - 9 será aproximado para n 3 40

A notação Ο! A função atua como um limite superior assintótico da função f ( 2! f = n 2-1 f = Ο(n! f = n 2-1 f = Ο(n 3 ) ( Ο(1! f = 403 f = ( n! f = 5+2logn +3log 2 n f = Ο(log 2 ( Ο(n! f = 5+2 log n +3log 2 n f = ( n! f = 5.2 n +5n 10 f = Ο(2 41

A notação Ο! g(n), h(n) - funções reais positivas! k - constante! f 1 (n) = g(n) e f 2 (n) = h(n) ( O(h! O(g+h) = O(g) + ( O(g! O(k*g) = k O(g) = ({( h(n! f 1 (n) + f 2 (n) = O(max {g(n), (( h(n! f 1 (n) * f 2 (n) = O(g(n) * 42

A notação Ο! O algoritmo de inversão de uma seqüência:! o número de passos se mantém o mesmo para o mesmo valor de n! variável independente é n! as complexidades de pior, melhor e pior casos são iguais 43

A notação Ο! Para a inversão! efetua sempre n/2 passos então sua ( Ο(n complexidade é! Para a soma e o produto de matrizes n x n verifica-se complexidades! Ο(n 2 ) e Ο(n 3 ) respectivamente 44

A notação Ο! Para procedimentos recursivos pode-se aplicar a seguinte técnica! determina-se o número total de chamadas ao procedimento recursivo! calcula-se a complexidade de execução de uma única chamada! complexidade número de chamadas complexidade de uma chamada 45

A notação Ο! por outro lado, um outro exemplo:! duas matrizes A e B de dimensões n x n! um parâmetro x, com valores 0 ou 1! dependendo do valor de x! calcula a soma: se x =0 " A + B! ou o produto das matrizes: se x = 1" A * B 46

A notação Ο! entrada: n 2 +1 informações - tamanho O(n 2 )! se x =0 então complexidade: O(n 2 )! complexidade do melhor caso! se x = 1 então complexidade: O(n 3 )! complexidade do pior caso 47

Alguns conceitos! T (n) = O (1) : constante! T (n) = O (log log n) : super-rápido! T (n) = O (log n) : logarítmico muito bom! T (n) = O (n) : linear toda a entrada é visitada! T (n) = O (n log n) : limite de muitos problemas! T (n) = O (n 2 ) : quadrático! T (n) = O (n k ) : polinomial no tamanho da entrada! T (n) = O (k n ), O (n!), O (n n ) : exponencial ruim! 48