Aula01 - Indução - Principio Analise

Algoritmos I
G.P. Telles
ICUNICAMP
13 de agosto de 2015
G.P. Telles (ICUNICAMP)
Algoritmos I
1 / 100
Referencias
Estes slides sao baseados principalmente nos livros:

CLRS09 T.H. Cormen, C.E. Leiserson, R.L. Rivest, C. Stein. Introduction to
Algorithms. 3rd ed. McGraw-Hill, 2009.
Man89 U. Manber. Algorithms: A Creative Approach. Addison-Wesley, 1989.
Estes slides sao incompletos. Contem e sempre conterao erros,

inconsistencias, imperfeic
oes e outros tipos de defeitos.
Estes slides foram escritos usando gramatica anterior à reforma
ortografica de 2009.
Guilherme P. Telles, 2015.
Algoritmos I
2 / 100
Esta disciplina
Analise de algoritmos.
Tecnicas para a construcao de algoritmos: inducao, divisao e
conquista, programacao dinamica, algoritmos gulosos.
Algumas estruturas de dados.
Problemas que sao recorrentes em computacao e sao faceis: busca,
ordenacao, problemas basicos em grafos etc.
Problemas que sao recorrentes em computacao e que nao sabemos se
sao faceis ou difceis: NP-completos.
Algoritmos I
3 / 100
Parte I
Introducao
Algoritmos I
4 / 100
Problemas e algoritmos
Um problema e uma questao que precisa ser respondida. Pode incluir

restricoes sobre os recursos que podem ser usados na solucao.
Em sentido amplo, um algoritmo e um metodo ou processo para
resolver um problema.
Em sentido mais estrito (mas ainda informal) um algoritmo e um
procedimento finito e bem definido que recebe valores como entrada e
produz valores como sada.
Um algoritmo deve ser composto por instruc
oes nao-ambguas e que
possam ser executadas pelo agente de computacao para o qual foi
feito.
Algoritmos I
5 / 100
(Problemas)
Podemos classificar problemas computacionais de acordo com o efeito

que se espera:
I
I
I
I
I
Problemas de busca: encontrar x na entrada que satisfaz a propriedade

P.
Problemas de construcao: construir x satisfazendo a propriedade P .
Problemas de estruturacao: transformar a entrada para satisfazer a
propriedade P .
Problemas de otimizacao: encontrar o melhor x que satisfaz a
propriedade P .
Problemas de decisao: decidir se a entrada satisfaz a propriedade P .
Problemas adaptativos: Manter a propriedade P (enquanto o problema
muda).
Algoritmos I
6 / 100
Algoritmos como tecnologia
Vamos supor que temos um vetor de tamanho n para ordenar.

Vamos supor que temos dois algoritmos para ordenar um vetor:
I
Insertion-sort, que gasta tempo c1 n2 , onde c1 e uma constante que nao

depende de n.
Merge-sort, que gasta tempo c2 n log2 n, onde c2 e uma constante que
nao depende de n.
Vamos supor que temos duas implementac

oes:
I
uma excelente para Insertion-sort em linguagem de baixo nvel, tal que

c1 = 2.
uma mediana para Merge-sort em linguagem de alto nvel, tal que
c2 = 50.
Algoritmos I
7 / 100
Se n for igual a 10 milh

oes, a execucao do Insertion-sort em um
computador muito rapido 1010 instruc
oes por segundo leva
2(107 )2 instruc
oes
= 20000s
10
10 instruc
oes/s
Mesmo se usarmos um computador 1000 vezes mais lento
107 instrucoes por segundo o Merge-sort leva
50 107 log2 107 instruc
oes
1163s
7
10 instruc
oes/s
Algoritmos I
8 / 100
A diferenca e de 5.5 horas para menos de 20 minutos executando o

Merge-sort em um computador 1000 vezes mais lento.
Para 100 milhoes de n
umeros a diferenca e de 23 dias para menos de
4 horas.
Algoritmos I
9 / 100
O exemplo ilustra que melhorias de desempenho obtidas por escolhas

melhores de algoritmos podem ir alem das melhorias que o hardware
pode prover.
Bons algoritmos sao necessarios para resolver uma infinidade de
problemas reais.
Algoritmos I
10 / 100
Outras questoes
Custo de desenvolvimento versus custo de execucao.

I
Um algoritmo eficiente pode ser complicado e pode nao haver alguem

capaz de mante-lo.
Se um programa sera usado poucas vezes ou para problemas pequenos
o custo de implementacao, depuracao e testes pode nao valer a pena.
Em algumas aplicacoes, precisao e estabilidade sao tao importantes

quanto eficiencia.
Algoritmos I
11 / 100
Parte II
Inducao
Algoritmos I
12 / 100
Secoes
Man89: captulo 2.
Algoritmos I
13 / 100
Princpio da inducao
Seja P um predicado com parametro n.

Se P (1) e verdadeiro e para todo n > 1 o fato de que P (n 1) e
verdadeiro implica que P (n) e verdadeiro entao P e verdadeiro para
todo natural n.
Uma intuicao e: se garantimos que o primeiro domino cai e
garantimos que quando qualquer domin
o cai ele derruba o domino
seguinte, entao podemos garantir que todos os dominos caem.
A inducao e uma tecnica para provar teoremas sobre os n
umeros
naturais e para projetar algoritmos.
Algoritmos I
14 / 100
Provas
Para provar um teorema T (n) por inducao e necessario:

1
2
mostrar que T vale para 1 (caso base), e

mostrar que se T vale para n 1 (hip
otese de inducao) isso implica
que T vale para n (passo da inducao).
Algoritmos I
15 / 100
Exemplo
Seja S1 (n) =
n
X
i.
i=1
Vamos mostrar que S1 (n) =
n(n + 1)
para todo natural n.
2
Algoritmos I
16 / 100
Para todo natural n, S1 (n) =
n(n+1)
2
Prova por inducao em n.

Base: Para n = 1, S1 (1) =
1
X
i=1
i=1e
n(n + 1)
1(1 + 1)
=
= 1.
2
2
Algoritmos I
17 / 100

HI: Vamos assumir que S1 (n 1) =
n(n+1)
2
(n 1)n
.
2
Algoritmos I
18 / 100

Passo: Mostrar que se S1 (n 1) =
n(n+1)
2
(n 1)n
.
2
(n 1)n
n(n + 1)
entao S1 (n) =
.
2
2
Algoritmos I
18 / 100

S1 (n) = S1 (n 1) + n
n(n+1)
2
(n 1)n
.
2
(n 1)n
n(n + 1)
entao S1 (n) =
.
2
2
(direto da definicao de S1 )
Algoritmos I
18 / 100

S1 (n) = S1 (n 1) + n
(n 1)n
=
+n
2
n(n+1)
2
(n 1)n
.
2
(n 1)n
n(n + 1)
entao S1 (n) =
.
2
2
(direto da definicao de S1 )
(HI)
Algoritmos I
18 / 100

n(n+1)
2
(n 1)n
.
2
(n 1)n
n(n + 1)
entao S1 (n) =
.
2
2
S1 (n) = S1 (n 1) + n (direto da definicao de S1 )

(n 1)n
=
+ n (HI)
2
(n 1)n 2n
=
+
2
2
Algoritmos I
18 / 100

n(n+1)
2
(n 1)n
.
2
(n 1)n
n(n + 1)
entao S1 (n) =
.
2
2

