Setembro 2004Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro1 Projeto e Análise de...

Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro 1

Projeto e Análise de Algoritmos

Celso Carneiro Ribeirohttp://www.inf.puc-rio.br/~celso

Parte 2

Análise de Algoritmos

Análise de algoritmos

• Motivação• Análise de algoritmos• Complexidade de pior caso• Notação “O”• Aplicações• Algoritmos polinomiais• Comparação de algoritmos• Algoritmos recursivos• Algoritmos não-polinomiais• Algoritmos pseudo-polinomiais

Motivação

• Problema:– Alunos cursam disciplinas.– Cada disciplina tem uma prova.– Há um único horário em que são marcadas provas em cada

dia.– Provas de duas disciplinas diferentes não podem ser

marcadas para o mesmo dia se há alunos que cursam as duas disciplinas.

• Montar um calendário de provas:– satisfazendo as restrições de conflito e …– … minimizando o número de dias necessários para realizar

todas as provas.

Motivação

• Modelagem por conjuntos:

Motivação

• Os alunos que fazem apenas uma disciplina influem na modelagem? – Não!

• O número de alunos que cursam simultaneamente um par de disciplinas influi na modelagem? – Não!– E se o objetivo fosse minimizar o número de alunos

“sacrificados”?– Neste caso, sim!

• Este modelo pode ser simplificado?

Motivação

• Simplificação tratando-se apenas as interseções:

Considerar apenas as interseções não-vazias.

Motivação

• Simplificação com a utilização de um grafo de conflitos:

disciplinas → nós conflitos → arestas

Motivação

• Simplificação com a utilização de um grafo de conflitos:

disciplinas → nós conflitos → arestas

Modelo de dados

• As provas de um par de disciplinas não podem ser marcadas simultaneamente se existe uma aresta entre os nós que representam estas duas disciplinas.

• Outros modelos de dados: listas, árvores, conjuntos, circuitos

• Como representar em computador o modelo de dados chamado grafo?– Matriz de incidência (nó-aresta)– Matriz de adjacência (nó-nó)

Grafo = [ nós, arestas ]

Matriz de incidência

• n nós e m arestas• Memória utilizada: nm

000110000001100000011011100010100001100001

a b c d e f g

Matriz de adjacência

• Memória utilizada: n2

010100101000010001100011000101001110

A B C D E F

Listas de adjacências

• Estas matrizes são duas “estruturas de dados” que representam o mesmo modelo de dados (grafo).

• Outra estrutura de dados para grafos são as listas de adjacências.

FEDCBA B C D

A CB A FA ED FE C

Motivação

• Como montar um calendário satisfazendo as restrições de conflito?

• Marcar para o primeiro dia qualquer combinação de disciplinas sem conflitos: A, B, C, D, E, F, AE, AF, BD, BE, BF, CD, CE, DF, BDF

Motivação

• Escolher por exemplo o par de disciplinas B e E para o primeiro dia e retirá-las do grafo.

Motivação

• Escolher por exemplo o par de disciplinas B e E para o primeiro dia e retirá-las do grafo.

Motivação

• Marcar para o segundo dia qualquer combinação de disciplinas sem conflitos: A, C, D, F, AF, CD, DF

Motivação

• Escolher por exemplo o par de disciplinas D e F para o segundo dia e retirá-las do grafo.

Motivação

• Escolher por exemplo o par de disciplinas D e F para o segundo dia e retirá-las do grafo.

Motivação

• Marcar A ou C para o terceiro dia e a que sobrar para o quarto dia:

Motivação

• A solução assim construída utiliza quatro dias: B-E no primeiro dia, D-F no segundo dia, A no terceiro e C no quarto:

• Uma solução com quatro dias corresponde a colorir os nós do grafo de conflitos com quatro cores!

Motivação

• Esta solução utiliza o menor número possível de dias? ou ...• É possível montar uma solução com menos dias? ou ...• É possível colorir o grafo de conflitos com três cores?

• É impossível colorir o grafo de conflitos com menos de três cores! (por que?)

Motivação

• Como montar um escalonamento com o menor número possível de dias?

• Recordando: um subconjunto independente de um grafo é um subconjunto de nós sem nenhuma aresta entre eles.

• Logo, um conjunto de disciplinas que forma um subconjunto independente dos nós do grafo de conflitos pode ter suas provas marcadas para o mesmo dia.

• Os nós deste subconjunto independente podem receber a mesma cor.

Motivação

• Quanto mais disciplinas forem marcadas para o primeiro dia, menos disciplinas sobram para os dias seguintes e, portanto, serão necessários menos dias para realizar as provas das disciplinas restantes.

• Então, marcar para o primeiro dia as provas das disciplinas correspondentes a um subconjunto independente máximo.

• Retirar os nós correspondentes a estas disciplinas do grafo de conflitos.

• Continuar procedendo da mesma maneira, até as provas de todas as disciplinas terem sido marcadas.

Motivação

• Subconjunto independente máximo no grafo de conflito?BDF

Motivação

• Eliminar os nós B, D e F do grafo de conflitos.

Motivação

• Eliminar os nós B, D e F do grafo de conflitos.

Motivação

• Subconjunto independente máximo no grafo de conflito?CE

Motivação

• Eliminar os nós C e E do grafo de conflitos.

Motivação

• Eliminar os nós C e E do grafo de conflitos.

Motivação

• Subconjunto independente máximo no grafo de conflito?A

Motivação

• Subconjunto independente máximo no grafo de conflito?A

• Eliminar o nó A do grafo de conflitos.• Solução completa (todos nós coloridos).

Motivação

• A solução encontrada usa o número mínimo de cores para colorir o grafo, logo o número de dias para aplicar todas as provas é mínimo:

• Foi proposto um algoritmo para colorir um grafo com o menor número de cores.

Motivação

• O passo básico deste algoritmo corresponde a determinar um subconjunto independente máximo.

• Entretanto, este subproblema a ser resolvido a cada iteração (já é um problema NP-completo por si só, ou seja, cada subproblema) é computacionalmente difícil.

• Além deste procedimento ser computacionalmente difícil, é possível garantir que este algoritmo sempre encontra a solução ótima com o número mínimo de cores?– Ou demonstrar que sim, ou dar um contra-exemplo.

Motivação

• Considerando-se o grafo abaixo, qual solução seria encontrada pelo algoritmo?

DC E F

Os oito nós externos formam um subconjunto independente de cardinalidade máxima e podem todos ser coloridos com a mesma cor.

Motivação

Os oito nós externos formam um subconjunto independente de cardinalidade máxima e podem todos ser coloridos com a mesma cor.

DC E F

Motivação

DC E F

