Área que visa determinar a complexidade (custo) de um algoritmo, com isso é possível:

Transcrição

1 Á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 (

2 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?

3 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!

4 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

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

6 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

7 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!

8 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

9 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

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

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

12

13 Cálculo da complexidade do algoritmo Ex1 f(x)= n * (n* (n* ( ) ) ) 3+n* n * n * n 3 Desprezouse os f(x) = O(n 3 termos de ) menor grau

14 ORDENS DE ALGORITMOS Complexidade Constante Complexidade Linear Complexidade Logarítmica Complexidade Log Linear Complexidade Quadrática Complexidade Cúbica Complexidade Exponencial Complexidade Fatorial

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

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

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

18 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); } }

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

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

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

22 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

23 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!) s 0.004s 0.064s 0.256s 4s 1m5s 663 anos s 0.005s 0.16s 1s 33s 49 dias sec s 0.009s 4.608s 4m22s 37h sec... 23

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

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

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

27 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

28 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);

29 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,&notas[i]); soma = soma + notas[i]; } media = soma/100; printf( A media é: %d, media);

30 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]; } } }

31 Exercícios 4. for(j=1;j<=n;j++){ for(k=1;k<=n;k++){ p=p+1; } }

32 Exercícios Faça agora um estudo comparativo e determine qual ou quais dos 4 algoritmos do exercícios anterior tem a maior complexidade

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

34 UNIDADE II Introdução à Complexidade de Algoritmos FIM