(n 1)n
=
+ n (HI)
2
(n 1)n 2n
=
+
2
2
n(n 1 + 2)
=
2
Algoritmos I
18 / 100

n(n+1)
2
(n 1)n
.
2
(n 1)n
n(n + 1)
entao S1 (n) =
.
2
2

(n 1)n
=
+ n (HI)
2
(n 1)n 2n
=
+
2
2
n(n 1 + 2)
=
2
n(n + 1)
=
2
Algoritmos I
18 / 100
n(n+1)
2
Mostramos que o enunciado e valido para 1 e que a validade para

n 1 implica na validade para n.
n(n + 1)
Entao, por inducao conclumos que S1 (n) =
para todo
2
natural.
Algoritmos I
19 / 100
n, n + 1
Podemos usar n ou n + 1, o que e equivalente:

Se P (1) e verdadeiro e para todo n > 1 o fato de que P (n) e
verdadeiro implica que P (n + 1) e verdadeiro entao P e verdadeiro
para todo natural n.
Algoritmos I
20 / 100
Bases e passos
Em alguns casos podemos partir de uma base diferente, ou de varias
bases.
Seja P um predicado com parametro n. Se P (1) e P (2) sao
verdadeiros e se P (n 2) verdadeiro implica que P (n) seja
verdadeiro para todo n > 2 entao P e verdadeiro para todo n 1.
O passo pode ser maior que 1, desde que um conjunto infinito seja
coberto.
Seja P um predicado com parametro n. Se P (1) e verdadeiro e se
P (n/2) verdadeiro implica que P (n) seja verdadeiro para todo n
potencia inteira de 2 entao P e verdadeiro para toda potencia inteira
de 2.
Algoritmos I
21 / 100
Inducao forte
Uma variacao muito usada e a inducao forte, em que todos os valores

anteriores de n sao usados na hip
otese.
Seja P um predicado com parametro n. Se P (1) e verdadeiro e se
P (k) verdadeiro para todo 1 < k < n implica que P (n) seja
verdadeiro entao P e verdadeiro para todo n 1.
Algoritmos I
22 / 100
Parte III
Analise de algoritmos
Algoritmos I
23 / 100
Secoes
CLRS09: captulos 2 e 3.
Man89: secoes 3.1 a 3.3.
Algoritmos I
24 / 100
Correcao de algoritmos
Um algoritmo e correto se para toda entrada valida ele produzir o

resultado esperado.
Algumas maneiras de mostrar que um algoritmo e correto:
I
I
I
Testar.
Provar.
Model checking.
Algoritmos I
25 / 100
Testar
Testar e executar um programa com um subconjunto das entradas

possveis.
u
E
til como tecnica de depuracao, mas nao fornece uma garantia de
que o programa esteja correto.
Definir um conjunto de testes de aumente a probabilidade de
encontrar erros e uma parte crucial desse processo.
Outra limitacao e que normalmente nao ha um outro programa
garantidamente correto (oraculo) valide a sada do programa.
Algoritmos I
26 / 100
Provar
Iterativos: assercoes e invariantes de laco.

Recursivos: inducao.
Nao e facil com programas grandes.
Algoritmos I
27 / 100
Assercoes e invariantes de laco
Processo:
I
I
I
I
Enunciam-se as propriedades que o algoritmo deve ter.

Enunciam-se propriedades para pequenas porc
oes do algoritmo
(asserc
oes).
Mostra-se que as asserc
oes sao verdadeiras.
Comp
oem-se as asserc
oes para mostrar que as propriedades do
algoritmo sao verdadeiras.
Assercoes sao afirmac

oes a respeito dos valores de variaveis antes e
depois da execucao de um bloco de comandos.
Algoritmos I
28 / 100
Assercoes
Assercoes tipicamente tem a forma de pre e p

os-condicoes.
I
Pre-condic
oes: conjunto de afirmac
oes que devem ser validas antes da
execucao de um bloco.
P
os-condic
oes: conjunto de afirmac
oes que devem ser validas depois da
execucao de um bloco.
As construcoes atomicas do algoritmo sao consideradas axiomas

(propriedades que nao precisam ser demonstradas).
Algoritmos I
29 / 100
Exemplo
Tripla de Hoare: {P }S{Q}.

Significa: dado que P e verdadeira antes da execucao de S entao Q e
verdadeira depois da execucao de S.
{x > 1} x = x + 2 {x > 3}
{x < y} while (x < y) x = x + 1 {x = y}
Algoritmos I
30 / 100
Invariante de laco
Uma invariante de laco e uma assercao que vale antes do incio de

cada iteracao.
Para mostrar que um laco tem certas propriedades sao usadas
invariantes de laco compostas com uma prova de que o laco termina.
Algoritmos I
31 / 100
Exemplo
Um algoritmo para somar os elementos de um vetor.

Sum-array(A)
1
2
3
4
sum = 0
for i = 1 to A.length
sum = sum + A[i]
return sum
Algoritmos I
32 / 100
Terminacao
O laco 2:3 termina.
No laco o valor inicial de i e 1 e ele e incrementado automaticamente ate
alcancar A.length. Como A.length e definido, finito e maior ou igual a 0
entao o laco termina.
Algoritmos I
33 / 100
Invariante
No comeco de cada iteracao do laco 2:3, a variavel sum contem a soma
dos valores do subvetor A[1 . . i 1].
Algoritmos I
34 / 100
Invariante
Antes da primeira iteracao: para i = 1 o subvetor A[1 . . 0] nao contem
elementos e o valor de sum e zero.
Algoritmos I
34 / 100
Invariante
Antes da primeira iteracao: para i = 1 o subvetor A[1 . . 0] nao contem
elementos e o valor de sum e zero.
Cada iteracao mantem a invariante: o corpo do laco adiciona A[i] a sum.
Ao termino do laco, i e incrementado e entao sum contem a soma dos
elementos do subvetor A[1 . . i 1].
Algoritmos I
34 / 100
Correcao de Sum-array
Sum-array retorna a soma dos valores no vetor.
A invariante de laco garante que sum contem a soma dos elementos no
vetor A na linha 4. Como o laco termina, o algoritmo retorna sum e entao
esta correto.
Algoritmos I
35 / 100
Invariantes e inducao
A tecnica de invariantes de laco e similar à inducao.

A validade da invariante antes da primeira iteracao do laco
corresponde ao caso base da inducao e a validade ao termino de cada
iteracao corresponde ao passo da inducao.
Algoritmos I
36 / 100
Model-checking
Especificam-se as propriedades desejadas para o algoritmo.

Constroi-se um modelo do algoritmo (p.ex. um sistema de estados
onde os estados sao valores das variaveis e transicoes sao operacoes
atomicas do algoritmo.)
Executa-se um verificador de modelos para verificar se o modelo tem
as propriedades enunciadas (p.ex. se o sistema alcanca algum estado
inconsistente). Tem limitac
oes de tamanho e restricoes para modelos
infinitos.
Algoritmos I
37 / 100
Mais sobre analise de correcao
M. Huth and M. Ryan. Logic in Computer Science: Modelling and

Reasoning about Systems, Cambridge University Press, 2nd edition
2004.
e outros.
Algoritmos I
38 / 100
Desempenho de algoritmos
Analise experimental.
Analise assintotica.
Algoritmos I
39 / 100
Analise experimental
Varios problemas praticos nao estao bem caracterizados do ponto de