DEsta solução é ótima, ou é possível colorir este grafo com menos cores?

Sim: o grafo pode ser colorido com apenas duas cores.

Motivação

Esta solução é ótima, ou é possível colorir este grafo com menos cores?

DC E F

Sim: o grafo pode ser colorido com apenas duas cores

Motivação

• O algoritmo proposto nem sempre encontra a solução ótima (isto é, uma solução com o número mínimo de cores).

• Este algoritmo é então um algoritmo aproximado ou uma heurística para o problema de coloração de grafos.

• Algoritmos exatos vs. algoritmos aproximados:– qualidade da solução– tempo de processamento

Algoritmo

Seqüência precisa, não-ambígua de passos elementares que levam à solução de um problema.

• Definição informal, imprecisa! • Definição formal: máquina de Turing• Especificação: português

português estruturadopseudo linguagemlinguagem de

programação

Algoritmo

Passo 0: k 1Passo 1: alocar o maior número possível de provas no dia k

sem conflitoPasso 2: eliminar estas provas do grafo (nós, arestas) Passo 3: fazer k k+1 e voltar ao passo 1

• Subproblema resolvido a cada iteração: alocar o maior número possível de provas sem conflito

• Conjunto independente de cardinalidade máxima

Análise de algoritmos

• Como avaliar a eficiência de um algoritmo?

• Dados dois algoritmos para a resolução de um mesmo problema, qual é o mais eficiente?

• Quando um problema pode ser considerado como bem resolvido?

Objetivos e questões básicas:

Problema do caixeiro viajante

anosnanosn

segundossoluçãoumasoluçõesn

1680228021

• n cidades, distâncias cij

• Obter a rota de menor comprimento que parte de uma cidade, visita uma vez cada cidade e retorna à cidade inicial.– Cada solução é uma permutação circular das n cidades.

Como escolher um algoritmo?

• Algoritmo mais fácil de entender, implementar, documentar

• Algoritmo mais rápido ou eficiente

• Eficiência é uma medida objetiva:

– Memória

– I/O

– Comunicação

– Acesso a memória secundária

– Tempo → problemas grandes (crescimento assintótico)

Como escolher um algoritmo?

• É impossível processar um algoritmo/programa para todas as entradas (dados) possíveis.

• Desenvolver medidas do tempo de processamento que resumam seu comportamento para todas as entradas possíveis.

• Considerar a eficiência de um algoritmo como sendo a quantidade de tempo que usa, medida como função do tamanho da entrada.

Enfoques

• Benchmark – considerar uma pequena coleção de entradas “típicas” e considerá-la como representativa dos possíveis dados de entrada.

• Métodos analíticos – agrupar as entradas possíveis de acordo com seu tamanho

– Ordenação: n

– Matriz: m,n

– Grafo: m,n

Enfoques

• Usar uma função T(n) para representar o número de unidades de tempo utilizadas pelo algoritmo/programa quando aplicado a um problema cujo tamanho da entrada é n

– T(n) = cn

– T(n) = d + en + fn2

– T(n) número de instruções

número de operações elementares

tempo de CPU

• O tempo de processamento depende dos dados da própria entrada, não apenas do seu tamanho!

Enfoques

• T(n) = tempo {MÉDIO, MÍNIMO, MÁXIMO} de processamento calculado sobre todas as entradas de tamanho n

– Médio: mais difícil, mais realista

– Mínimo: pouca informação

– Máximo: conservador

ordenação 1 2 3 4 5 6

n=6 6 5 4 3 2 1

Exemplo: Ordenação por seleção

A[1] A[2] … A[n]

para i = 1 até n-1 façainício

smaller i para j=i+1 até n faça

se A[j] < A[smaller] então smaller j; temp A[smaller]

A[smaller] A[i] A[i] tempfim

Análise

• Contar como operações as linhas de código, executando-se atribuições, comparações,…

casopiorinfavorávelmaiscaso

jsmaller

insetestetotalinpara

smallertestetotalnpara

