Área que visa determinar a complexidade (custo) de um algoritmo, com isso é possível: Comparar algoritmos: existem algoritmos que resolvem o mesmo tipo de problema. Determinar se o algoritmo é ótimo : os algoritmos apresentam um limite inferior para a sua complexidade (definido matematicamente). Se a complexidade é ótima então está abaixo deste limite. Fonte: UFPB (http://www.slideshare.net/alexandrend/anlise-de-complexidade-de-algoritmos)
Um algoritmo serve para resolver um determinado problema, e todos os problemas têm sempre uma entrada de dados O tamanho dessa entrada (N) tem geralmente efeito direto no tempo de resposta de um algoritmo Dependendo do problema a ser resolvido, já existem algoritmos prontos ou que podem ser adaptados O problema é: qual algoritmo escolher?
Pode-se falar de dois tipos de complexidade de algoritmos : Complexidade Espacial: Quantidade de recursos utilizados para resolver o problema; Complexidade Temporal: Quantidade de tempo utilizado. Pode ser vista também como o número de instruções necessárias para resolver um determinado problema; Em ambos os casos, a complexidade é medida de acordo com o tamanho dos dados de entrada (n) Estamos mais interessados em calcular a Complexidade Temporal de um algoritmo!
Existem três perspectivas para análise de complexidade: Melhor Caso (Ω) Caso Médio (θ) Pior Caso (O) Nas três perspectivas, a função f(n) retorna a complexidade de um algoritmo com entrada de tamanho n
ANÁLISE DO MELHOR CASO Definido pela letra grega Ω(Ômega) Exprime o menor tempo de execução de um algoritmo para uma entrada de tamanho n É pouco usado, por ter aplicação em poucos casos. Ex.: O algoritmo de pesquisa sequêncial em um vetor tem complexidade f(n) = Ω(1) A análise assume que o número procurado seria o primeiro selecionado na lista. Abordagem otimista!
ANÁLISE DO CASO MÉDIO Definido pela letra grega g θ (Theta) Deve-se obter a média dos tempos de execução de todas as entradas de tamanho n, ou baseado em probabilidade de determinada condição ocorrer Ex.: O algoritmo de pesquisa sequêncial em um vetor tem complexidade f(n) = θ(n/2) Em média será necessário visitar n/2 elementos do vetor até encontrar o elemento procurado Melhor aproximação Muito difícil de determinar na maioria dos casos
ANÁLISE DO PIOR CASO Representado pela letra grega O (big O) Big O maiúsculo. Trata-se da letra grega ômicron maiúscula Baseia-se no maior tempo de execução sobre todas as entradas de tamanho n (ordem de grandeza) É o método mais fácil de se obter (o mais usado). ) Ex.: O algoritmo de pesquisa sequêncial em um vetor tem complexidade f(n) = O(n) No pior caso será necessário visitar todos os n elementos do vetor até encontrar o elemento procurado Abordagem pessimista!
A Notação O Tempo (ou espaço) é contabilizado em número de passos do algoritmo (unidade de armazenamento) Análise do algoritmo determina uma função que depende do tamanho da entrada n. à medida que n aumenta, aumenta a complexidade do algoritmo (esforço computacional) 8
A Notação O 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 9
Cálculo da complexidade do algoritmo Foi visto que, para calcular a complexidade de um algoritmo, deve-se analisar o pior caso (O(x)) A análise deve ser feita de acordo com a tabela a seguir Número de Operações Complexidade d f(n) c xf(n) f(n) + f(n) f(n) + g(n) f(n) x g(n) O(f(n)) O(f(n)) O(f(n)) O(max(f(n),g(n)) O(f(n) x g(n))
Técnicas de análise da complexidade do algoritmo Alguns princípios podem ser seguidos: 1. O tempo de execução de um comando de atribuição, de leitura ou de escrita pode ser considerado como O(1). 2. O tempo de execução de um comando de decisão é O(1); 3. O tempo para executar um looping é a soma do tempo de execução do corpo do looping, multiplicado pelo número de iterações do looping. 4. Quando o programa possui funções não recursivas, o tempo de execução de cada função deve ser computado separadamente um a um, iniciando com funções que não chamam outras funções.
Cálculo da complexidade do algoritmo Ex1 f(x)=1 + 1 + 1 + n * (n* (n* (1+ 1 + 1 + 3 ) ) ) 3+n* n * n * 6 3 + 6n 3 Desprezouse os f(x) = O(n 3 termos de ) menor grau
ORDENS DE ALGORITMOS Complexidade Constante Complexidade Linear Complexidade Logarítmica Complexidade Log Linear Complexidade Quadrática Complexidade Cúbica Complexidade Exponencial Complexidade Fatorial
COMPLEXIDADE CONSTANTE - O(1) São os algoritmos onde a complexidade independe do tamanho n de entradas É o único em que as instruções dos algoritmos são executadas um número fixo de vezes if (condição == true) then { 1+( realiza alguma operação em tempo constante 1 else { 1+( realiza alguma operação em tempo constante 1 f(x) = 1+(1)*1+(1) = 4 => O(1)
COMPLEXIDADE LINEAR O(N) Uma operação é realizada em cada elemento de entrada, ex.: pesquisa de elementos em uma lista for (i = 0; i < N; i++) { if (condição == true){ 1+( comandos de leitura, escrita ou condicionais; 1 else { 1+( comandos de leitura, escrita ou condicionais; 1 n*( f(x) = n*(1+(1)*1+(1))=> n*(2*2) = n(4) =>O(n)
COMPLEXIDADE LOGARÍTMICA - O(LOG 2 N) Ocorre tipicamente em algoritmos que dividem o problema em problemas menores int PesquisaBinaria ( int array[], int chave, int N){ ( int inf = 0; 1+ int sup = N - 1; 1+ int meio; 1 while (inf <= sup) { n*( meio = (inf+sup)/2; 1+ if (chave == array[meio]){ 1+( return meio; 1 else{ 1+( if (chave < array[meio]){ 1+( sup = meio-1; 1 else{ 1+( inf = meio+1; 1 return -1; // não encontrado 1 f(x) = (1+1+1*n*(1+1+(1)*1+(1+(1)*1+(1)))*1) = 3*n(6). Como Log 2 (6) = 3 => (Log 2 (n))
COMPLEXIDADE LOG LINEAR O(NLOG 2 N) Ocorre tipicamente em algoritmos que dividem o problema em problemas menores, porém juntando posteriormente a solução dos problemas menores. void merge(int inicio, int fim) { if (inicio < fim) { int meio = (inicio + fim) / 2; merge(inicio, meio); merge(meio + 1, fim); mesclar(inicio, meio, fim); } }
COMPLEXIDADE QUADRÁTICA O(N²) Itens são processados aos pares, geralmente com um loop dentro do outro void bubblesort(int[] a) { ( for (int i = 0; i < a.length-1; i++) { n*( for (int j = 0; j < a.length-1; j++) { n*( n( if (a[j] > a[j+1]) { 1+( swap(a, j, j+1); 3 f(x) = (n*(n*(1+(3)))) = (n*(n+4)) = n 2 +4n => O(n 2 )
COMPLEXIDADE CÚBICA O(N³) Itens são processados três a três, geralmente com um loop dentro do outros dois int dist[n][n]; 1+ int i, j, k; 1+ for ( k = 0; k < N; k++ ) n*( for ( i= 0; i< N; i++ ) n*( for ( j = 0; j < N; j++ ) n*( dist[i][j] = min( dist[i][j], dist[i][k] + dist[k][j] ); 1))) f(x) = 1+1+n*(n*(n*(1))) = 4+n 3 => O(n 3 )
COMPLEXIDADE EXPONENCIAL O(2 N ) Utilização de Força Bruta para encontrar a solução de um problema. A solução geralmente é baseada diretamente no enunciado do problema e nas definições dos conceitos envolvidos Ex.: Utilizando apenas números é possível criar 10 n senhas de n dígitos Um algoritmo de força bruta para quebrar uma dessas senhas tem complexidade O(2 n )
COMPLEXIDADE FATORIAL O(N!) Também é baseada na utilização de força bruta para encontrar a solução de um problema Consiste em testar todas as possíveis permutações existentes na solução à procura da solução ótima para o problema Ex.: Problema do Caixeiro Viajante Encontrar a rota mínima para visitar várias cidades sem repetir nenhuma É um problema base para o projeto de microchips, sequênciamento de genôma e muitas outras aplicações Não possui solução exata eficiente (Problema NP) Utilização de heurísticas para aproximar a solução ótima 22
ORDENS DE COMPLEXIDADE Imagine um computador que leva 1ms (0,00s) para executar uma operação. A tabela abaixo indica o tempo aproximado de execução de um algoritmo com diferentes ordens de complexidades para 3 tamanhos de entrada n O(n) Log 2 (n) nlog 2 (n) O(n 2 ) O(n 3 ) O(2 n ) O(n!) 16 0.016s 0.004s 0.064s 0.256s 4s 1m5s 663 anos 32 0.032s 0.005s 0.16s 1s 33s 49 dias 10 23 sec 512 0.512s 0.009s 4.608s 4m22s 37h 10 143 sec... 23
Exemplo de estudo comparativo da complexidade de algoritmos: - Dado 3 algoritmos, verificar qual deles demanda maior custo, seguindo o princípio do pior caso. Algoritmo 1: Soma de vetores: for(i=0;i<n;i++){ n*( n( S[i] = X[i] + Y[i]; 1 f(x) = n*(1) => f(x) = O(n) Então, complexidade linear (O(n))
Exemplo de estudo comparativo da complexidade de algoritmos - continuação Algoritmo 2: Soma de matrizes: for(i=0;i<n;i++){ n*( for(j=0;j<n;j++){ n*( n( C[i,j] =A[i,j] + B[i,j]; 1 g(x) = n*(n*(1)) => h(x) = O(n 2 ) Então, grau de complexidade quadrática (O(n 2 ))
Exemplo de estudo comparativo da complexidade de algoritmos - continuação Algoritmo 3: Produto de matrizes: for(i=0;i<n;i++){ i< i++){ n*( for(j=0;j<n;j++){ n*( P[i,j] =0; 1+ for(k=0;k<n;k++){ ; n*( P[i,j] = P[i,j] + A[i,k] * B[k,j] 1 h(x) n*(n*(1+n*(1))) n*(n*(1+n)) n*(n+n 2 ) n*(n 2 ) >h(x) O(n 3 ) h(x) = n*(n*(1+n*(1))) = n*(n*(1+n)) = n*(n+n 2 ) = n*(n 2 )=>h(x)= O(n 3 ) Então, grau de complexidade cúbica (O(n 3 ))
Exemplo de estudo comparativo da complexidade de algoritmos - continuação Comparando agora os três algoritmos dos exemplos anteriores, temos: f(x)+g(x)+h(x) ( )+h( ) = max(o(n),o(n 2 )O( ),O(n 3 )) Dessa forma, concluímos que o algoritmo que teve o maior custo foi o do exemplo 3 (h(x) = O(n 3 )), pois o expoente do grau de complexidade (n) é o maior é o maior deles (expoente 3). Então, seu grau de complexidade resultante é cúbico. 27
Exercícios Informe a complexidade dos algoritmos abaixo: 1. int a,b, aux; scanf( %d%d,&a,&b); aux = a; a = b; b = aux; printf( %d, %d,a,b);
Exercícios 2. float media, notas[100]; int i, soma = 0, media; for(i=0;i<=100;i++) { printf( entre com a nota ); scanf( %d,¬as[i]); soma = soma + notas[i]; } media = soma/100; printf( A media é: %d, media);
Exercícios 3. for(i=0;i<=n_lin1;i++) { for(j=0;j<=n_col2;j++) { C[i,j] = 0; for(k=0;k<=n_col1;k++) { C[i,j] = C[i,j] + A[i,k] * B[k,j]; } } }
Exercícios 4. for(j=1;j<=n;j++){ for(k=1;k<=n;k++){ p=p+1; } }
Exercícios Faça agora um estudo comparativo e determine qual ou quais dos 4 algoritmos do exercícios anterior tem a maior complexidade
Exercícios Prova de concursos: (ENADE-2005-Q15) - Considere o algoritmo que implementa o seguinte processo: uma coleção desordenada de elementos é dividida em duas metades e cada metade é utilizada como argumento para a reaplicação recursiva do procedimento. Os resultados das duas reaplicações são, então, combinados pela intercalação dos elementos de ambas, resultando em uma coleção ordenada. Qual é a complexidade desse algoritmo? (A) O(n2) (B) O(n2n) (C) O(2n) (D) O(log n log n) (E) O(n log n)
UNIDADE II Introdução à Complexidade de Algoritmos FIM