vista teorico (sao complexos demais). A experimentacao e a u
nica
forma de analisar eficiencia.
Alguns algoritmos, notoriamente meta-heursticas, precisam ser
adaptados aos problemas reais. Essas adaptac
oes preservam os
princpios gerais do algoritmo original mas normalmente nao sao
analisadas formalmente.
Para ajustar parametros e identificar causas de falta de eficiencia e
efetividade, notoriamente em heursticas.
Nao deveria ser motivada pelo mito fazer um bom experimento e
muito mais facil que desenvolver boas teorias.
Algoritmos I
40 / 100
Analise experimental
Depende da implementacao dos algoritmos e e influenciada pela

experiencia do programador, linguagem de programacao, compilador,
sistema operacional e hardware.
O projeto dos experimentos deve ser prever um n
umero adequado de
repeticoes, escolha adequada de parametros para o funcionamento
dos algoritmos e para comparac
oes de resultados.
A analise dos resultados deve levar a conclus
oes que sejam
estatisticamente significativas.
A adicao de um novo algoritmo ou mudancas tecnologicas
normalmente exigem que todos os experimentos sejam refeitos.
Algoritmos I
41 / 100
Mais sobre analise experimental
I.P. Gent et al. How not to do it. Technical Report U. Strathclyde,

1997.
T. Bartz-Beielstein et al. Experimental Methods for the Analysis of
Optimization Algorithms, Springer-Verlag 2010.
e outros.
Algoritmos I
42 / 100
Modelo de computacao
Um modelo de computacao representa um agente de computacao.

Cada modelo de computacao e capaz de computar um certo conjunto
de funcoes, isto e, resolver um certo conjunto de problemas.
Cada modelo define suas operac
oes e uma mem
oria (se houver).
Quando estivermos analisando um algoritmo estaremos fazendo a
analise em relacao às operac
oes definidas para um modelo de
computacao e com relacao à mem
oria usada pelo modelo de
computacao.
Se modificarmos o modelo entao as analises podem perder a sua
validade.
Algoritmos I
43 / 100
Modelo RAM
O modelo RAM (Random Access Machine) e similar a um

computador digital e sera usado nas nossas analises.
O modelo RAM com mem
oria infinita e equivalente a outros modelos
importantes, como as Maquinas de Turing, e para os quais varias
propriedades teoricas sao conhecidas.
Algoritmos I
44 / 100
Modelo RAM
O modelo e composto por uma CPU e uma memoria.

A CPU possui apenas 2 registradores e opera em ciclos de
leitura-decodificacao-execucao das instruc
oes. Nao inclui nenhum tipo
de paralelismo.
A memoria e finita com palavras finitas. Armazena programas e
dados. As operacoes permitidas sao leitura e escrita de uma posicao
da memoria.
Os dados sao inteiros ou fracionarios e o conjunto de instrucoes inclui
movimentacao de dados entre a mem
oria e os registradores, operacoes
aritmeticas, condicionais, loops, chamadas e retorno de funcoes.
Algoritmos I
45 / 100
Modelo RAM
[Savage, Models of Computation, 1998]
Algoritmos I
46 / 100
Instancia, tamanho da entrada
Um conjunto de valores que serve como entrada para um problema e

chamado de inst
ancia.
O tamanho da entrada para um problema vai ser expresso da forma
mais adequado ao problema. Por exemplo,
I
para o problema da ordenacao o tamanho do problema sera o n

umero
de itens,
para o problema de testar se um n
umero e primo o tamanho do
problema sera o n
umero de bits usado para representar o n
umero,
para problemas em grafos o tamanho do problema sera o n
umero de
vertices e arestas no grafo
etc.
Algoritmos I
47 / 100
Analise assintotica
uma avaliacao teorica que fornece uma aproximacao do desempenho

E
de um algoritmo em termos de tempo de execucao e memoria sem
que seja necessario implementar e executar experimentos.
Normalmente e mais rapida que a analise experimental.
A analise assintotica e feita contando-se o n
umero de operacoes que o
algoritmo executa e expressando o resultado como uma funcao do
tamanho da entrada.
A analise assintotica faz simplificac
oes na forma de contar e na forma
de expressar o n
umero de operac
oes.
Algoritmos I
48 / 100
Simplificacoes na contagem
Considera-se
1
que cada instrucao do algoritmo pode ser convertida em um conjunto

finito e bem definido de instruc
oes da Maquina RAM e
cada instrucao leva tanto tempo quanto a instrucao mais lenta.
Dessa forma, considera-se que cada instrucao seja executada em 1

unidade de tempo.
Esta simplificacao subestima o n
umero de operacoes executadas por
uma constante multiplicativa.
Algoritmos I
49 / 100
Exemplo
Vamos considerar um algoritmo para somar os elementos de um vetor.

O tamanho da entrada e A.length, o n
umero de elementos do vetor,
que vamos chamar de n.
Sum-array(A)
1
2
3
4
sum = 0
sum = sum + A[i]
return sum
Algoritmos I
50 / 100
Exemplo
Contando temos:
operac
oes
Sum-array(A)
1
2
3
4
sum = 0
sum = sum + A[i]
return sum
1
n+1
n
1
Somando temos: 1 + (n + 1) + n + 1 = 2n + 3.
Entao o tempo de execucao de Sum-array e aproximadamente
2n + 3.
Algoritmos I
51 / 100
Simplificacao na forma de expressar
Depois de contar o n
umero de instruc
oes, desconsideramos os termos
de menor ordem, coeficientes e constantes na equacao, e fazemos a
suposicao de que o tamanho da entrada e arbitrariamente grande.
No nosso exemplo, ao inves de 2n + 3 ficamos apenas com n.
Dizemos que o tempo de execucao do algoritmo e aproximadamente
n, para valores suficientemente grandes de n.
Outro exemplo: se contamos n2 + 200n + 2000 operacoes para o
algoritmo A, dizemos que o tempo de execucao de A e
aproximadamente n2 .
Algoritmos I
52 / 100
Outra simplificacao na contagem: operacao dominante
Como os termos constantes e termos de menor ordem sao ignorados,

podemos simplificar o processo contando apenas o n
umero de
execucoes de uma operac
ao dominante.
Uma operacao que e executada m vezes pelo algoritmo e dominante
se nenhuma outra operacao e executada mais que cm vezes, para
uma constante c.
Algoritmos I
53 / 100
Exemplo
Sum-array(A)
1
2
3
4
sum = 0
sum = sum + A[i]
return sum
Nesse algoritmo a soma e uma operacao dominante.

Assim podemos contar apenas o n
umero de somas.
Obtemos tempo de execucao aproximadamente n contando apenas o
n
umero de execucoes da linha 3.
Algoritmos I
54 / 100
Outras operacoes
if: n
umero de operac
oes do then ou pelo else, o que executar mais
operacoes.
switch: n
umero de operac
oes de sua clausula com mais operacoes.
subrotina: n
umero de operac
oes da subrotina.
Algoritmos I
55 / 100
Tipos de analise
Freq
uentemente o tempo de execucao de um algoritmo depende do
valor das entradas.
Entao dentre as entradas de um certo tamanho e necessario escolher
alguma que vai ser usada como referencia para analise.
As possibilidades sao:
uma entrada que causa a execucao do menor n
umero de instrucoes
(melhor caso),
uma entrada que causa a execucao de um n
umero medio de
instrucoes (caso medio) ou
uma entrada que causa a execucao o maior n
umero de instrucoes
(pior caso).
Algoritmos I
56 / 100
Analise de pior caso
O melhor caso nunca e usado porque todo algoritmo tem algum caso
trivial que nao e representa a dificuldade do problema.
O caso medio custuma ser difcil de definir e difcil de analisar.
O pior caso e uma boa indicacao pratica do comportamento tpico do
algoritmo.
Algoritmos I
57 / 100
Algoritmo eficiente
Um algoritmo e considerado eficiente se seu tempo de execucao e