,1)1(,0

1)1(:)(1)(1)1( :

1 :)(1)(1 :

)1(156)(

)(3)1(234)(

)1(31)1(311)(

innnnT

ninnnT

Comparação de dois algoritmos22)(100)( nnTennT BA

n 50 – Algoritmo Bn 50 – Algoritmo A

TB(n)=2n2

TA(n)=100n

20 40 60 80 100

• Para n 50, a vantagem do algoritmo A sobre o algoritmo B cresce com n.• A função T(n) determina o maior problema que pode ser resolvido com este algoritmo

(em determinado tempo de computação)

milisegundos

Comparação de dois algoritmos

Quando a velocidade dos computadores aumenta, maiores aumentos no tamanho dos maiores problemas que podem ser resolvidos são observados para programas cujo tempo de processamento cresce mais lentamente.

Segundos Maior problema que pode ser resolvido

Alg. A Alg. B1 10 22

10 100 70

100 1000 223

1000 10000 707

Procurar algoritmos com menores taxas de crescimento!

Comparação de dois algoritmos

• O tempo de processamento de um dado algoritmo para uma entrada particular ainda depende– do computador– do compilador

• Mesmo conhecendo-se algoritmo/programa/máquina/ compilador, ainda é difícil prever o tempo de processamento de um programa

Notação O

• Número de instruções de máquina geradas por um computador• Número de instruções de máquina executadas (por segundo)

por um determinado computador

T(n) = 100n → T(n) = O(n)“Alguma constante vezes n”

• Também esconde o fato de que instruções diferentes executam em tempos diferentes.

Descrever o tempo de processamento de um programa usando a notação O, que “esconde” fatores tais como:

Notação O

T(n) = O(f(n)) se existe um inteiro n0 e uma constante c > 0 tal que T(n) ≤ c.f(n) para qualquer n ≥ n0

4,1412

)1(212

)()()1()(

nnnnnn

nOnTnnT

Notação O

Constantes e termos de menor grau não importam:

aaaacnnOnT

anananananT

Notação O

))(()(

2,1002

nhOnfnhOngngOnf

ngOnhngngnh

:dadeTransitivi

Notação O

No caso geral, obter T(n) de forma exata pode ser muito difícil. Esta tarefa pode ser muito simplificada se, em vez de obter-se T(n), procura-se uma expressão O(f(n)) como limitante superior de T(n).

Ordenação por seleção: T(n) = O(n2)

Notação O

nOnOnO

nOnOnOnT

Limite mais justo: menor grau constante = 1

T(n) = O(n2)

Notação O

Constante

Logarítmico

Linear

Quadrático

Cúbico

Exponencial

Fatorial

Notação O

Expressões na notação O podem freqüentemente ser adicionadas:

nfOnTnT

nfOnfHipótese

Aplicação: programas que podem ser decompostos em duas partes

Exemplo 1Expressões na notação O podem freqüentemente ser adicionadas:

vezesnnOOO

nOnTnTnTnT

)( 2321

ler npara i = 1 até n faça

para j = 1 até n façaA[i,j] 0

para i=1 até n façaA[i,i] 1

1)(1 OnT

22 )( nOnT

nOnT )(3

Exemplo 2 - Fatorial

Ler ni 2fact 1enquanto i ≤ n façainicio

fact fact * ii i+1

fimEscreva fact

)()(1).1(1

: 5115)(

11)221)(1(111:

13)1(35)(

1133111:

nOnTOnO

ONotaçãonnnT

nnTInstruções

Linhas

Análise do tempo de processamento

• Comandos simples: O(1)– Atribuição, E/S, go to– Bloco de comandos simples consecutivos: O(1)

• Bloco for– Limites do for dão um limite superior para o número de

vezes que o bloco é executado– Caso mais simples: multiplicar a complexidade do bloco

pelo limite superior do número de vezes que é executado

Tempo de processamento ~ Complexidade

para j = 1 até n faça → n vezesA[i,j] 0 → O(1)

para i = 1 até n faça → n vezes para j = 1 até n faça → n vezes

A[i,j] 0 → O(1)T(n) = nT’(n) = n(n.O(1)) = O(n2)

Selection sort:

smaller = i → O(1)para j = i+1 até n faça → n vezes

se A[j] < A [smaller] então smaller j; → O(1)

• i n-1 T(n)=O(1)• i < n-1 T(n)=O(1) + (n-i) · O(1) = O(n-i)• T(n)=O (max {1, n-i} )• Complexidade do algoritmo completo

1,1max1

nOnOinO

vezesn

• Teste:

se <condição> então → O(1)<parte_do_então> →

O(f(n))senão

<parte_do_senão> → O(g(n))

O (max(f(n), g(n))

se A[i,i]=0 então → f(n) = n2

para i =1 a n faça para j = 1 a n faça A[i,j] 0

senão → g(n) = npara i = 1 a n faça A[i,i] 0

• Verificar se um elemento x pertence a um vetor A[.] (busca seqüencial) com n elementos:

A[n+1] xi 1enquanto x A[i] faça i i+1;se i = n+1 então elemento não existe;se não elemento existe;

O(1) + O(n)·O(1) + O(1) = O(n)

• Programas com chamadas de funções ou procedimentos

• Procurar algoritmos de menor complexidade• Na prática, as constantes e termos de menor grau omitidos

podem fazer uma diferença significativa• Procurar otimizar o código nos pontos críticos

618992)(

nnnTnO

Cálculo de polinômios

xPcalcularxDado

axaxaxaxP

P A[0]para i = 1 até n faça

P P + A[i] · (xi);

T1(n) = n · O(n) = O(n2)

P A[0]y y · x;para i 1 até n faça

P P + A[i] · yy y · x;

T2(n) = n · [O(1)+O(1)] = O(n)

O(n) mesmo?

Método de Horner

xPcalcularxDado

axaxaxaxP

P A[n]para i n-1 até 0 faça

P A[i] + x * P;T3(n) = n · O(1) = O(n)

xaxaxaaP

xaxaxaa

xaxaaxaP

xaaxaPaxaP

Qual dos três algoritmos é melhor?

Ordenação pelo método da bolhainício chave 1;

enquanto chave=1 façainício chave 0; para i = 1 até n-1 faça início

se A[i+1] < A[i] então início temp A[i]; A[i] A[i+1]; A[i+1] temp; chave 1; fim

fimfim

Ordenação pelo método da bolha

• Em cada iteração, pelo menos um elemento é colocado na posição final correta.

• No máximo, n-1 iterações

T(n) = (n-1) · [(n-1) · O(1)]T(n) = O(n2)

A[1] ... A[n]

soma 0;para i=1 até n faça soma soma + A[i];

fim-para; media soma / n; maisperto 1;

i 2;enquanto i n faça

se (A[i]–media)**2 < (A(maisperto)-media)**2 entao maisperto i;i i + 1;

fim-enquanto;

Calcular média e elemento mais próximo

T(n) = O(1) + n · O(1) + O(1) + (n-1) · O(1)T(n) = O(n)

Verificar se um inteiro é primo

prime true; i 2; enquanto i**2 n faça

se (n mod i) = 0 então;início; prime false; goto 99;

fim; senao i i + 1;fim-enquanto;

99: imprimir resultado;

T(n) = O(1) + · O(1)T(n) = O( )

Pesquisa binária

x A[1] ...A[n] ? (ordenado)

min 1; max n; med (min + max)/2; enquanto max > min e A[med] x faça

início; se x > A[med] então min med + 1; se x < A[med] então max med – 1; med (min + max)/2; fim

se A[med] = x então ...senão ...

T(n) = O(1) + log n · O(1)T(n) = O(log n)

Pesquisa binária: O(log n)Pesquisa seqüencial: O(n)

maxmin medA[9] =x

maxmin medA[8] < x

min maxmedA[5] < x

A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] A[9] A[10] 2 4 5 8 10 11 13 15 17 20

Exemplo:

x = 17

max min

maxmin medA[9] >x

maxmin medA[8] < x

min maxmedA[5] < x

Exemplo:

A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] A[9] A[10] 2 4 5 8 10 11 13 15 17 20

x = 16

Algoritmos de menor complexidade

• Heapsort• Mergesort

É possível provar que este limitante é o melhor possível, isto é, estes algoritmos são ótimos!

• Problema: dados um vetor A[1] ... A[n] e um valor x, verificar se x é um elemento do vetor.

• Qual é o melhor algoritmo?

O(n log n)

Depende!!!Dados ordenados ou não?

• Dados ordenados:- Pesquisa binária: O(log n)

• Dados não-ordenados:- Pesquisa seqüencial: O(n)

- Ordenar + pesquisa binária: O(n log n) + O(log n) = O(n log n)

Pesquisa seqüencial é melhor!

• Variante:Há m elementos a serem testados

• Dados não-ordenadosPesquisa seqüencial: O(m.n)

Ordenar + pesquisa binária: O(n log n) + O(m log n) = O((n + m) log n)

• Hipótese: m n

Agora, a segunda alternativa é a mais eficiente!O(n log n) vs. O(n2)

• Tipo de dado:Fila de prioridade

Implementação:Heap

• Conjunto de elementos, cada um com uma prioridadeOperações: Inserir

Obter e eliminar o elemento com maior prioridade

• Exemplo de aplicação: heapsort

Árvore parcialmente ordenada

• Árvore binária valorada onde os rótulos satisfazem as seguintes propriedades:

1. Rótulos dos nós são elementos com uma prioridade (valor de um elemento).

2. O elemento armazenado em um nó tem prioridade maior ou igual à dos filhos deste nó.

Árvore parcialmente ordenada

• APO’s são uma boa implementação de filas de prioridade.

DeleteMax: – Substituir a raiz pelo nó mais à direita no nível mais baixo;– Reorganizar a árvore fazendo o elemento da raiz descer

até a posição apropriada.

Inserir:– Criar folha mais à esquerda possível no nível mais baixo e

subir até encontrar a posição apropriada.

Árvore parcialmente ordenada balanceada

• As folhas estão no máximo em dois níveis diferentes .• As folhas no nível mais baixo estão o mais à esquerda possível.

n nós caminho da raiz tem comprimento menor ou igual a log2 n

Heap: implementação de uma APO balanceada

• Vetor A com interpretação especial para índice dos elementos

• Elementos de APOB aparecem nível a nível em A, começando da raiz, e dentro de um mesmo nível da esquerda para a direita

– O filho à esquerda do nó armazenado em A[i] será armazenado em A[2i] e seu filho à direita em A[2i+1]

18 18 7916 1 9 573

1 2 543 6 7 1098

A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] A[9] A[10] 4 1 3 2 16 9 10 14 8 7

Construção da árvore

type IntArray = array [1...max] of integer;

procedure swap (var A: intarray;i, j: integer);var temp: integer; início temp A[i];

A[i] A[j]; A[j] temp;

Heapprocedure bubbleUp (var A: intarray;i: integer);início se i > 1 AND A[i] > A[i/2] então

inícioswap (A,i,i/2);bubbleUp (A,i/2)

fimfim

procedure insert (var A: intarray; x,n: integer);início

n n + 1;A[n] x;bubbleUp (A,n)

fim T(n) = O(log n)

procedure bubbleDown (var A: intarray;i,n: integer);var filho: integer;início filho 2*i;

se filho < n então se A[filho+1] > A[filho] então filho filho + 1;se filho n então

se A[i] < A[filho] então início

swap (A,i,filho); bubbleDown (A,filho,n)

fimfim

procedure deletemax (var A: intarray; Var n: integer);início

swap (A, 1, n);n n – 1;

bubbleDown (A, 1, n)fim T(n) = O(log n)

para i = 1 até n façainsert(ai);

para i = 1 até n façadeletemax

Heapsort

• Ordenar um vetor A[1..n] em duas fases:

1. Dar ao vetor a propriedade de ser uma APO balanceada (heap).2. Repetidamente, selecionar o maior item do heap até que o vetor

fique ordenado

heap1 i (i + 1) n

(n-i) maiores elementos já ordenados

T(n) = O(n log n)O(log n)

O(log n)

Heapsort

A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] A[9] A[10] 4 1 3 2 16 9 10 14 8 7

Construção do vetor (primeira parte, usando insert)

Heapsort

A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] A[9] A[10] 4 1 3 2 16 9 10 14 8 7

Heapsort

A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] A[9] A[10] 4 1 3 2 16 9 10 14 8 7

Heapsort

A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] A[9] A[10] 4 1 3 2 16 9 10 14 8 7

Heapsort

A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] A[9] A[10] 4 1 3 2 16 9 10 14 8 7

Atenção!!!

Heapsort

A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] A[9] A[10] 4 1 3 2 16 9 10 14 8 7

Heapsort

A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] A[9] A[10] 4 1 3 2 16 9 10 14 8 7

Heapsort

A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] A[9] A[10]16 4 3 2 1 9 10 14 8 7

Heapsort

A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] A[9] A[10] 16 4 3 2 1 9 10 14 8 7

Heapsort

A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] A[9] A[10] 16 4 3 2 1 9 10 14 8 7

Heapsort

A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] A[9] A[10] 16 4 9 2 1 3 10 14 8 7

Heapsort

2 1 3 10

A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] A[9] A[10] 16 4 9 2 1 3 10 14 8 7

Heapsort

2 1 3 10

A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] A[9] A[10] 16 4 9 2 1 3 10 14 8 7

Heapsort

2 1 3 9

A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] A[9] A[10] 16 4 10 2 1 3 9 14 8 7

Heapsort

2 1 3 9

A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] A[9] A[10] 16 4 10 2 1 3 9 14 8 7

Heapsort

2 1 3 9

A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] A[9] A[10] 16 4 10 2 1 3 9 14 8 7

Heapsort

4 1 3 9

A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] A[9] A[10] 16 14 10 4 1 3 9 2 8 7

Heapsort

A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] A[9] A[10] 16 14 10 4 1 3 9 2 8 7

Heapsort

A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] A[9] A[10] 16 14 10 4 1 3 9 2 8 7

Heapsort

A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] A[9] A[10] 16 14 10 8 1 3 9 2 4 7

Heapsort

A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] A[9] A[10] 16 14 10 8 1 3 9 2 4 7

Heapsort

A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] A[9] A[10] 16 14 10 8 1 3 9 2 4 7

Heapsort

A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] A[9] A[10] 16 14 10 8 7 3 9 2 4 1

Heapsort

Ordenação do vetor (segunda parte, usando deleteMax)

A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] A[9] A[10] 16

9874321

Árvore após extrair a raizÁrvore antes de extrair a raiz

Heapsort

procedure heapsort (var A: intarray; n: integer);var i: integer;início heapify (A, n);

i n;enquanto i > 1 faça

deletemax (A,i);fim

swap de A[1] e A[i];diminui n n -1

O (n log n)

heapify considera o vetor A após a leitura e o transforma em um heap,começando do nível mais baixo e subindo nível a nível.

Implementação melhor: em vez de montar um heap elemento a elemento, ler o vetor e transformá-lo após a leitura.

Heapsort

procedure heapify (var A: intarray; n: integer);var i: integer;início

para i = n/2 downto 1 façabubbleDown (A,i,n);

n/2 chamadas a BubbleDown O(n log n) ou menos?

Nada a fazer no nível mais baixo, começar um nível acima: apenas os n/2 primeiros elementos podem ser afetados, pois são os que têm filhos.

Heapsort

n/4 + 1

n/2 + 1

• 2a metade: 0 chamada• 2º quarto: 1 chamada• 2º oitavo: 2 chamadas

Heapsort

• Zona i:

• No máximo i chamadas a bubbleDown para cada elemento na zona i

• Número de elementos na zona i:

n/8 n/4 n/2 n... 2 1 0

zona 2 zona 1

122 ii

zona 0 4

Heapsort

• Zona de maior índice: log2n

• Altura: log2n

• A[1] é o único elemento na zona log2n de maior índice