limitado por um polin
omio no tamanho da entrada.
Por exemplo, 3n, 2n2 100, n51 , 1.000.000n2 , etc.
Algoritmos I
58 / 100
Na pratica
Na pratica, polinomios de graus muito grandes nao podem ser

considerados eficientes.
Ha algoritmos com a mesma analise te
orica mas constantes muito
diferentes, por exemplo, bubble-sort vs. selection sort.
Ha algoritmos com analise te
orica pior que sao melhores na pratica
que outros com analise te
orica melhor. Em muitos casos isso se deve
a padroes distintos de acesso à mem
oria, dependencias de dados que
dificultam otimizacoes do programa e paralelismo interno de
instrucoes na CPU.
Algoritmos I
59 / 100
No entanto
A combinacao de analise assint

otica com analise de pior caso, apesar
de aproximada, e rapida (!) e fornece uma boa indicacao da eficiencia
de um algoritmo.
independente de tecnologia e de todas as tecnicalidades da
E
experimentacao.
A analise teorica e particularmente u
til para indicar limites inferiores
para problemas.
Algoritmos I
60 / 100
Memoria
Para analisar o uso de mem

oria podemos usar a mesma tecnica,
contando o n
umero de posic
oes de mem
oria usadas pelo algoritmo.
Nao contamos a mem
oria usada pela entrada nem pela sada.
Algoritmos I
61 / 100
(Combinacoes)
Um problema P pode ser resolvido em um n

umero infinito de
modelos.
Para cada modelo M existe um n
umero infinito de algoritmos para
resolver P .
Para cada algoritmo A existe um n
umero infinito de medidas de
recursos R usados por A (tempo, mem
oria, tamanho, efetividade,
etc.)
Para cada medida R permite um n
umero infinito de analises (melhor
caso, caso medio, pior caso, potencias de 2, etc.)
Algoritmos I
62 / 100
Exemplo: Insertion-Sort
O algoritmo Insertion-Sort ordena um vetor A[1 . . n].
Insertion-Sort(A)
1
2
3
4
5
6
7
8
for j = 2 to A.length
key = A[j]
// Insert A[j] into the sorted sequence A[1 . . j 1].
i = j1
while i > 0 and A[i] > key
A[i + 1] = A[i]
i = i1
A[i + 1] = key
Algoritmos I
63 / 100
Insertion-sort
Vamos contar.
Mas o n
umero de execuc
oes do bloco 5:7 depende dos valores em A.
Entao vamos denotar o n
umero de vezes que uma linha no bloco 5:7
e executada para um certo valor de j de tj e o tamanho de A por n.
Insertion-Sort(A)
1
2
3
4
5
6
7
8
key = A[j]
// Insert A[j] into A[1 . . j 1].
i = j1
A[i + 1] = A[i]
i = i1
A[i + 1] = key
Algoritmos I
64 / 100
Insertion-sort
Vamos contar.
Mas o n
umero de execuc
operacoes
Insertion-Sort(A)
1
2
3
4
5
6
7
8
key = A[j]
i = j1
A[i + 1] = A[i]
i = i1
A[i + 1] = key
Algoritmos I
64 / 100
Insertion-sort
Vamos contar.
Mas o n
umero de execuc
operacoes
Insertion-Sort(A)
1
2
3
4
5
6
7
8
key = A[j]
i = j1
A[i + 1] = A[i]
i = i1
A[i + 1] = key
Algoritmos I
64 / 100
Insertion-sort
Vamos contar.
Mas o n
umero de execuc
operacoes
Insertion-Sort(A)
1
2
3
4
5
6
7
8
key = A[j]
i = j1
A[i + 1] = A[i]
i = i1
A[i + 1] = key
Algoritmos I
n
n1
64 / 100
Insertion-sort
Vamos contar.
Mas o n
umero de execuc
operacoes
Insertion-Sort(A)
1
2
3
4
5
6
7
8
key = A[j]
i = j1
A[i + 1] = A[i]
i = i1
A[i + 1] = key
Algoritmos I
n
n1
0
64 / 100
Insertion-sort
Vamos contar.
Mas o n
umero de execuc
operacoes
Insertion-Sort(A)
1
2
3
4
5
6
7
8
key = A[j]
i = j1
A[i + 1] = A[i]
i = i1
A[i + 1] = key
Algoritmos I
n
n1
0
n1
64 / 100
Insertion-sort
Vamos contar.
Mas o n
umero de execuc
operacoes
Insertion-Sort(A)
1
2
3
4
5
6
7
8
key = A[j]
i = j1
A[i + 1] = A[i]
i = i1
A[i + 1] = key
Algoritmos I
n
n1
0
n1
P
n
j=2 tj
64 / 100
Insertion-sort
Vamos contar.
Mas o n
umero de execuc
operacoes
Insertion-Sort(A)
1
2
3
4
5
6
7
8
key = A[j]
i = j1
A[i + 1] = A[i]
i = i1
A[i + 1] = key
Algoritmos I
n
n1
0
n1
P
n
tj
(t
j=2 j 1)
Pnj=2
64 / 100
Insertion-sort
Vamos contar.
Mas o n
umero de execuc
operacoes
Insertion-Sort(A)
1
2
3
4
5
6
7
8
key = A[j]
i = j1
A[i + 1] = A[i]
i = i1
A[i + 1] = key
Algoritmos I
n
n1
0
n1
P
n
t
Pnj=2 j
(t
1)
Pnj=2 j
j=2 (tj 1)
64 / 100
Insertion-sort
Vamos contar.
Mas o n
umero de execuc
operacoes
Insertion-Sort(A)
1
2
3
4
5
6
7
8
key = A[j]
i = j1
A[i + 1] = A[i]
i = i1
A[i + 1] = key
Algoritmos I
n
n1
0
n1
P
n
t
Pnj=2 j
(t
1)
Pnj=2 j
j=2 (tj 1)
n1
64 / 100
Somando
Somando temos:
T (n) = n + (n 1) + 0 + (n 1) +
n
X
j=2
tj +
n
X
(tj 1) +
j=2
n
X
(tj 1) + (n 1)
j=2
= 4n +
n
X
j=2
tj + 2
n
X
(tj 1) 3
j=2
O n
umero de vezes que as linhas 5, 6 e 7 sao executadas depende do
conte
udo de A.
Algoritmos I
65 / 100
Melhor caso
Quando A esta previamente ordenado, a linha 5 e executada apenas 1
vez em todas as iterac
oes para j. Assim,
T (n) = 4n +
= 4n +
n
X
tj + 2
n
X
(tj 1) 3
j=2
j=2
n
X
n
X
1+2
j=2
03
j=2
= 4n + n 1 + 0 3
= 5n 4
O tempo de execucao de melhor caso e aproximadamente n.
Cuidado: o melhor caso nao e quando n = 1. Sempre consideramos
que n e grande.
Algoritmos I
66 / 100
Pior caso
Quando A esta em ordem decrescente, a linha 5 e executada j vezes
(j 1 movimentacoes para a direita e um teste final). Assim,
T (n) = 4n +
= 4n +
n
X
j=2
n
X
tj + 2
j+2
j=2
n
X
(tj 1) 3
j=2
n
X
(j 1) 3
j=2
n(n + 1)
n(n 1)
1+2
3
2
2
3 2 7
n + n4
2
2
= 4n +
=
O tempo de execucao de pior caso e aproximadamente n2 .
Algoritmos I
67 / 100
Memoria
O n
umero de posicoes de mem
oria usadas (alem da entrada) e
constante.
memoria
Insertion-Sort(A)
1
2
3
4
5
6
7
8
key = A[j]
i = j1
A[i + 1] = A[i]
i = i1
A[i + 1] = key
Algoritmos I
1
1
0
1
0
0
0
0
68 / 100
Outro exemplo: Merge