Heapify O(n)

Heapsort

Algoritmos polinomiais

• Diz-se que um algoritmo é polinomial quando sua complexidade de pior caso (T(n)) é limitada por um polinômio em função do tamanho da entrada (n).

• Considera-se um determinado tipo de problema como bem resolvido em termos algorítmicos quando se dispõe de um bom algoritmo para sua solução.

• Diz-se que um bom algoritmo é aquele cuja complexidade é polinomial

• A taxa de crescimento de qualquer algoritmo polinomial é menor do que a taxa de crescimento dos algoritmos não polinomiais.

P(n): polinômio em n

0)(lim!

)(lim2

)(lim nnnnn n

nPnnPnP

• Para n suficientemente grande, um algoritmo polinomial é sempre mais rápido do que um algoritmo não-polinomial.

T1(n) = na T2(n) = an

)1(lim

1)1(lim)(

)1(lim

n 10 100 1000n log n 33 664 9966n3 1000 106 109

2n 1024 1.27 x 1030 1.05 x 10 301

n log n 2099 1.93 x 1013 7.89 x 10 29

n! 3628800 10158 4 x 10 2567

P = {polinômios} é uma constante

P1, P2 P · P1 P P1 + P2 P P1 · P2 P

• Propriedade de fechamento:

• Melhor utilização de avanços tecnológicos

• n1: maior tamanho de problema que pode ser resolvido em um computador disponível hoje, usando um algoritmo de complexidade T(n), em determinado tempo de processamento pré-fixado.

• n10: mesma definição, em um computador 10 vezes mais rápido.

T(n10) = 10 · T(n1)

n 1012 1013

n log n 0.948 x 1011 0.87 x 1012 n3 104 2.15 x 104

2n 40 43nlog n 79 95n! 14 15

(n10)3 = 10 (n1 )3

n10 = · n13 10

• Problemas que podem ser resolvidos por algoritmos polinomiais classe

• Há muitos problemas para os quais não se conhece algoritmos polinomiais

Não existem?

Ainda não foram encontrados?

Teoria da complexidade

• Problemas NP-completos

• O que fazer quando não se conhece um algoritmo polinomial para um problema?

Desenvolver um algoritmo não-polinomial.Procurar algoritmos aproximados de complexidade polinomial.

decisão Problemas avaliação

otimização

“sim”“não”

Teoria da complexidade

P-SPACE

“fáceis” (algoritmos polinomiais)

“NP-difíceis” /“NP-árduos”

P NP ?

NP-Completos

Algoritmos pseudopolinomiais

A[1] ... A[n]: números inteiros [a,b]

FASE 1: Colocar cada elemento A[i] na caixa apropriada (ou seja, a caixa rotulada com i)

FASE 2: Percorrer as caixas na ordem por ordem crescente de rótulo, retirando os elementos

Exemplo: ordenação pelo método das caixas

para j = a até b façan(j) 0;

para i = 1 até n façan[a[i]] n[a[i]] + 1;

k 0;para j = a até b faça início

enquanto n[j] 0 faça início n[j] = n[j] – 1; k k + 1; a[k] j; fim

T(n) = (b – a + 1) · O (1) + n · O (1) + O (1) + (b – a + 1) · O (n) · O (1) = O(n · (b – a))

Não, cuidado!!!

para : b – a + 1enquanto: n + (b – a + 1)n[j] : k : na[k] :

T(n) = O(b – a + n)

Não é um algoritmo polinomial, pois T(n) não é um polinômio apenas no tamanho da entrada.

• Selecionar dentre n objetos aqueles que serão levados em uma mochila de capacidade (peso máximo) limitada. j = 1, ..., n objetoscj “lucro”aj “peso”b “peso máximo”

Hipótese: aj b j

Exemplo: problema da mochila

,...,1,1,01

: a sujeito

maximizar

Problema da mochila

• Decomposição do problema em estágios.

• Em vez de considerar uma solução (x1,x2,...,xn) completa de uma só vez, visualizar o problema como se as decisões fossem tomadas para um item de cada vez.

• Após k decisões, terão sido determinados quais dos primeiros k itens devem ser selecionados e, conseqüentemente, terão sido determinados os valores das variáveis x1,x2,...,xk.

• Neste ponto, o valor acumulado é

• O volume acumulado é

jj xa1j

Problema da mochila

• Estágio:cada variável do problema

• Estado: volume total ocupado com as decisões já tomadas

• Decisão: selecionar ou não um item (isto é, fazer xk=1)

• Custo da decisão de selecionar o item k: aumento de ck unidades no lucro parcial acumulado

• Efeito da decisão de selecionar o item k: aumento do volume ocupado (estado) em ak unidades

Problema da mochila• Definição:

yk(u) = lucro máximo que pode ser obtido com volume total igual a u e usando apenas itens do conjunto {1,...,k}

• Quanto vale y0(0)?– y0(0) = 0 (sem objetos selecionados, o peso e o lucro são nulos)

• Definir yk(u) = - se é impossível obter um volume total igual a u apenas com itens dentre os do conjunto {1,...,k}.

• Quanto valem y0(u) e yk(0)? – y0(u) = - para u > 0 (impossível acumular peso sem itens)– yk(0) = 0 para k = 1,2,...,n (nenhum item selecionado)

• Calcular yk(u) para k = 1,...,n e u = 0,...b, a partir de y0(0).

Problema da mochila

• yk(u) = lucro máximo que pode ser obtido com volume total igual a u e usando apenas itens do conjunto {1,...,k}

• Calcular yk(u) para k = 1,...,n e u = 0,...b:

• Interpretação: há duas alternativas para se obter yk(u), dependendo do item k ser selecionado ou não– yk(u) = yk-1(u), se o item k não é usado– yk(u) = yk-1(u-ak)+ck, se o item k é usado

nkbucauyuyb;ku

,...,1;,...,0,)(),(max0,...,1,

0;0,0)(

Problema da mochila

• Observar que o lucro associado ao estado resultante de uma decisão depende apenas do valor desta decisão e do estado atual, mas não depende da forma como este último foi atingido.

nkbucauyuyb;ku

,...,1;,...,0,)(),(max0,...,1,

0;0,0)(

Problema da mochila

5,...,1},1,0{4233 :a sujeito

3223max

jxxxxxx

y5(4) =

Problema da mochila

5,...,1},1,0{4233 :a sujeito

3223max

jxxxxxx

5,...,1},1,0{233 :a sujeito

3223max

jxbxxxxx

y5(b) =

Valor ótimo = maxb=0,...,4 {y5(b)}

Problema da mochila

y0(4) y5(4)

y0(3) y5(3)

y0(2) y5(2)

y0(1) y5(1)

y0(0) y1(0) y2(0) y3(0) y4(0) y5(0)

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

0 0 0 0 0 0

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

0 0 0 0 0 0

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

- - - ?

- 3 3 ?

- - - ?

0 0 0 ?

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

0 0 0 0

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

- - - 2

0 0 0 0

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

- - - -

- - - 2

0 0 0 0

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

- - - -

- - - 2

0 0 0 0

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

- - - -

- - - 2

0 0 0 0

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

- 3 3 3

- - - -

- - - 2

0 0 0 0

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

- - - 5

- 3 3 3

- - - -

- - - 2

0 0 0 0

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

- - - 5

- 3 3 3

- - - -

- - - 2

0 0 0 0

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

- - - 5 ?

- 3 3 3 ?

- - - - ?

- - - 2 ?

0 0 0 0 ?

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

- - - 5

- 3 3 3

- - - -

- - - 2

0 0 0 0 0

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

- - - 5

- 3 3 3

- - - -

- - - 2

0 0 0 0 01

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

- - - 5

- 3 3 3

- - - -

- - - 2 2

0 0 0 0 0

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

- - - 5

- 3 3 3

- - - -

- - - 2 2

0 0 0 0 0

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

- - - 5

- 3 3 3

- - - - 3

- - - 2 2

0 0 0 0 0

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

- - - 5

- 3 3 3 3

- - - - 3

- - - 2 2

0 0 0 0 0

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

- - - 5

- 3 3 3 3

- - - - 3

- - - 2 2

0 0 0 0 0

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

- - - 5

- 3 3 3 3

- - - - 3

- - - 2 2

0 0 0 0 0

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

- - - 5

- 3 3 3 3

- - - - 3

- - - 2 2

0 0 0 0 0

0u = 4

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

- - - 5 5

- 3 3 3 3

- - - - 3

- - - 2 2

0 0 0 0 0

0u = 4

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

- - - 5 5

- 3 3 3 3

- - - - 3

- - - 2 2

0 0 0 0 0

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

- - - 5 5 ?

- 3 3 3 3 ?

- - - - 3 ?

- - - 2 2 ?

0 0 0 0 0 ?

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

- - - 5 5

- 3 3 3 3

- - - - 3

- - - 2 2

0 0 0 0 0 0

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

- - - 5 5

- 3 3 3 3

- - - - 3

- - - 2 2

0 0 0 0 0 0

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

- - - 5 5

- 3 3 3 3

- - - - 3

- - - 2 2 2

0 0 0 0 0 0

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

- - - 5 5

- 3 3 3 3

- - - - 3

- - - 2 2 2

0 0 0 0 0 0

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

- - - 5 5

- 3 3 3 3

- - - - 3

- - - 2 2 2

0 0 0 0 0 0

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

- - - 5 5

- 3 3 3 3

- - - - 3 3

- - - 2 2 2

0 0 0 0 0 0

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

- - - 5 5

- 3 3 3 3

- - - - 3 3

- - - 2 2 2

0 0 0 0 0 0

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

- - - 5 5

- 3 3 3 3

- - - - 3 3

- - - 2 2 2

0 0 0 0 0 0

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

- - - 5 5

- 3 3 3 3 5

- - - - 3 3

- - - 2 2 2

0 0 0 0 0 0

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

- - - 5 5

- 3 3 3 3 5

- - - - 3 3

- - - 2 2 2

0 0 0 0 0 0

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

- - - 5 5

- 3 3 3 3 5

- - - - 3 3

- - - 2 2 2

0 0 0 0 0 0

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

- - - 5 5 6

- 3 3 3 3 5

- - - - 3 3

- - - 2 2 2

0 0 0 0 0 0

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

- - - 5 5 6

- 3 3 3 3 5

- - - - 3 3

- - - 2 2 2

0 0 0 0 0 0

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

Problema da mochila

- - - 5 5 6

- 3 3 3 3 5

- - - - 3 3

- - - 2 2 2

0 0 0 0 0 0

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

y5(4) = 6

y5(3) = 5

y5(2) = 3

y5(1) = 2

y5(0) = 0

Problema da mochila

- - - 5 5 6

- 3 3 3 3 5

- - - - 3 3

- - - 2 2 2

0 0 0 0 0 0

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

y5(4) = 6

y5(3) = 5

y5(2) = 3

y5(1) = 2

y5(0) = 0

Problema da mochila

- - - 5 5 6

- 3 3 3 3 5

- - - - 3 3

- - - 2 2 2

0 0 0 0 0 0

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

y5(4) = 6

y5(3) = 5

y5(2) = 3

y5(1) = 2

y5(0) = 0

Problema da mochila

- - - 5 5 6

- 3 3 3 3 5

- - - - 3 3

- - - 2 2 2

0 0 0 0 0 0

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

y5(4) = 6

y5(3) = 5

y5(2) = 3

y5(1) = 2

y5(0) = 0

Problema da mochila

- - - 5 5 6

- 3 3 3 3 5

- - - - 3 3

- - - 2 2 2

0 0 0 0 0 0

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

y5(4) = 6

y5(3) = 5

y5(2) = 3

y5(1) = 2

y5(0) = 0

x5=1x4=1

Problema da mochila

- - - 5 5 6

- 3 3 3 3 5

- - - - 3 3

- - - 2 2 2

0 0 0 0 0 0

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

y5(4) = 6

y5(3) = 5

y5(2) = 3

y5(1) = 2

y5(0) = 0

x5=1x4=1x3=1

Problema da mochila

- - - 5 5 6

- 3 3 3 3 5

- - - - 3 3

- - - 2 2 2

0 0 0 0 0 0

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

y5(4) = 6

y5(3) = 5

y5(2) = 3

y5(1) = 2

y5(0) = 0

x5=1x4=1x3=1x2=0

Problema da mochila

- - - 5 5 6

- 3 3 3 3 5

- - - - 3 3

- - - 2 2 2

0 0 0 0 0 0

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5

y5(4) = 6

y5(3) = 5

y5(2) = 3

y5(1) = 2

y5(0) = 0

x5=1x4=1x3=1x2=0x1=0

Problema da mochila

• Os estados em verde e as transições possíveis (arcos com setas) definem um grafo multiestágio para a aplicação da recursão de programação dinâmica.

• Número de operações (tempo de processamento) diretamente proporcional ao produto do tamanho da mochila pelo número de variáveis (preencher inteiramente a matriz de dimensões (b+1)x(n+1)): aplicabilidade limitada aos valores de n e de b

• Caso seja possível levar múltiplas cópias de cada item, aumenta o número de decisões e a complexidade do problema.

• Calcular:

yj(u): lucro máximo que pode ser obtido carregando-se um peso igual a u usando apenas objetos do conjunto {1,..., j}

• Recursão:

yj-1(k)

yj(k) = max

yj-1(k-aj) + cj

y(0,0) 0;

para k = 1 até b faça y(k,0) - ;

para j = 1 até n façainício

para k = 0 até aj–1 faça y(k,j) y(k,j-1);para k = aj até b faça y(k,j) max {y(k,j-1),f(k-aj,j-1) + cj}

T(n) = O (b) + n · O (b)T(n) = O (n · b) Tamanho da entrada

Valor do maior dado na entrada

Diz-se que um algoritmo é pseudopolinomial se sua complexidade de pior caso é um polinômio notamanho da entrada e no valor do maior dado de entrada

Caixeiro viajante

• Grafo orientado com n nós

• Distâncias dij

S { 2, 3, ..., n}

C(S,k) = custo ótimo de sair do nó 1, visitar todos as cidades de S uma única vez, terminar na cidade k.

Caixeiro viajante

• Início: calcular C(S,k) para |S| = 1, k = 2, ..., n

• Cálculo de C(S,k) para |S| > 1: a melhor maneira de sair do nó 1, visitar todos os nós de S e retornar a k é considerar visitar m imediatamente antes de k, para cada m, considerando C(S-{k}, m) calculado anteriormente:

dmkSCksC mk

kdkkC 1,

Caixeiro viajante

• Calcular para todos S de dado tamanho e para cada possível nó m em S.

• Complexidade:

nadiçõesn

ndentrekescolher

Definições recursivas ou indutivas

• Definição recursiva: uma classe de objetos relacionados é definida em termos dos próprios objetos.

• Uma definição recursiva envolve uma base (em que um ou mais objetos simples/elementares são definidos) e um passo indutivo (em que objetos maiores são definidos em termos dos objetos menores já definidos).

fat(n) = 1 • 2 • ... • nDefinição recursiva:

Base: 1! = 1Indução: n! = n • (n – 1)!

1º uso do passo indutivo

2º uso do passo indutivo

nº uso do passo indutivo

• Expressões aritméticas são naturalmente definidas de forma recursiva:

Base especificar os operandos atômicos (variáveis, etc.)

• Base: variáveis / inteiros/ reais

• Indução: Se E1 e E2 são expressões, então:

(E1 + E2), (E1 – E2), (E1 • E2), (E1 / E2) e (-E1)

também são expressões aritméticas.

+ -• / Operadores binários

Procedimentos recursivos

• Chamados de seu interior

• Programas recursivos são freqüentemente mais sucintos ou mais fáceis de serem entendidos.

– Base: entrada particular que pode ser resolvida pela base da indução

– Parte Indutiva: chamadas recursivas sucessivas ao próprio procedimento

function fat (n: integer): integer;início

se n 1 entãofat 1

senãofat n · fat (n-1)

Call fat(1)

return 2 fat(2)

Base: T(1) = O(1)Indução: T(n) = O(1) + T(n-1) n > 1

return 6 fat(3)

return 24 fat(4)

return 1

Call fat(2)

Call fat(3)

Call fat(4)

• É essencial que a indução faça apenas chamadas envolvendo argumentos de menor tamanho e que a base seja sempre necessariamente atingida.

• Base: Se i = n, só existe um elemento a ser ordenado.

• Indução: Se i < n, obter min {ai, ..., an}, trocá-lo com ai e ordenar

recursivamente {ai +1, ... an}

SelectionSort1) Obter menor elemento da cauda do vetor A[i...n]2) Trocá-lo por A[i]3) Ordenar o vetor A[i+1... n]

procedure SelectionSort (var A: intarray; i, n: integer);var j,smaller, temp: integer;início

se i < n entãoinício smaller i; para j i + 1 até n faça se A[j] < A[smaller] então início

smaller j; temp A[smaller]; A[smaller] A[i];

A[i] temp; SelectionSort (A,i+1,n)

fimfim

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

• Análise de procedimentos recursivos:

1. Definir Tp(n) = tempo de processamento de P em função do

tamanho n de seus argumentos.

2. Estabelecer uma relação de recorrência que relacione Tp(n) com

outras funções TQ(k) para outros procedimentos Q com

argumentos de tamanho k.

3. Escolher uma noção de tamanho de argumento que garanta que os procedimentos são chamados recursivamente com argumentos progressivamente menores com o avanço da recursão.

• Quando o argumento se torna suficientemente pequeno, não são feitas novas chamadas recursivas: caso base da definição indutiva de Tp(n)

• Enquanto o argumento não se torna suficientemente pequeno, chamadas recursivas podem ocorrer com argumentos menores

• Tp(n) é obtido pelo exame do código

a) call Q tempo de execução TQ(k)

b) avaliar o corpo de P com as técnicas já conhecidas, deixando termos como TQ(k) como incógnitas: duas expressões para o

tempo de P (caso base e parte indutiva)