O merge-sort e um algoritmo recursivo que divide um vetor A em dois
subvetores, ordena cada um recursivamente e depois intercala os dois
subvetores obtendo uma permutacao ordenada de A.
Merge-Sort(A, p, r)
1
2
3
4
5
if p < r
q = b(p + r)/2c
Merge-Sort(A, p, q)
Merge-Sort(A, q + 1, r)
Merge(A, p, q, r)
Merge, mostrado a seguir, e o algoritmo que intercala os subvetores

ordenados A[p . . q] e A[q + 1 . . r].
Algoritmos I
69 / 100
Intercalacao
Merge(A, p, q, r)
1 n1 = q p + 1
2 n2 = r q
3 let L[1 . . n1 + 1] and R[1 . . n2 + 1] be new arrays
4 for i = 1 to n1
5
L[i] = A[p + i 1]
6 for j = 1 to n2
7
R[j] = A[q + j]
8 L[n1 + 1] = inf
9 R[n2 + 1] = inf
10 i = 1
11 j = 1
12 for k = p to r
13
if L[i] R[j]
14
A[k] = L[i]
15
i=i+1
16
else A[k] = R[j]
17
j =j+1
Algoritmos I
70 / 100
Intercalacao
operacoes
Merge(A, p, q, r)
1 n1 = q p + 1
2 n2 = r q
4 for i = 1 to n1
5
L[i] = A[p + i 1]
6 for j = 1 to n2
7
R[j] = A[q + j]
8 L[n1 + 1] = inf
9 R[n2 + 1] = inf
10 i = 1
11 j = 1
12 for k = p to r
13
if L[i] R[j]
14
A[k] = L[i]
15
i=i+1
16
else A[k] = R[j]
17
j =j+1
Algoritmos I
71 / 100
Intercalacao
operacoes
Merge(A, p, q, r)
1
1 n1 = q p + 1
2 n2 = r q
4 for i = 1 to n1
5
L[i] = A[p + i 1]
6 for j = 1 to n2
7
R[j] = A[q + j]
8 L[n1 + 1] = inf
9 R[n2 + 1] = inf
10 i = 1
11 j = 1
12 for k = p to r
13
if L[i] R[j]
14
A[k] = L[i]
15
i=i+1
16
else A[k] = R[j]
17
j =j+1
Algoritmos I
71 / 100
Intercalacao
operacoes
Merge(A, p, q, r)
1
1 n1 = q p + 1
1
2 n2 = r q
4 for i = 1 to n1
5
L[i] = A[p + i 1]
6 for j = 1 to n2
7
R[j] = A[q + j]
8 L[n1 + 1] = inf
9 R[n2 + 1] = inf
10 i = 1
11 j = 1
12 for k = p to r
13
if L[i] R[j]
14
A[k] = L[i]
15
i=i+1
16
else A[k] = R[j]
17
j =j+1
Algoritmos I
71 / 100
Intercalacao
operacoes
Merge(A, p, q, r)
1
1 n1 = q p + 1
1
2 n2 = r q
2
4 for i = 1 to n1
5
L[i] = A[p + i 1]
6 for j = 1 to n2
7
R[j] = A[q + j]
8 L[n1 + 1] = inf
9 R[n2 + 1] = inf
10 i = 1
11 j = 1
12 for k = p to r
13
if L[i] R[j]
14
A[k] = L[i]
15
i=i+1
16
else A[k] = R[j]
17
j =j+1
Algoritmos I
71 / 100
Intercalacao
operacoes
Merge(A, p, q, r)
1
1 n1 = q p + 1
1
2 n2 = r q
2
n1 + 1
4 for i = 1 to n1
5
L[i] = A[p + i 1]
6 for j = 1 to n2
7
R[j] = A[q + j]
8 L[n1 + 1] = inf
9 R[n2 + 1] = inf
10 i = 1
11 j = 1
12 for k = p to r
13
if L[i] R[j]
14
A[k] = L[i]
15
i=i+1
16
else A[k] = R[j]
17
j =j+1
Algoritmos I
71 / 100
Intercalacao
operacoes
Merge(A, p, q, r)
1
1 n1 = q p + 1
1
2 n2 = r q
2
n1 + 1
4 for i = 1 to n1
n1
5
L[i] = A[p + i 1]
6 for j = 1 to n2
7
R[j] = A[q + j]
8 L[n1 + 1] = inf
9 R[n2 + 1] = inf
10 i = 1
11 j = 1
12 for k = p to r
13
if L[i] R[j]
14
A[k] = L[i]
15
i=i+1
16
else A[k] = R[j]
17
j =j+1
Algoritmos I
71 / 100
Intercalacao
operacoes
Merge(A, p, q, r)
1
1 n1 = q p + 1
1
2 n2 = r q
2
n1 + 1
4 for i = 1 to n1
n1
5
L[i] = A[p + i 1]
n2 + 1
6 for j = 1 to n2
7
R[j] = A[q + j]
8 L[n1 + 1] = inf
9 R[n2 + 1] = inf
10 i = 1
11 j = 1
12 for k = p to r
13
if L[i] R[j]
14
A[k] = L[i]
15
i=i+1
16
else A[k] = R[j]
17
j =j+1
Algoritmos I
71 / 100
Intercalacao
operacoes
Merge(A, p, q, r)
1
1 n1 = q p + 1
1
2 n2 = r q
2
n1 + 1
4 for i = 1 to n1
n1
5
L[i] = A[p + i 1]
n2 + 1
6 for j = 1 to n2
n2
7
R[j] = A[q + j]
8 L[n1 + 1] = inf
9 R[n2 + 1] = inf
10 i = 1
11 j = 1
12 for k = p to r
13
if L[i] R[j]
14
A[k] = L[i]
15
i=i+1
16
else A[k] = R[j]
17
j =j+1
Algoritmos I
71 / 100
Intercalacao
operacoes
Merge(A, p, q, r)
1
1 n1 = q p + 1
1
2 n2 = r q
2
n1 + 1
4 for i = 1 to n1
n1
5
L[i] = A[p + i 1]
n2 + 1
6 for j = 1 to n2
n2
7
R[j] = A[q + j]
1
8 L[n1 + 1] = inf
9 R[n2 + 1] = inf
10 i = 1
11 j = 1
12 for k = p to r
13
if L[i] R[j]
14
A[k] = L[i]
15
i=i+1
16
else A[k] = R[j]
17
j =j+1
Algoritmos I
71 / 100
Intercalacao
operacoes
Merge(A, p, q, r)
1
1 n1 = q p + 1
1
2 n2 = r q
2
n1 + 1
4 for i = 1 to n1
n1
5
L[i] = A[p + i 1]
n2 + 1
6 for j = 1 to n2
n2
7
R[j] = A[q + j]
1
8 L[n1 + 1] = inf
1
9 R[n2 + 1] = inf
10 i = 1
11 j = 1
12 for k = p to r
13
if L[i] R[j]
14
A[k] = L[i]
15
i=i+1
16
else A[k] = R[j]
17
j =j+1
Algoritmos I
71 / 100
Intercalacao
operacoes
Merge(A, p, q, r)
1
1 n1 = q p + 1
1
2 n2 = r q
2
n1 + 1
4 for i = 1 to n1
n1
5
L[i] = A[p + i 1]
n2 + 1
6 for j = 1 to n2
n2
7
R[j] = A[q + j]
1
8 L[n1 + 1] = inf
1
9 R[n2 + 1] = inf
1
10 i = 1
11 j = 1
12 for k = p to r
13
if L[i] R[j]
14
A[k] = L[i]
15
i=i+1
16
else A[k] = R[j]
17
j =j+1
Algoritmos I
71 / 100
Intercalacao
operacoes
Merge(A, p, q, r)
1
1 n1 = q p + 1
1
2 n2 = r q
2
n1 + 1
4 for i = 1 to n1
n1
5
L[i] = A[p + i 1]
n2 + 1
6 for j = 1 to n2
n2
7
R[j] = A[q + j]
1
8 L[n1 + 1] = inf
1
9 R[n2 + 1] = inf
1
10 i = 1
1
11 j = 1
12 for k = p to r
13
if L[i] R[j]
14
A[k] = L[i]
15
i=i+1
16
else A[k] = R[j]
17
j =j+1
Algoritmos I
71 / 100
Intercalacao
operacoes
Merge(A, p, q, r)
1
1 n1 = q p + 1
1
2 n2 = r q
2
n1 + 1
4 for i = 1 to n1
n1
5
L[i] = A[p + i 1]
n2 + 1
6 for j = 1 to n2
n2
7
R[j] = A[q + j]
1
8 L[n1 + 1] = inf
1
9 R[n2 + 1] = inf
1
10 i = 1
1
11 j = 1
n+1
12 for k = p to r
13
if L[i] R[j]
14
A[k] = L[i]
15
i=i+1
16
else A[k] = R[j]
17
j =j+1
Algoritmos I
71 / 100
Intercalacao
operacoes
Merge(A, p, q, r)
1
1 n1 = q p + 1
1
2 n2 = r q
2
n1 + 1
4 for i = 1 to n1
n1
5
L[i] = A[p + i 1]
n2 + 1
6 for j = 1 to n2
n2
7
R[j] = A[q + j]
1
8 L[n1 + 1] = inf
1
9 R[n2 + 1] = inf
1
10 i = 1
1
11 j = 1
n+1
12 for k = p to r
n
13
if L[i] R[j]
14
A[k] = L[i]
15
i=i+1
16
else A[k] = R[j]
17
j =j+1
Algoritmos I
71 / 100
Intercalacao
operacoes
Merge(A, p, q, r)
1
1 n1 = q p + 1
1
2 n2 = r q
2
n1 + 1
4 for i = 1 to n1
n1
5
L[i] = A[p + i 1]
n2 + 1
6 for j = 1 to n2
n2
7
R[j] = A[q + j]
1
8 L[n1 + 1] = inf
1
9 R[n2 + 1] = inf
1
10 i = 1
1
11 j = 1
n+1
12 for k = p to r
n
13
if L[i] R[j]
n
14
A[k] = L[i]
15
i=i+1
16
else A[k] = R[j]
17
j =j+1
Algoritmos I
71 / 100
Intercalacao
operacoes
Merge(A, p, q, r)
1
1 n1 = q p + 1
1
2 n2 = r q
2
n1 + 1
4 for i = 1 to n1
n1
5
L[i] = A[p + i 1]
n2 + 1
6 for j = 1 to n2
n2
7
R[j] = A[q + j]
1
8 L[n1 + 1] = inf
1
9 R[n2 + 1] = inf
1
10 i = 1
1
11 j = 1
n+1
12 for k = p to r
n
13
if L[i] R[j]
n
14
A[k] = L[i]
n
15
i=i+1
16
else A[k] = R[j]
17
j =j+1
Algoritmos I
71 / 100
Intercalacao
operacoes
Merge(A, p, q, r)
1
1 n1 = q p + 1
1
2 n2 = r q
2
n1 + 1
4 for i = 1 to n1
n1
5
L[i] = A[p + i 1]
n2 + 1
6 for j = 1 to n2
n2
7
R[j] = A[q + j]
1
8 L[n1 + 1] = inf
1
9 R[n2 + 1] = inf
1
10 i = 1
1
11 j = 1
n+1
12 for k = p to r
n
13
if L[i] R[j]
n
14
A[k] = L[i]
n
15
i=i+1
0
16
else A[k] = R[j]
17
j =j+1
Algoritmos I
71 / 100
Intercalacao
operacoes
Merge(A, p, q, r)
1
1 n1 = q p + 1
1
2 n2 = r q
2
n1 + 1
4 for i = 1 to n1
n1
5
L[i] = A[p + i 1]
n2 + 1
6 for j = 1 to n2
n2
7
R[j] = A[q + j]
1
8 L[n1 + 1] = inf
1
9 R[n2 + 1] = inf
1
10 i = 1
1
11 j = 1
n+1
12 for k = p to r
n
13
if L[i] R[j]
n
14
A[k] = L[i]
n
15
i=i+1
0
16
else A[k] = R[j]
0
17
j =j+1
Algoritmos I
71 / 100
Intercalacao
O tempo de execucao do Merge, e aproximadamente n.