c) Substituir O(f(n)) por c·f(n) + dd) Resolver a equação de recorrência

procedure SelectionSort (var A: intarray; i, n: integer);var j,smaller, temp: integer;início

se i < n entãoinício smaller i; para j i + 1 até n faça se A[j] < A[smaller] então início

smaller j; temp A[smaller]; A[smaller] A[i];

A[i] temp; SelectionSort (A,i+1,n)

fimfim

Base (i = n): apenas um elemento a ordenar

Indução (i < n): obter o menor elemento em A[i...N], colocá-lo em A[i] e ordenar A[i+1... N]

T(1) = O(1) = aT(n) = O(n) + T(n-1) b.n

T(1) = aT(n) = b.n + T(n-1)T(2) = 2b + aT(3) = 3b + 2b + a = 5b + aT(4) = 4b + 5b + a = 9b + aT(n) =

Base: T(1) = O(1)Indução: T(n) = O(1) + T(n-1) n>1

T(1) = aT(n) = b + T(n-1) n>1T(1) = aT(2) = T(1) + bT(3) = T(2) + b = T(1) + 2bT(4) = T(3) + b = T(1) + 3bT(n) = T(1) + (n-1) · b T(n) = a + (n-1)·b = O(n)

Voltando ao cálculo do fatorial:

Merge sort

235235

• Algoritmo recursivo baseado em listas, utilizando a técnica de divisão-e-conquista.

• Princípio de divisão para conquistar:

– Dividir a lista em duas listas do mesmo tamanho– Ordenar cada uma das duas listas– Fazer o merge das duas listas ordenadas

Merge sort

236236

1Lista 1

2Lista 2

Merge sort

237237

Lista 2

Mergeados recursivamente

Lista 11

Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro 238 238238

Merge sort

Callmerge(1 2 7 7 9, 2 4 7 8)

merge(2 7 7 9, 2 4 7 8)merge(7 7 9, 2 4 7 8)

merge(7 7 9, 4 7 8)merge(7 7 9, 7 8)

merge(7 9, 7 8)merge(9, 7 8)

merge(9, 8)merge(9, NIL)

1 (2 2 4 7 7 7 8 9)2 ( 2 4 7 7 7 8 9)

2 (4 7 7 7 8 9)4 (7 7 7 8 9)7 (7 7 8 9)7 (7 8 9)7 (8 9)8 (9)

Return9

Merge sort

239239

Lista 14 81 124 nil5

Lista 224 282 nil3

24 26 28 30

4 6 8 10 12 14

L4 L24 L8 > L24

L8 > L28

function merge (lista1, lista2: listType) : listTypeinício

se lista1=NIL então merge lista2

senão se lista2=NIL então

merge lista1 senão

se lista1^.elemento lista2^.elemento entãolista1^.next merge(lista1^.next,

lista2)merge lista1

elselista2^.next merge(lista1,

lista2^.next)merge lista2

Merge sorttype cell=record

element : integernext : listType

type listType=^cell

function split (lista: listType) : listTypeVar second cell: listTypeinício

se lista=NIL então split NIL

senão se lista^.next=NIL então

split NIL senão

second cell list^.next list^.next second cell^.next second cell^.next split(second cell^.next)

split second cellfim

Merge sort

Mergen=n1+n2

T(n)=?lista1=NIL ou lista1=NIL O(1)T(n)=O(1)+T(n-1) T(n)=O(n) (percorre a lista)

Splitn: tamanho da listalista1=NIL ou lista1^.next=NIL O(1)T(n)=O(1)+T(n-2)T(0)=aT(1)=bT(n)=c + T(n-2)

Complexidade de Merge sort

T(0) = aT(1) = bT(1) = bT(2) = c + aT(3) = c + bT(4) = c + ( c + a ) = 2c + a T(5) = c + ( c + b ) = 2c + b T(6) = 3c + a T(7) = 3c + b

Complexidade de Merge sort

n par: T(n) = ( n/2 ) · c + an ímpar: T(n) = ( (n-1)/2 ) · c + b

T(n) = O(n)

Chama-se split recursivamente n/2 vezes, cada vez com cálculos O(1)

program sort (input, output) const max = 100type cell = record elemento: integer next: listTypeend listType=^cell

var A: array [1…max] of integer k, n: integer

list: listType

Merge sort

procedure merge sort (var list: listType)function merge (lista1, lista2: listType): listTypefunction split (list: listType) : listType

function makeList (i, n: integer) : listType var new cell: listTypeinício

se i > n então makeList NILelse

new(newCell) newCell^.next makeList(i+1, n) newCell^.element A[i] makeList newCell

Merge sort

procedure printList (list: listType) início

se list = NIL então returnelse

write(list^.element) printList(list^.next)

Merge sort

inícioreadln(n)para k 1 até n faça read(A[k]) list makeList(1, n) mergeSort(list) printList(list)

procedure mergeSort(var list: listType) var secondList: listTypeinício

se list <> NIL então se list^.next <> NIL então secondList split(list) mergeSort(list)

mergeSort(secondList) list merge(list, secondList)

Merge sort

list NIL ou list^.next NIL O(1)n: tamanho da lista

base: T(1) = O(1) indução: T(n) = O(1) + O(n) + T(n/2) + T(n/2) + O(n)

T(1) = O(1) = a T(n) = O(n) + 2 · T(n/2) = b · n + 2 · T(n/2)

T(2) = 2a + 2b T(4) = 4a + 8b T(8) = 8a + 24b T(16) = 16a + 64b T(n) = n · a + (n · log2n) · b

Merge sort

T(n)=O(n log n)

Torres de Hanoi

• Repetir n passos 1 e 2 abaixo até que os discos estejam corretamente empilhados:1. Mover o menor disco do suporte “corrente” para o seguinte no …2. Fazer o único movimento possível que não envolva o menor disco

Torres de Hanoi

n-1n-1

hanoi (n, x, y, z) início

mover n discos de x para y usando zx yse n =1 então x ysenão

hanoi(n-1, x, z, y) x y hanoi(n-1, z, y, x)

Torres de Hanoi

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

T(n) = 1 + 2 T(n-1) n > 1T(n) = O(1) n = 1

Torres de Hanoi

aaaanTnT

aaanTnT

aanTnT

22242)(

2232)(

)1(122

Setembro 2004Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro1 Projeto e Análise de...

Documents

Apresentação celso

Maria Tereza Sadek (org.)books.scielo.org/id/82r9t/pdf/sadek-9788579820342.pdf · Expositores: Sérgio Adorno Sueli Carneiro Celso Campilongo Joaquim Falcão Floriza Verucci Esta

PARA RESULTADO VOLUNTÁRIOS DA CHAMADA INTEGRAREM … · NACIONAIS DA ÁREA DE MÉTODOS EDUCATIVOS Curitiba, 16 de julho de 2019 CELSO THADEU CARNEIRO DE MENEZES DIRETOR DE MÉTODOS

Algoritmos e Estruturas de Dados II ARQUIVOS Rodney Carneiro

Perspectivas NVidia para Desktop Tiago Carneiro Pessoa carneiro@larces.uece.br

celso fernando de azambuja gomes carneiro a constituição de

Carneiro hidráulico

Celso emilio

Celso lage

Ricardo Carneiro

Angela carneiro

Programação Linear Celso Carneiro Ribeiro Simone Lima Martins Parte I – Introdução 2009

Parte 4 Teoria da complexidade. Setembro 2004Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro2 Motivação : –problema x algoritmo –classificação

DE VARIEDADES “RB” DE CANA-DE-AÇÚCAR · Celso Bitencourt Teixeira - UFRRJ ... Prof. Dr. Alexandre Siqueira Guedes Coelho UFG ... Tec. Agr. Claudio Augusto Carneiro Maciel UFRRJ

Celso Carneiro Ribeiro Diretor do DEPEM/SESu/MEC

Transparência 1/49 Paralelismo, ferramentas e aplicações 03/maio/2002 Paralelismo, ferramentas e aplicações Celso Carneiro Ribeiro Noemi Rodriguez Sérgio

Sistemas terrestres Celso Dal Ré Carneiro Departamento de Geociências Aplicadas ao Ensino Instituto de Geociências, Unicamp

Celso Tetsuro

3/junho/2002Metaheurísticas1 Celso Carneiro Ribeiro Versão original: Escola Brasileira de Computação 1998 celso

Celso Zilbovicius