Isso vale para o melhor caso e tambem para o pior caso.
A memoria (alem da entrada e da sada) tambem e aproximadamente
n.
Algoritmos I
72 / 100
Secoes
CLRS09: captulo 3.
Man89: secoes 3.1 a 3.3.
Algoritmos I
73 / 100
Classes de funcoes assintoticas
As notacoes O, , , o e sao usadas para expressar as simplificacoes

feitas na analise assint
otica e para formalizar a nocao de uma
aproximacao em funcao do tamanho da entrada.
Cada uma delas define um conjunto (ou classe) de funcoes.
Algoritmos I
74 / 100
O(g(n))
{f (n) : existem constantes positivas c e n0

tais que 0 f (n) cg(n) para todo n n0 }
Informalmente, se f (n) O(g(n)) entao f (n) cresce no maximo tao

rapidamente quanto g(n).
Se f (n) O(g(n)) com o mesmo sentido tambem dizemos
f (n) = O(g(n)) e f (n)
e O(g(n)).
Algoritmos I
75 / 100
Exemplos
Seja f (n) = 6n + 10. Vamos verificar se f (n) = O(n).
Algoritmos I
76 / 100
Exemplos
Seja f (n) = 6n + 10. Vamos verificar se f (n) = O(n).

Vamos escolher c = 10. Entao
6n + 10 10n
n 10/4
n > 3
Entao para c = 10 e n0 = 3 temos f (n) cn. Conclumos que
f (n) = O(n).
Algoritmos I
76 / 100
Exemplos
Seja f (n) = 12 n2 3n. Vamos verificar se f (n) O(n2 ).
Algoritmos I
77 / 100
Exemplos
Seja f (n) = 12 n2 3n. Vamos verificar se f (n) O(n2 ).
1 2
2n
3n = 0 tem zeros em n = 0, n = 6 e entao f (n) 0 se n 0

ou n 6. Tomando n0 = 7,
1 2
n 3n cn2
2
1 2
7 37
2
1
49 21
2
7
2
1
14
c72
49c
49c
c
Entao para c = 1/14 e n0 = 7 temos f (n) cn2 . Conclumos que

f (n) = O(n2 ).
Algoritmos I
77 / 100
Exemplos
5n2 + 15 = O(n3 ).
Fazendo c = 6 e n0 = 1, 5n2 + 15 6n3 para todo n > 1.
Algoritmos I
78 / 100
Exemplos
Algoritmos I
79 / 100
Exemplos
5n2 + 15 6= O(n) (n 6
c15
5 ).
Algoritmos I
79 / 100
Exemplos
5n2 + 15 6= O(n) (n 6
c15
5 ).
n = O(n)
Algoritmos I
79 / 100
Exemplos
5n2 + 15 6= O(n) (n 6
c15
5 ).
n = O(n)
n = O(n2 )
Algoritmos I
79 / 100
Exemplos
5n2 + 15 6= O(n) (n 6
c15
5 ).
n = O(n)
n = O(n2 )
n = O(n3 )
Algoritmos I
79 / 100
Exemplos
5n2 + 15 6= O(n) (n 6
c15
5 ).
n = O(n)
n = O(n2 )
n = O(n3 )
n = O(nn )
Algoritmos I
79 / 100
Exemplos
5n2 + 15 6= O(n) (n 6
c15
5 ).
n = O(n)
n = O(n2 )
n = O(n3 )
n = O(nn )
n = O(n2 )
Algoritmos I
79 / 100
Exemplos
5n2 + 15 6= O(n) (n 6
c15
5 ).
n = O(n)
n = O(n2 )
n = O(n3 )
n = O(nn )
n = O(n2 )
= O(1)
Algoritmos I
79 / 100
Exemplos
5n2 + 15 6= O(n) (n 6
c15
5 ).
n = O(n)
n = O(n2 )
n = O(n3 )
n = O(nn )
n = O(n2 )
= O(1)
1080 = O(1)
Algoritmos I
79 / 100
(g(n))
{f (n) : existem constantes positivas c e n0

tais que 0 cg(n) f (n) para todo n n0 }
Informalmente, se f (n) (g(n)) entao f (n) cresce no mnimo tao

lentamente quanto g(n).
Algoritmos I
80 / 100
(g(n))
{f (n) : existem constantes positivas c1 , c2 e n0

tais que 0 c1 g(n) f (n) c2 g(n)
para todo n n0 }
Informalmente, se f (n) (g(n)) entao f (n) cresce tao rapidamente

quanto g(n).
Se f (n) O(g(n)) e f (n) (g(n)) entao f (n) (g(n)) e
vice-versa.
Algoritmos I
81 / 100
o(g(n))
{f (n) : para toda constante positiva c, existe

constante n0 > 0 tal que 0 f (n) < cg(n),
para todo n n0 }
Informalmente, se f (n) o(g(n)) entao f (n) cresce mais lentamente

que g(n).
o representa um limite assint
otico superior que nao e apertado.
Se f (n) = o(g(n)) entao f (n) = O(g(n)).
Algoritmos I
82 / 100
Exemplos
Vamos mostrar que 1000n2 o(n3 ).
Precisamos mostrar que,
0 1000n2 < cn3 , para todo n n0 .
Dividindo por n3 , obtemos a inequacao
0
1000
e decrescente
n

+1 a
n0 = 1000
c
1000
< c.
n
e se iguala a c quando n = 1000

c . Fazendo
equacao sempre se verifica para n n0 .
Algoritmos I
83 / 100
Exemplos
Vamos mostrar que 1000n2 o(n3 ).
Precisamos mostrar que,
0 1000n2 < cn3 , para todo n n0 .
Dividindo por n3 , obtemos a inequacao
0
1000
e decrescente
n

+1 a
n0 = 1000
c
1000
< c.
n
e se iguala a c quando n = 1000

c . Fazendo
equacao sempre se verifica para n n0 .
facil ver que 1000n2 6 o(n2 ).

E
Algoritmos I
83 / 100
(g(n))
{f (n) : para toda constante positiva c, existe uma

constante n0 > 0 tal que 0 cg(n) < f (n),
para todo n n0 }
Informalmente, se f (n) (g(n)), entao f (n) cresce mais

rapidamente que g(n).
representa um limite assint
otico inferior que nao e apertado.
Se f (n) = (g(n)) entao f (n) = (g(n)).
Algoritmos I
84 / 100
Melhor, medio, pior
Nao confundir melhor caso com , caso medio com e pior caso
com O.
A rigor cada tipo de analise leva a um resultado que pode ser limitado
inferior ou superiormente.
Por exemplo, suponha um algoritmo A com entrada de tamanho n
executa 3n2 operacoes no pior caso. Exceto quando n e potencia de
2, caso em que o algoritmo executa 5n operac
oes no pior caso.
Entao podemos dizer que o tempo de execucao de pior caso de A e
O(n2 ) e e (n).
Algoritmos I
85 / 100
Definicoes pelo limite
f (n)
=0
g(n)
f (n)
f (n) O(g(n)) se lim
<
n g(n)
f (n)
f (n) (g(n)) se 0 < lim
<
n g(n)
f (n)
f (n) (g(n)) se lim
>0
n g(n)
f (n)
f (n) (g(n)) se lim
=
n g(n)
f (n) o(g(n)) se lim
Algoritmos I
86 / 100
Regra de LHopital
Sejam f e g funcoes diferenciaveis tais que
limn f (n) = limn g(n) = 0 ou . Se o limite de
f (n)0 /g(n)0 existir entao,
f 0 (n)
f (n)
= lim 0
n g (n)
n g(n)
Exemplo: Seja f (n) = ln n e g(n) = n. Como f 0 (n) = 1/n e
g 0 (n) = 1/2 n,
lim
f (n)
f 0 (n)
1/n
1
= lim
=0
= lim 0
= lim
n g(n)
n g (n)
n 1/2 n
n 2n n
lim
Portanto, f (n) = o(g(n)).
Algoritmos I
87 / 100
Propriedades das classes
Transitividade:
Se f (n) O(g(n)) e g(n) O(h(n)), entao f (n) O(h(n))
Se f (n) (g(n)) e g(n) (h(n)), entao f (n) (h(n))
Se f (n) o(g(n)) e g(n) o(h(n)), entao f (n) o(h(n))
Algoritmos I
88 / 100
Propriedades das classes

Reflexividade:
f (n) O(f (n))
f (n) (f (n))
f (n) (f (n))
Simetria:
f (n) (g(n)) se e somente se g(n) (f (n))
Simetria transposta:
f (n) O(g(n)) se e somente se g(n) (f (n))
f (n) o(g(n)) se e somente se g(n) (f (n))
Algoritmos I
89 / 100
Em expressoes
As notacoes podem ser usadas em express

oes quando for conveniente.
Por exemplo,
T (n) = T (bn/2c) + O(n)
I(n) = n log n + O(1)
S(n) = 3n3 + n2 + (n)
Algoritmos I
90 / 100
Exemplo: Merge-sort
Merge-Sort(A, p, r)
1
2
3
4
5
if p < r
q = b(p + r)/2c
Merge-Sort(A, p, q)
Merge(A, p, q, r)
Ja vimos que Merge faz 3n + 11 operac

oes no pior caso para uma
entrada de tamanho n. Entao e (n).
O tempo de execucao de algoritmos recursivos como o merge-sort
pode ser expresso por uma relacao de recorrencia, uma formula
definida em termos dela mesma.
Vamos denotar o tempo de execucao do merge-sort para uma entrada
de tamanho n por T (n).
Algoritmos I
91 / 100
Tempo de execucao do Merge-sort

Merge-Sort(A, p, r)
1 if p < r
2
q = b(p + r)/2c
3
Merge-Sort(A, p, q)
4
5
Merge(A, p, q, r)
operacoes
(1)
(1)
T (dn/2e)
T (bn/2c)
(n)
Somando temos T (n) = T (dn/2e) + T (bn/2c) + (n) + (2).

A recorrencia e

T (n) =
(1)
T (dn/2e) + T (bn/2c) + (n)
se n = 1
c.c.
Resolvendo a recorrencia, obtemos T (n) = (n log n).

A resolucao de recorrencias e um dos pr
oximos assuntos.
Algoritmos I
92 / 100
Exemplo: busca sequencial
Sequential-Search(A, k)
1
2
3
4
5
6
7
8
9
A[|A| + 1] = k
i=1
while (true)
if A[i] == k
if i |A|
return i
else
return 0
i=i+1
Algoritmos I
93 / 100
Exemplo: busca sequencial
Quais os tempos de execucao de melhor e de pior caso em funcao do

tamanho da entrada?
Qual o tempo de execucao de caso medio se todas as chaves tem a
mesma probabilidade de serem selecionadas?
Algoritmos I
94 / 100
Exemplo: busca binaria
Binary-Search(A, l, r, k)
1
2
3
4
5
6
7
8
9
if l > r
return 0
m = b(l + r)/2c
if A[m] == k
return m
elseif k < A[m]
return Binary-Search(A, l, m 1, k)
else
return Binary-Search(A, m + 1, r, k)
Algoritmos I
95 / 100
Busca binaria
Qual o tempo de execucao de pior caso em funcao do tamanho da

entrada?
Algoritmos I
96 / 100
Busca binaria

entrada?
A cada passo a busca realiza trabalho constante e divide a entrada
n1
em partes de tamanho d n1
2 e e b 2 c
A recorrencia para o pior caso e T (n) = T (d n1
2 e) + c.
O algoritmo e O(lg n) no pior caso.
Algoritmos I
96 / 100
Exemplo: count
Count(x)
1
2
3
4
k =1
for i = 1 to x
k = k+1
return k
Algoritmos I
97 / 100
Exemplo: count

entrada?
Algoritmos I
98 / 100
Exemplo: count

entrada?
O tamanho da entrada n e o menor n
umero de bits na representacao
de x. Entao 2n1 x < 2n .
No pior caso, a linha 3 e executada O(2n ) vezes.
Dizer que o algoritmo e O(x) e um abuso da notacao, ja que o
tamanho da entrada nao e x.
Algoritmos I
98 / 100
Exemplo: pairing
Pairing(A, B)
1
2
3
4
5
6
7
8
9
10
c=0
for i = 1 to n
for j = 1 to m
if A[i] == B[j]
c = c+1
break
if c == n
return 1
else
return 0
Algoritmos I
99 / 100
Exemplo: pairing

entrada?
Algoritmos I
100 / 100
Exemplo: pairing

entrada?
T (n, m) = (nm).
T (n, m) 6= O(n2 ), T (n, m) 6= O(m2 ), T (n, m) 6= (n2 ),
T (n, m) 6= (m2 ).
Algoritmos I
100 / 100

Aula01 - Indução - Principio Analise

Загружено:

Сведения о документе

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Aula01 - Indução - Principio Analise

Загружено:

Авторское право:

Доступные форматы

Algoritmos I

G.P. Telles (ICUNICAMP)

Estes slides sao baseados principalmente nos livros:

Estes slides sao incompletos. Contem e sempre conterao erros,

G.P. Telles (ICUNICAMP)

G.P. Telles (ICUNICAMP)

G.P. Telles (ICUNICAMP)

Um problema e uma questao que precisa ser respondida. Pode incluir

G.P. Telles (ICUNICAMP)

Podemos classificar problemas computacionais de acordo com o efeito

Problemas de busca: encontrar x na entrada que satisfaz a propriedade

G.P. Telles (ICUNICAMP)

Algoritmos como tecnologia

Vamos supor que temos um vetor de tamanho n para ordenar.

Insertion-sort, que gasta tempo c1 n2 , onde c1 e uma constante que nao

Vamos supor que temos duas implementac

uma excelente para Insertion-sort em linguagem de baixo nvel, tal que

G.P. Telles (ICUNICAMP)

Algoritmos como tecnologia

Se n for igual a 10 milh

G.P. Telles (ICUNICAMP)

Algoritmos como tecnologia

A diferenca e de 5.5 horas para menos de 20 minutos executando o

G.P. Telles (ICUNICAMP)

Algoritmos como tecnologia

O exemplo ilustra que melhorias de desempenho obtidas por escolhas

G.P. Telles (ICUNICAMP)

Custo de desenvolvimento versus custo de execucao.

Um algoritmo eficiente pode ser complicado e pode nao haver alguem

Em algumas aplicacoes, precisao e estabilidade sao tao importantes

G.P. Telles (ICUNICAMP)

G.P. Telles (ICUNICAMP)

G.P. Telles (ICUNICAMP)

Seja P um predicado com parametro n.

G.P. Telles (ICUNICAMP)

Para provar um teorema T (n) por inducao e necessario:

mostrar que T vale para 1 (caso base), e

G.P. Telles (ICUNICAMP)

Vamos mostrar que S1 (n) =

G.P. Telles (ICUNICAMP)

Para todo natural n, S1 (n) =

Prova por inducao em n.

G.P. Telles (ICUNICAMP)

Para todo natural n, S1 (n) =

G.P. Telles (ICUNICAMP)

Para todo natural n, S1 (n) =

G.P. Telles (ICUNICAMP)

Para todo natural n, S1 (n) =

G.P. Telles (ICUNICAMP)

Para todo natural n, S1 (n) =

G.P. Telles (ICUNICAMP)

Para todo natural n, S1 (n) =

S1 (n) = S1 (n 1) + n (direto da definicao de S1 )

G.P. Telles (ICUNICAMP)

Para todo natural n, S1 (n) =

S1 (n) = S1 (n 1) + n (direto da definicao de S1 )

G.P. Telles (ICUNICAMP)

Para todo natural n, S1 (n) =

S1 (n) = S1 (n 1) + n (direto da definicao de S1 )

G.P. Telles (ICUNICAMP)

Para todo natural n, S1 (n) =

Mostramos que o enunciado e valido para 1 e que a validade para

G.P. Telles (ICUNICAMP)

Podemos usar n ou n + 1, o que e equivalente: