Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
PROJETO E ANLISE DE
ALGORITMOS
Projeto e Anlise de
Algoritmos
CDD 005.1
A responsabilidade pelo texto e imagens desta obra do autor. O contedo desta obra foi licenciado, temporria e
gratuitamente, para utilizao no mbito do Sistema Universidade Aberta do Brasil, atravs da UFPI. O leitor se compromete
a utilizar o contedo desta obra para aprendizado pessoal, sendo que a reproduo e distribuio ficaro limitadas ao mbito
interno dos cursos. A citao desta obra em trabalhos acadmicos e/ou profissionais poder ser feita, com indicao da fonte.
A cpia desta obra sem autorizao expressa, ou com intuito de lucro, constitui crime contra a propriedade intelectual, com
sanes previstas no Cdigo Penal.
proibida a venda deste material.
Ao desenvolver um sistema computacional, no podemos deixar
de levar em considerao todos os aspectos que influem positiva ou
negativamente na sua execuo. Projetar bem um sistema antes de sua
implementao pode reduzir drasticamente o tempo de sua concluso, alm
de utilizar mais eficientemente todos os recursos computacionais que se tem
disposio.
O objetivo desta apostila proporcionar ao leitor um entendimento
no que se refere ao desenvolvimento de bons algoritmos e sua anlise. O
texto foi escrito de forma simples e objetiva. Cada captulo acompanhado
de embasamento terico e prtico dos fundamentos de anlise, bem como
exemplos de boas implementaes e exerccios. A bibliografia e a web
bibliografia ao fim das notas so suficientes para que o leitor se aprofunde na
teoria apresentada em cada unidade.
Na Unidade I so apresentados os conceitos relacionados aos
fundamentos de anlise de algoritmos, os quais sero descritos suas
definies e principais situaes relacionadas aos problemas de anlise.
Na Unidade II descrita a forma como analisar as principais estruturas
contidas em algoritmos, de maneira que possa determinar uma ordem de
grandeza do seu desempenho.
Na Unidade III so apresentadas as principais estratgias para
elaborao de algoritmos com bom desempenho, conforme a natureza dos
problemas tomados.
Por fim, na Unidade IV apresentada uma classificao dos principais
problemas computacionais em estudo e as suas ordens de complexidade,
enfocando a natureza de sua resoluo.
UNIDADE 1
11 FUNDAMENTOS DE ANLISE DE ALGORITMOS
Fundamentos de algoritmos........................................................ 11
Conceitos bsicos......................................................................... 18
Recorrncias................................................................................. 32
UNIDADE 2
35 tcnicas de anlise de algoritmos
Anlise de algoritmos................................................................... 47
Complexidade de algoritmos........................................................ 48
UNIDADE 3
35 tcnicas de projeto de algoritmos
Introduo.................................................................................... 63
Fora bruta................................................................................... 63
Dividir- e-conquistar..................................................................... 64
Programao dinmica................................................................. 70
Algoritmos gulosos....................................................................... 76
UNIDADE 4
35 classes de problemas
Introduo.................................................................................. 103
Solucionabilidade de problemas............................................... 103
Formas de problemas................................................................. 105
Problemas de deciso classe p................................................... 106
Classe np.................................................................................... 108
Classe co-np................................................................................ 109
Classe np-completo.................................................................... 110
Algumas redues...................................................................... 112
A classe np-difcil........................................................................ 113
Relaes entre classes de problemas......................................... 113
Backtracking e branch-and-bound............................................. 114
UNIDADE 1
Fundamentos de anlise de
algoritmo
Resumindo
Esta unidade dedicada aos conceitos iniciais relacionados anlise de algoritmos, noes de
funo de complexidade e suas variaes, eficincias e avaliao emprica de algoritmos e s
variveis envolvidas nesse processo.
Fundamentos de anlise de
algoritmo
FUNDAMENTOS DE ALGORITMOS
Introduo
Algoritmo
O que um Algoritmo?
Definies:
Segundo o dicionrio de Aurlio, algoritmo sob o ponto de vista da
matemtica processo de clculo ou de resoluo de um grupo de problemas
12 unidade 1
fundamental da cincia da computao. Algoritmo muito mais que um
ramo da cincia da computao. o ncleo da cincia da computao e com
toda a imparcialidade, pode ser considerado relevante para a maioria das
cincias, negcios e tecnologia. Programas de computadores no existiriam
sem algoritmos.
Instncia
14 unidade 1
Medida do custo para execuo do programa
Funo de Complexidade
Eficincia de Algoritmos
Computador B demora:
16 unidade 1
menos tempo computacional, ou seja, mais eficiente do que o algoritmo de
ordenao por insero e esta vantagem ainda maior proporo que n
cresce.
CONCEITOS BSICOS
- Edsger W. Dijkstra
Introduo
18 unidade 1
desempenho e escolher, entre os algoritmos disponveis, o melhor. Existem
vrios critrios de avaliao de um algoritmo como: quantidade de trabalho
requerido, quantidade de espao requerido, simplicidade, exatido de
resposta e otimizao (TOSCANI, 2001).
As medidas de complexidade introduzem as ideias de complexidade
de pessimista (pior caso), bem como as medidas de complexidade de tempo
e espao.
Tabela 1.2
Ordens Assintticas
20 unidade 1
negativos: de N em R+ .
Uma cota assinttica superior (CAS) uma funo que cresce mais
rapidamente que outra e a partir de certo ponto est acima. Por exemplo,
uma funo cbica n3 cresce mais rapidamente do que uma quadrtica
n2. Dizemos que a cbica n3 CAS para n2. Do mesmo modo, uma funo
exponencial 2n CAS para n2.
Definio:
Em geral, define-se que g uma cota assinttica superior para f, se e
somente se (n0 N)(n n0) f(n) g(n)
Para n suficientemente grande, g(n) domina f(n).
Exemplo: O grfico da Figura 1.2 mostra esta notao O:
Figura 1.2:
Notao O
f n
Alternativamente, f(n) O(g(n)) se lim constante (mas
no infinito). g n
Exemplo: Seja f(n)=13n3+2n2+5nlogn e g(n)=n3, ento:
Simbolicamente:
O(g(n) = {f : N R+ | (c R+*)(n0 N)(n n0)[f(n) c.g(n)]}
Normalmente diz-se que f(n) O(g(n)) ou f(n) O(g(n)).
Exemplo grfico da Figura 1.3 de dominao assinttica que ilustra a
notao O.
Figura 1.3.
22 unidade 1
Exemplo: Verifique, se g(n)=(n+1)2, ento:
g(n) O(n2) ou g(n)=O(n2), ou seja, (cR*+)((n0N)(nn0) g(n)
cf(n)
f(n)=n2
(n+1)2 c.n2
n2+2n+1 c.n2 c 1 + 2/n + 1/n 2
Demonstrao:
Neste caso:
n 4 , se n par
mximof n , g n 3
n , se n mpar
24 unidade 1
Proposio 2
Se T1(n) e T2(n) so de ordem O(f(n)) e O(g(n)) respectivamente,
ento:
T(n) = T1(n) . T2(n) de ordem O(f(n).g(n)).
Demonstrao
Teorema:
Demonstrao:
Usando a definio:
T(n) = O(nm) ( c R ) T(n) c.n ,
+
2
n no
|T(n)| |tm|n + |tm-1|n
m m-1
+...+ |t1|n+|to|
|T(n)| (|tm|+ |tm-1|/n+...+ |to|/nm)nm
|T(n)| = (|tm|+...+ |to|)nm, n 1
Resoluo:
Provar que este limite existe.
lim lim ~ ~
f n /g n f n / g n
n n
1
lim log n / n lim1/ n /
) lim 2 / n 0
2 n
1. Notao (mega)
26 unidade 1
Diz-se que g(n) (f(n)), se e somente se, para alguma constante c
R*+ e no N tal que g(n) c.f(n)
Isto : (f(n)) = {g: NR+ |( c R*+)( no N) ( n no)[g(n)
c.f(n)]}
Em outra palavras, (f(n)) um conjunto de todas as funes g(n)
limitadas inferiormente por mltiplo real positivo de f(n), para n suficientemente
grande.
Exemplo: Para mostrar que g(n)= 3n3+2n2 (n3), basta fazer c=1, e
ento 3n3+2n2 n3 para n 0.
Exemplo: Seja g(n)=n para n mpar (n 1) e g(n) = n2/10 para n par (n
0). Neste caso, g(n) (n2), bastando considerar c=1/10 e n=0,2,4,...
Exemplo: A Figura 1.4 mostra o grfico para a notao .
Figura 1.4
1. Notao (Theta)
28 unidade 1
Reflexividade:
1. f(n)= (f(n))
2. f(n)= O(f(n))
3. f(n)= (f(n))
Simetria:
1. f(n)=O(g(n)) se e somente se g(n)=O(f(n))
Transitividade:
2. f(n) = (g(n)) e g(n) = (h(n)) implicam f(n) = (h(n))
3. f(n) = O(g(n)) e g(n) = O(h(n)) implicam f(n) = O(h(n))
4. f(n) = (g(n)) e g(n) = (h(n)) implicam f(n) = (h(n))
Comportamento Assinttico
1. f(n)=O(1)
1. Algoritmos de complexidade O(1) so ditos de complexidade
constante. O uso do algoritmo independe do tamanho de n. As instrues do
algoritmo so executadas um nmero fixo de vezes.
2. f(n) = O(log n)
1. Um algoritmo de complexidade O(log n) dito ter complexidade
logartmica. Esse tipo de execuo ocorre em algoritmos que resolvem um
problema transformando-o em problemas pequenos.
1. f(n) = O(n)
1. Um algoritmo de complexidade O(n) dito ter complexidade linear.
1. f(n) = O(nlog n)
1. Tpico em algoritmos que quebram um problema em outros menores
resolve cada um deles independentemente e depois unindo as solues.
2. f(n) = O(n2)
1. Um algoritmo de complexidade O(n2) dito ter complexidade
quadrtica, os quais ocorrem quando os itens de dados so processados
aos pares, sendo muitas vezes em um ninho dentro do outro. So teis para
resolver problemas de tamanhos pequenos.
3. f(n) = O(n3)
1. Um algoritmo de complexidade O(n3) dito ter complexidade
cbica. teis para resolver pequenos problemas.
4. f(n) = O(2n)
1. Um algoritmo de complexidade O(2n) dito ter complexidade
exponencial. No so teis do ponto de vista prtico.
5. f(n) = O(n!)
1. Um algoritmo de complexidade O(n!) dito ter complexidade
exponencial tambm, apesar de a complexidade fatorial O(n!) ter
30 unidade 1
comportamento muito pior que O(2n).
Segue a ordem de complexidade dos algoritmos.
2. O(1) < O(log n) < O(n) < O(n log n) <O(n2) <O(n3)<O(2n)
Um Algoritmo cuja complexidade O(cn), c>1 chamado de algoritmo
exponencial no tempo de execuo. O algoritmo cuja funo de complexidade
um polinmio, isto , O(p(n)) p(n) e chamado de algoritmo polinomial
em tempo de execuo. A diferena entre esses algoritmos cresce quando o
tamanho do problema a ser resolvido aumenta, conforme ilustra a Tabela 1.3.
RECORRNCIAS
Saiba Mais
O uso da notao O
iniciou vrias discusses Introduo
na comunidade de
anlise de algoritmos e
Quando um algoritmo contm uma chamada recursiva, o seu tempo
teoria da computao,
de execuo pode ser descrito por uma recorrncia. Uma recorrncia uma
como por exemplo, a
de que a igualdade equao ou uma inequao que descreve uma funo em termos de seu
f(n) = g(n) de mo valor em entrada menor. Para exemplificar, vamos apresentar a equao de
nica, ou seja, apenas recorrncia do Mergesort (Intercalao).
no sentido esquerdo
T(n)=
para direita, mesmo
adotando-se o fato de Cuja soluo T(n)=O(nlogn).
que a notao O defina Apresentaremos a seguir trs mtodos para resolver recorrncia, isto
um conjunto de funes. , para obter limites assintticos para a soluo.
Algoritmos Iterativos:
32 unidade 1
1. Algoritmo do fatorial
1 FAT 1
2 para i de 2 at n, faa:
3 FAT FAT * i
4 retorne FAT
1. Algoritmo de Fibonacci
1 Fib(1) Fib(2) 1
2 para i de 3 at n faa
3 Fib(1) Fib(i - 2) + Fib(i 1)
Algoritmos Recursivos
Algoritmos Recursivos:
Algoritmo Fatorial
funo Fat(n):
Se n = 0 ou n = 1, ento:
retorne (1)
Seno,
retorne(n * Fat(n - 1))
Algoritmo de Fibonacci
funo Fib(n):
Se n = 1 ou n = 2, ento:
Recorrncias
Solucionando Recorrncia
34 unidade 1
Solucionando Recorrncia:
1. T(1) = 21 = 2 verdade;
2. Hiptese de Induo:
I. Suponha que T(k) = 2k seja verdade;
3. Passo Indutivo:
Prova-se que T(k+1) = 2k+1
Pela definio temos T(k+1) = 2T((k+1)-1) = 2T(k) = 2 2k = 2k+1
Logo, est provada nossa conjectura.
4. Passo Indutivo:
Prova-se que T(k) = 3k2/2 + 7k/2 - 4
Temos T(k) = T(k-1) + 3k + 2 por definio
T(k) = [3(k-1)2/2 + 7(k-1)/2 - 4] + 3k + 2
T(k) = 3k2/2 + 7k/2 - 8/2
T(k) = (3k2 + 7k - 8)/2
Logo, est provada nossa conjectura.
Como a frmula est correta, prova-se que T(n) = O(n2).
Como determinar a complexidade de um algoritmo recursivo?
Exemplo: Algoritmo Mergesort
Tcnicas de Recorrncia
Mtodo da Substituio
36 unidade 1
constante c, pois T(1) c 1 log1 = 0. A sada para superar esta dificuldade
consiste em usar um valor n n0 sendo n0 uma constante qualquer maior
do que 1. Assim podemos impor T(2)= 4 e T(3)= 5, constantes e usar a
recorrncia a partir de T(4).
T(2) c 2 log2
42c
c 2, para todo n 2.
Como observamos, qualquer valor de c 2 suficiente para que os
casos bsicos de n=2 e n=3 sejam vlidos.
A grande dificuldade deste mtodo que no existe uma forma
geral para solucionar recorrncias corretamente. Pressupor soluo exige
experincia e criatividade na rea, entretanto existem algumas heursticas,
rvore de recurso, que veremos adiante, que podem ajudar a gerar boas
hipteses.
Se uma recorrncia for semelhante a uma que voc j tenha visto
antes, ento ser fcil supor uma soluo semelhante.
Exemplo: Considere a recorrncia.
T(n) = 2T( n/2 +35) + n, que semelhante recorrncia
vista anteriormente, exceto pelo termo 35. Este termo no pode afetar
substancialmente a soluo da recorrncia. Quando n grande, a diferena
entre T( n/2 ) e T( n/2 +35) no grande. Conclumos que T(n)=O(nlogn),
pode ser verificado usando o mtodo da substituio.
Exemplo: Resolver a recorrncia T(n) = 2T(n ) + logn
Parece difcil, porm tentaremos resolv-la mediante uma substituio
de variveis. Por convenincia vamos considerar que n inteira. Substituindo
m = logn obtemos T(2m) = 2T(2m/2) + m. Substituindo a recorrncia S(m)
= T(2 ), produzimos a recorrncia S(m) = 2S(m/2) + m, cuja soluo j
m
n/2h = 1 h = log n2
Total = h.n
38 unidade 1
T(n) = 4T(n - 2) + 2 + 1
T(n) = 4(2T(n - 3) + 1) + 2 + 1
T(n) = 23T(n - 3) + 4 + 2 + 1
--------------------
T(n) = 2i T(n-i) + 2i-1 + 2i-2 +...+ 21 + 20
O caso base alcanado quando i = n - 1
Logo, T(n) = 2n-1 + 2n-2 + 2n-3 +...+ 21 + 20
T(n) = 2n - 1 = O(2n)
Mtodo Mestre
Teorema Mestre
Exerccio 1
1. O que algoritmo?
2. Fornea um exemplo de aplicao que exija contedo algortmico no
nvel de aplicao e discuta a funo dos algoritmos envolvidos.
3. O que significa dizer que um algoritmo executa em tempo polinomial a n?
4. Comparao entre os tempos de execuo
Para cada funo f(n) e cada tempo t na tabela a seguir, determine o maior
tamanho n de um problema que pode ser resolvido no tempo t, supondo-se
que o algoritmo para resolver o problema demore f(n) microssegundos.
40 unidade 1
Exerccio 2
Exerccio III
42 unidade 1
Demonstre por induo que T(n)= n(n +1)/2.
2. Considere a equao de recorrncia a seguir, definindo T(n):
Resumindo
Esta unidade reservada para a anlise mais especfica de algoritmos, em especial, aos algoritmos
recursivos, bem como ao estudo dos mtodos de resoluo de recorrncia e a determinao de
suas complexidades.
ANLISE DE ALGORITMOS
Annimo
Introduo
Analisar Algoritmos
Complexidade de Algoritmos
48 unidade 2
6. Quando o programa possui procedimentos recursivos, para cada
procedimento associada uma funo de complexidade f(n)
e, em geral, a anlise desta funo envolve a soluo de uma
relao de recorrncia.
Complexidades de Atribuies
Complexidade de Sequncias
Essa estrutura tem a forma: S; T. A complexidade da sequncia a
soma das complexidades componentes.
Complexidades Condicionais
50 unidade 2
13. Para varivel inteira i:
Se i = 0 ento i i + 1;
Esta estrutura condicional envolve:
Determinar se o valor de i 0, sua complexidade O(1).
Caso afirmativo, executar a atribuio i i + 1 com complexidade
O(1).
Sua complexidade total tem ordem constante O(1).
1. Para lista v de inteiros e varivel inteira m;
Se m = 0 ento m Max(v);
Esta atribuio envolve (n comprimento da lista):
Determinar se o valor de m 0, com O(1).
Caso afirmativo, executar a atribuio m Max(v) com complexidade
O(n).
Sua complexidade no pior caso tem ordem O(n).
1. Estrutura Condicional Se b ento S seno T
Exemplo: Considere as estruturas condicionais a seguir:
2. Para variveis inteiras i e j
Se i j ento i i + j
seno j i + 1
Esta estrutura condicional envolve:
Determinar se os valores de i e j so diferentes com complexidade
O(1). Caso afirmativo, executar a atribuio i i + j com complexidade O(1).
Caso negativo, executar a atribuio j i + 1 com complexidade
O(1). Sua complexidade tem ordem constante O(1).
1. Para listas u e v (inteiros)
Se u = v, ento v Prim(u)
seno u Ordene (v)
Esta estrutura condicional envolve:
Determinar se as listas u e v so iguais com complexidade O(n). Caso
afirmativo, executar v Prim(u) com complexidade O(n) e (Prim(u) d como
sada a primeira metade da lista( n/2 ).
Caso negativo, executar u Ordene(v), usando um dos algoritmos
de ordenao com complexidade O(n2).
Sua complexidade total, no pior caso : O(n) +O(n) + O(n2)= O(n2).
52 unidade 2
Enquanto i 10 faa:
ii+1
Sua complexidade tem ordem constante 10.1, isto , O(10).
Inicializao de vetor A [1..n] de inteiros:
i0
Enquanto i n, faa:
i i + 1;
A[i] 0;
Sua complexidade tem ordem n . 1: O(n).
Atualizao de vetor A [1..n] de inteiros:
in
Enquanto i > 0 faa
A[i] A[i] + 1;
i i 1;
Sua complexidade tem ordem O(n).
OBS: Esses tipos de laos no so fceis de analisar como os laos
para.
Primeiro, o fator a regra de parada, o qual envolve varivel inteira e
uma constante e pode ser analisado semelhante o para.
Segundo, quando envolvem duas variveis inteiras, a anlise consiste
em expressar o comportamento como uma varivel nica a ser decrementada
Analisar um algoritmo prever o que o algoritmo ir precisar. s
vezes o hardware importante, mas o que acontece com frequncia medir
o tempo que ir demorar. O tempo de execuo de um algoritmo depende
geralmente do tamanho de sua entrada. Portanto, a anlise de algoritmo est
baseada no tamanho de sua entrada para compar-lo com outros algoritmos
e ter noo de quanto tempo ele vai demorar.
Exemplo: Analisar o seguinte algoritmo:
1. para i 1 at n faa
2. para 1 at i faa
3. imprima i x j x n
4. fim para
5. fim para
Para medir o custo do algoritmo, nossa anlise consistir em ver
quantas vezes cada passo executado. Mediremos o custo de cada linha
(cada passo a ser executado), sempre em funo de n. Vamos analisar o
algoritmo.
54 unidade 2
Fat 1;
enquanto i n, faa:
Fat Fat * i;
i i +1;
escreva Fat;
Exemplo: Verificar se um inteiro n primo
Primo verdade
i2
enquanto i * i n, faa:
Se n mod i = 0, ento:
primo falsidade
goto 44
seno:
i i +1;
44 fim
Exemplo: Considere o algoritmo para ordenar n elementos de um
conjunto A.
Para i de 1 at n-1, faa:
min i;
para j de i + 1 at n, faa:
Se A[j] < A[min], ento:
min j;
temp A[min];
A[min] A[i];
A[i] temp;
Exemplo: Algoritmos para avaliao de polinmios de grau n da forma:
Pn(x) = anxn + an-1xn-1 + ... +a1x + a
E so comparadas as suas complexidades.
Algoritmo 1
Ler (n, an,, an-1-,,..., a0,,x}
P a0
yx
para i de 1 at n-1, faa:
P P + ai * y;
yy + x;
P P + an * y;
Cada execuo de lao implica em dois produtos e uma soma, 3
56 unidade 2
A complexidade total ser a soma das complexidades da ordenao
com:
O(n log n) + O(log n) = O(n log n)
Pesquisa sequencial melhor.
Variante: H m elementos x a serem testados.
Dados no ordenados:
Pesquisa sequencial O(m n)
Ordenar + pesquisa binria
O(n log n) + O(m log n) = O((n+m) log n)
Hiptese: m n
Agora, a segunda alternativa a mais eficiente.
O(n log n), O(n2)
Exerccio
retorne k
58 unidade 2
3 xA[j]
4 ij 1
5 enquanto i > 0 e A[i] > x, faa:
6 A[i + 1] A[i]
7 ii 1
8 A[i + 1] x
Resumindo
Esta unidade dedicada a demonstrar as principais tcnicas para elaborao de algoritmos com
bons desempenhos e, de acordo com a natureza do problema, propiciar ao leitor decidir qual
estratgia utilizar diante de certas situaes especficas de resoluo. Exemplificaremos as tcnicas
com alguns dos principais algoritmos relacionados a cada estratgia.
INTRODUO
FORA BRUTA
DIVIDIR- E-CONQUISTAR
Introduo
Ordenao
64 unidade 3
Usando a tcnica dividir-e-conquistar, devemos dividir T em duas
partes iguais ou de tamanhos semelhantes, ordenar cada uma delas
recursivamente, e ento fazer um merge das solues respeitando a
ordenao. O algoritmo a seguir, de nome mergesort verifica o tamanho da
instncia a ser ordenada, caso ela tenha tamanho inferior a c, uma constante
determinada experimentalmente, o algoritmo ordena com o uso do algoritmo
de ordenao por insero; caso contrrio, o vetor a ser ordenado dividido em
duas partes iguais e o procedimento mergesort chamado recursivamente
com cada uma das metades U e V do vetor original T. O procedimento merge
invocado quando se dispe dos dois vetores ordenados U e V, gerando o
vetor final ordenado pela mesclagem(merge) de U e V.
Algoritmo Mergesort
1 proc mergesort(T[1..n])
2 incio
3 se n <= c ento ordenar_por_insero
4 seno
5 U[1.. n/2] T[1.. n/2]
6 V[1.. n/2] T[1+n/2 ... n]
7 mergesort(U)
8 mergesort(V)
9 merge(U,V,T)
10 fim
1 proc merge(U[1..m+1],V[1..n+1],T[1..m+n]
2 {U[m+1] e V[n+1] so usados como sentinelas}
3 i,j1
4 U[m+1],V[n+1]
5 para k 1 at m+n, faa:
6 se U[i] < V[j] ento: T[k] U[i]; i i+1
7 seno: T[k] V[j];j j+1
Exemplo:
Vetor a ser ordenado
Correo:
Pelo teorema de Jean Pierre basta olhar, esse algoritmo est correto,
ou seja, dado um vetor T no ordenado, ao final do algoritmo, teremos um
vetor T ordenado.
Mais formalmente, para instncia de tamanho menor ou igual a c, as
mesmas so ordenadas por um algoritmo j conhecido e correto.
Assumimos que o algoritmo ordena corretamente um vetor de tamanho
<=n. Para ordenar um vetor de tamanho n+1, tal vetor ser dividido em duas
instncias U,V de tamanho menor ou igual a n. O algoritmo merge recebe
dois vetores U e V ordenados e gera um vetor T ordenado. Por contradio,
assumindo que possvel haver um vetor T no ordenado, e supondo, sem
perda de generalidade, que os elementos t1, t2, tm+n na ordem de seleo do
merge, que corresponde sada.
Para o vetor no ser ordenado, deve haver algum elemento ti>tj, para
i<j. Pelo algoritmo merge impossvel, pois a condio de seleo impe que
seja o menor dentre os dois menores dos vetores U e V.
Complexidade:
66 unidade 3
Neste caso aplicado o caso 2 do mtodo mestre.
Ento, T(n) (n.logn)
O mergesort superior ao algoritmo de ordenao por insero
que lhe serve de base e considerado algoritmo timo juntamente com o
heapsort. No entanto, o mergesort gasta muita memria intermediria,
enquanto o heapsort usa apenas o vetor original.
Outra questo interessante relativa diviso do vetor. Ser que faz
alguma diferena dividir ao meio ou dividir em outras propores? Supondo
que o algoritmo seja como abaixo:
1 proc mergesort2(T[1..n])
2 incio
3 se n <= c, ento: ordenar_por_insero
Desafio:
4 seno:
Projete um algoritmo
5 U[1.. n-1] T[1..n-1] utilizando a tcnica
6 V[1] T[n] dividir-e-conquistar para
7 mergesort(U) encontrar o menor e o
maior elemento entre
8 mergesort(V)
n nmeros usando
9 merge(U,V,T) no mais que 3n/2
10 fim comparaes.
Qual a complexidade do algoritmo mergesort2?
T(n) = T(n-1)+T(1)+n, o que corresponde claramente a (n2).
Quicksort
n/2 n/2
68 unidade 3
8 y v div 10s ; z v mod 10s
9 retornar mult (w,y) 102s + (mult(w,z) + mult(x,y)) 10s + mult (x,z)
70 unidade 3
2. Definir recursivamente o valor de uma soluo tima;
3. Clculo do valor de uma soluo tima;
4. Construo de uma soluo tima a partir da informao
computada.
Os passos de 1 a 3 formam a base de uma soluo por programao
dinmica para um problema. O passo 4 necessrio quando necessitamos
informao adicional para facilitar a computao do passo 3.
e que
72 unidade 3
Logo, uma soluo tima para uma instncia do problema contm
solues timas para as subinstncias do mesmo problema, o que permite o
emprego da programao dinmica.
74 unidade 3
ponderadas e com pesos no negativos. Queremos
agora resolver um problema amplo que determine a
distncia mnima e o respectivo caminho mnimo para
grafos orientados com arestas ponderadas, sendo
permitido o uso de arestas negativas.
Sobre o uso de arestas negativas, queremos
alertar desde j que a existncia de ciclos negativos
representa um erro e modelagem de problemas, pois
leva a uma soluo ilimitada, ou seja, sempre ser
possvel reduzir o custo em tal ciclo. A figura, a seguir,
ilustra um fragmento de grafo contendo um ciclo
negativo.
Primeira preocupao tratar o que tem de bom no algoritmo de
Dijkstra, ou seja, armazenar a distncia do caminho mnimo especial do
n u ao n v. De que forma pode armazenar esse valor, observando que
desejamos determinar a distncia de todo n u para todo n v ?
A resposta simples. Basta usar uma matriz bidimensional para
Saiba Mais
armazenar as distncias e supor que os ns do grafo so representados por
A tcnica de
nmeros inteiros. programao dinmica
Para formular o problema como problema de programao dinmica, foi desenvolvida
vamos imaginar o que acontece quando voc joga uma pedra em um lago, pela comunidade de
pesquisa operacional e
forma-se uma onda circular que vai aumentando de raio at atingir uma
formalizada por Richard
distncia suficientemente grande. No nosso problema, vamos aplicar o Bellman. A soluo para
conceito da onda procurando primeiro um caminho de um n u para um n v o produto de matrizes
usando apenas uma aresta, depois procurar caminhos que possam melhorar encadeadas descritas
atribuda a Godbole. O
os existentes usando 2 arestas, e assim por diante, at n-1 arestas.
mtodo assintoticamente
mais rpido atribudo a
O algoritmo proposto poderia ser: Hu e Shing.
1. caminho_geral(G:matriz[1..n,1...n]):matriz[1..n,1...n];
2. Dist:matriz[1..n,1...n];
3. Dist<-G;
4. para k<-2 at n-1 faa:
5. para i<-1 at n-k, faa:
6. j<- i + k
7. Dist[i,j]<- Min{Dist[i,j],
O Problema do Troco
76 unidade 3
O algoritmo guloso porque em cada passo escolhe a maior moeda
que pode e uma vez escolhida uma moeda, ela no ser trocada.
Caractersticas Gerais
Conjunto Soluo
Soluo vlida
Funo viabilidade
Funo seleo
78 unidade 3
3. A funo viabilidade verifica se o conjunto soluo uma rvore.
4. A funo de seleo varia com o algoritmo.
5. A funo objetivo minimizar o comprimento total das arestas na
soluo.
Algoritmo de Kruskal
Exemplo:
Ordenando as arestas:
{1,2}, {2,3}, {4,5}, {6,7}, {1,4}, {2,5}, {4,7}, {3,5}, {2,4}, {3,6}, {5,7} e
{5,6}
80 unidade 3
1. Ordenao das arestas = O(m log m) = O(m log n), pois n-1 m
n(n-1)/2
2. Inicializao dos n conjuntos disjuntos - O(n) so executados no
mximo 2m achar, cada um pode gastar at log n operaes so executados
n-1 juntar, cada um podendo gastar at log n operaes.
3. As demais operaes exigem no mximo O(m).
Conclumos que o algoritmo O(mlog m) ou O(mlog n).
Exemplo:
82 unidade 3
fonte s, ento o algoritmo termina determinando o caminho mnimo entre o
vrtice s e todos os demais vrtices do grafo.
Prova:
Chamaremos dist [u] a distncia relaxada do vrtice u ao vrtice s(ao
longo do algoritmo) e (s,u) a distncia mnima do vrtice s para o vrtice u.
Provaremos por induo matemtica que:
1. dist(u) = (s,u), u V, a partir de quando o vrtice u inserido
no conjunto S.
2. Se um n u S, ento dist[u] d o comprimento do menor caminho
especial de s para u.
1. Base: inicialmente, somente o n fonte s est em S, assim que a
condio a) verdadeira.
2. Hiptese de Induo:
Supondo que as condies a) e b) so verdadeiras antes de
adicionarmos um n u ao conjunto S
3. Passo indutivo para a)
Para cada n pertencente a S, antes da adio do n u, no h
alterao pelo algoritmo, assim a condio a) permanece verdadeira. Ao
adicionarmos o n u ao conjunto S devemos garantir que dist(u)= (s,u). Se o
p1
caminho encontrado pelo algoritmo s x u, onde x S.
Supondo que haja outro caminho alternativo, s y z u , tal que y
o nico n de p1 que no pertence a S e z S e predecessor e u. A distncia
total por y vale (s,y)+ (y,u) dist(y) + (y,u) dist(u), o que nos leva a
concluir que dist[y] < dist[u], no momento da seleo de u pelo algoritmo, o
que uma contradio, pois se isso fosse verdade, o algoritmo selecionaria
y antes de u. Assim, quando u adicionado a S, a induo permanece
verdadeira.
4. Passo indutivo para b):
Considere um n w S diferente de u. Quando u adicionado a S,
h duas possibilidades para o caminho mnimo especial de s para v. O valor
dist[w] no troca, ou o caminho de s para w passa por u (e possivelmente por
outros nos de S). No segundo caso, sendo x o ltimo n de S antes de atingir
w(pois o algoritmo sempre atualiza dist em relao a um n inserido em S), o
valor Dist[w]=Dist[x]+L(x,w) para todo n x em S(incluindo u). No entanto, para
todo n x em S, exceto u, esta comparao foi feita quando x foi adicionado
a S e Dist[x] no mudou, desde ento. Ento, o novo valor de Dist[w]=
Dist[u]+L(u,w) deve ser comparado com o valor antigo Dist[w]=Dist[x]+L(x,w).
Anlise do algoritmo:
Problema da Mochila
84 unidade 3
Problema de Programao Matemtica (P.P.M.)
n
Minx0 xi vi funo objetivo valor transportado
i 1
Sujeito a
n
,
x v i i W , xi {0,1} - restrio referente capacidade da mochila
i 1
n
vi
x0 xi
i 1 wi
' q q
x0 x0 vi vj
wi wj
v v v v
q i j 0 j i
w w w j wi
i j
86 unidade 3
resolver um subproblema tal que se combinarmos a resposta tima deste
subproblema com o(s) elemento(s) da escolha gulosa, chega-se soluo
tima do problema original. Esta a parte que requer mais engenhosidade.
4. Normalmente, a prova comea com uma soluo tima genrica e
mostram que ela pode ser modificada possivelmente apos vrios passos at
que ela inclua o(s) elemento(s) identificado(s) pela escolha gulosa.
Cdigo de Huffman
88 unidade 3
BT = f (c)d T (c)
cC
90 unidade 3
4 para i 1 at n -1 faa
5 aloque um novo n z
6 esq[z] x EXTRACT-MIN(Q)
7 dir[z] y EXTRACT-MIN(Q)
8 f[z] f[x] + f[y]
9 insert(Q,z)
10 retorne EXTRACT-MIN(Q) # retorna a raiz da rvore
Passo 1
Passo 2
Passo 3
Passo 5
92 unidade 3
Passo 6 a rvore final
Exerccio 1
94 unidade 3
campos elevao (que corresponde altura do ponto mdio do terreno
representado pela clula) e tipo de terreno. O tipo de terreno pode ser
1=limpo, 2=vegetao, 3=floresta, 4=urbano, 5=estrada. As coordenadas
dos pontos P1 e P2 so em metros. Desenvolver um algoritmo para
determinar se h uma linha de visada direta entre os mesmos sem
obstculos. So considerados obstculos a existncia de rea urbana,
vegetao ou floresta por um trecho superior a 20 metros ou o terreno Ter
altura superior altura da linha de visada.
9. Seja um conjunto de n garrafas distintas e n correspondentes rolhas
(existe uma correspondncia de um-pra-um entre garrafas e rolhas). No
permitido comparar duas garrafas ou duas rolhas diretamente, mas
permitido comparar uma garrafa e uma rolha para saber quem maior das
duas. Escreva um algoritmo para encontrar o casamento entre garrafas e
rolhas. esperado que, no caso mdio, a complexidade de seu algoritmo
seja O(n.log n).
10. Considere uma lista com n nmeros distintos x1, x2, ..., xn, em ordem
arbitrria, e um valor k < n. Escreva em pseudocdigo, um algoritmo que
imprima os k menores valores da lista, em qualquer ordem. Por exemplo,
se k = 3, deve ser impresso os 3 menores valores de x1, x2, ..., xn. O
algoritmo deve resolver o problema em O(n), independente do tamanho
de k.
11. Considere um array A, contendo n nmeros distintos. Esse array tem a
seguinte propriedade: existe um ndice m de modo que os nmeros do
subarray A[1..m] esto em ordem crescente e os nmeros do subarray
A[m+1..n] esto em ordem decrescente. Escreva (em pseudocdigo) um
algoritmo O(log n) que retorna o ndice m. Por exemplo, se o array de
entrada A[1..9] = [3; 7; 8; 9; 6; 5; 4; 2; 1], a sada deve ser m = 4.
Argumente que o seu algoritmo est correto.
12. Implementar em linguagem C o algoritmo para produto de nmeros
grandes de forma tal que receba os nmero de tamanho varivel e retorne
o produto correto. A implementao deve tornar o algoritmo eficiente para
a soluo computacional.
Exerccio 2
96 unidade 3
7. Uma cadeia de 3 lanchonetes comprou 8 lates de leite, cada um ao
preo de $ 20,00. Cada lato pode ser vendido ao preo de $ 40,00.
O fornecedor se compromete a recomprar cada lato no vendido ao
fim do dia, pagando $ 10,00 por lato. Constatou-se historicamente a
probabilidade de demanda em cada uma das lanchonetes, formando-se
a tabela abaixo.
Qual deve ser a alocao de lates de forma a maximizar o lucro esperado?
Sugesto: Construa uma tabela com o lucro esperado para cada
quantidade de lates e para cada lanchonete.
Exerccio 3
98 unidade 3
inicial e um tempo final. Projetar um algoritmo guloso para resolver este
problema.
5. Considerando o problema de selos de postagem, argumente que o seu
algoritmo est correto e efetue a anlise de complexidade de sua soluo.
a) Mostre que qualquer postagem de valor inteiro maior do que 7 centavos
pode ser formada, utilizando apenas selos de 3 e 5 centavos.
b) Escreva um algoritmo que dado um valor da postagem retorna o nmero
de selos de 3 e 5 centavos, respectivamente.
c) Mostre que o algoritmo est correto.
d) Indique a complexidade do algoritmo.
6. Considere o seguinte problema de coleta de cupons. Existe uma certa
quantidade de diferentes tipos de caixa de biscoito. Em cada caixa de
biscoito encontramos um cupom que d um desconto na compra de uma
outra caixa de biscoito (no necessariamente do mesmo tipo). possvel
utilizar mltiplos cupons para comprar uma nova de caixa de biscoito at
o valor de obt-la grtis. No possvel receber dinheiro de volta, mesmo
se sobra cupom. necessrio comprar uma caixa de cada tipo de biscoito,
gastando o menor valor possvel. Descreva um algoritmo eficiente, que
recebe como entrada, para cada tipo de biscoito, seu preo, o valor do
cupom e a marca contemplada no cupom e retorna a ordem tima de
compra das caixas de biscoito.
100 unidade 3
UNIDADE 4
Classes de problemas
Resumindo
Com esta unidade finalizaremos o nosso estudo de Projeto de Algoritmos e sua anlise classificando
os problemas de acordo com a sua natureza e complexidade. Visamos apenas oferecer ao leitor uma
viso geral dos problemas, enfatizando os de ordem polinominal e os problemas no determinstico
polinominalmente (NP).
Introduo
Solucionabilidade de Problemas
Problemas Tratveis
104 unidade 4
uma mochila, sabendo que ela tem um limite de peso para carregar itens de
valor, dentre muitos itens existentes de valor conhecido, etc.
Formas de Problemas
Problemas de Deciso
Problemas de Otimizao
106 unidade 4
resolvidos em tempo polinomial em um modelo computacional pode ser
resolvido em tempo polinomial em outro modelo.
Definio - Classe P
Classe NP
Algoritmos de Verificao
Definio da Classe NP
108 unidade 4
a NP se e somente se existe um algoritmo A que verifique um certificado em
tempo polinomial.
Ento, podemos concluir que o Problema do Ciclo Hamiltoniano
pertence a NP.
Relao entre P e NP
A classe Co-NP
Reduo Linear
A Classe NP-Completo
110 unidade 4
quais h provas formais da dificuldade intrnseca em resolv-los. Todos os
problemas desta classe so problemas reconhecidamente intratveis, mas se
for desenvolvido algum algoritmo polinomial para qualquer um dos problemas
desta classe, todos os outros problemas da classe estaro resolvidos em
tempo polinomial, conforme veremos ao longo desta Unidade, no so
poucos os problemas reconhecidamente intratveis.
J vimos o questionamento quanto incluso das classes P e NP.
Intuitivamente, descobrir uma prova mais difcil do que verific-la. Esta
intuio pode conduzir conjectura de que P NP o que at hoje no
foi possvel verificar. Por outro lado, h diversos problemas da classe NP
que com certeza no esto em P e que so muito difceis de resolver. Tais
problemas foram agrupados na classe NP-Completo, definida a seguir.
Definio: Um problema de deciso X NP-completo se,
i) X NP, e
ii) Y pt X, para todo problema Y NP.
Pela definio, um problema Y para pertencer classe NP-completo,
primeiro deve pertencer classe NP e em segundo, todos os problemas da
classe NP devem ser redutveis a ele.
Usando a definio acima, caso tenhamos um problema X NP-
completo e um problema Z da classe NP, se X pt Z, o que pode-se afirmar ?
Pode-se afirmar que Z to difcil quanto X ou pior.
Ser que Z pertence a NP-completo ?
Teorema: Seja X um problema NP-Completo. Considerar um problema
de deciso Z pertencente a NP tal que X pt Z. Ento, Z tambm pertence a
NP-completo.
Prova:
Para z ser NP-Completo deve satisfazer as duas condies da
definio imediatamente anterior. Primeiro Z NP, o que uma hiptese do
teorema; a segunda condio considera um Y arbitrrio em NP. Como X
NP-Completo e Y NP, segue que Y pt X. Pela hiptese X pt Z.
Agora, dado um novo problema Z, como provar que ele pertence
a NP-Completo? Aplicando a definio de NP-Completo, primeiro deve-se
provar que Z pertence a NP, conforme a definio anterior. A seguir, deve-se
provar que todos os problemas da classe NP so redutveis a Z. Como provar
isto?
Algumas Redues
Conjuntos Independentes
112 unidade 4
literais complementares.
Considerando uma expresso E com m clusulas, E satisfazvel se
e somente se G tem um conjunto independente de tamanho m.
Exemplo de Reduo:
( x 1 x 2 x 3 ) ( x1 x 2 x 4 ) ( x 2 x 3 x 5 ) ( x 3 x 4 x 5 )
A Classe NP-Difcil
Backtracking e branch-and-bound
Backtracking
114 unidade 4
O algoritmo backtracking percorre os possveis caminhos de procura
para localizar solues ou pequenas sadas. A configurao no final de um
caminho consiste em um par (x,y), onde x o subproblema que ainda deve ser
resolvido e y o conjunto de escolhas feitas para chegar a esse subproblema
a partir do problema original. Inicialmente, fornecemos ao algoritmo de
backtracking o par(x,0), onde x o problema original. Se o algoritmo descobrir
em algum momento que uma configurao (x,y) no conduz a uma soluo
vlida, no importando quantas escolhas adicionais sejam feitas, ento ele
evita todas as procuras a partir dessa configurao e retorna outra.
1. Algoritmo Backtrack(x):
2. Entrada: uma instncia x de um problema difcil
3. Sada: uma soluo para x ou sem soluo se nenhuma existir
4. F{(x,0)} {F o conjunto de fronteira de configuraes de
subproblemas}
5. enquanto F 0 faa
6. retire de F a configurao (x,y) mais promissora
7. expanda (x,y) fazendo um pequeno conjunto de escolhas
adicionais
8. sejam (x1,y1),(x2,y2),...,(xk,yk) o conjunto de novas configuraes
9. para cada nova configurao (xi,yi), faa:
10. verifique a consistncia de (xi,yi)
11. se a verificao retornar soluo encontrada, ento:
12. retorne a soluo derivada de (xi,yi)
13. se a verificao retornar sem sada, ento:
14. descarte a configurao (xi,yi) {Backtrack}
15. seno
16. F F {(xi,yi)} {(xi,yi) inicia uma procura mais promissora}
17. retorne sem soluo
Exemplos de Problemas:
Problema do Labirinto
116 unidade 4
rvore com possibilidades e alvo:
Branch-and-bound
1. Algoritmo Branch-and-Bound(x):
2. Entrada: uma instncia x de um problema difcil de otimizao
(minimizao)
3. Sada: uma soluo tima para x ou sem soluo se nenhuma
existir
4. F{(x,0)} { conjunto de fronteira de configuraes}
5. b{(+,0)} {custo e configurao da melhor soluo conhecida}
6. enquanto F0, faa:
7. retire de F a configurao (x,y) mais promissora
8. expanda (x,y) obtendo um conjunto (x1,y1),..., (xk,yk) de
configuraes adicionais
9. para cada nova configurao (xi,yi), faa:
10. verifique a consistncia de (xi,yi)
11. se a verificao retornar soluo encontrada, ento:
12. se o custo c da soluo para (xi,Yi) for melhor que b, ento:
13. b<- (c, (xi,yi))
14. seno,
15. descarte a configurao (xi,yi)
16. se a verificao retornar sem sada, ento:
17. descarte a configurao (xi,yi) {Backtrack}
18. seno,
19. se min b(xi,yi) o menor custo de b, ento:
20. F F {(xi,yi)} {(xi,yi) inicia um novo caminho promissor}
118 unidade 4
21. seno,
22. descarte a configurao (xi,yi) {o valor alto demais e j no
interessa}
23. retorne b
Exerccio 1
120 unidade 4
AZEREDO, Paulo A. Mtodos de classificao de dados e anlise de suas
complexidades. Rio de Janeiro: Campus, 1996.
.
BALAKRISHNAN, J. & RANGANATHAN, K. A Textbook of Graph Theory.,
Ed. Springer-Verlag,1999.
WEB BIBLIOGRAFIA
Graphviz - http://www.graphviz.org/
CV. http://lattes.cnpq.br/9112511053307536
Possui graduao em Licenciatura Plena em Matemtica pela
Universidade Federal do Piau UFPI (1976) e Mestrado em Sistemas e
Computao pela Universidade Federal da Paraba (Campina Grande, 1980).
Foi Professor do Departamento de Informtica da Universidade Federal da
Paraba-Joo Pessoa (1979 a 1989) e do Departamento de Informtica e
Estatstica da Universidade Federal do Piau UFPI (1989 a 2004). Atualmente,
est aposentado pela Universidade Federal, mas continua exercendo
atividade docente no curso de Cincia da Computao do Centro de Ensino
Unificado de Teresina - CEUT e sendo coordenador do Curso de Sistemas de
Informao da Faculdade das Atividades Empresariais de Teresina FAETE.
CV. http://lattes.cnpq.br/0683740460851435
Possui graduao em Licenciatura Plena em Matemtica pela
Universidade Estadual do Piau-UESPI (2001), Bacharelado em Cincia da
Computao pela Universidade Federal do Piau UFPI (2003). Especialista em
Matemtica e Estatstica e Especialista em Administrao e m Redes Linux
pela Universidade Federal de Lavras-MG (2005). Foi Professor substituto
do Departamento de Matemtica-DM e do Departamento de Informtica e
Estatstica DIE, da Universidade Federal do Piau - UFPI. Tem experincia
na rea de Cincia da Computao com nfase em Sistemas de Computao.
Seus principais interesses de pesquisa e atuao incluem Software Livre,
lgebra Computacional, Segurana e Criptografia, Anlise de Desempenho,
Processamento Paralelo, Sistemas Distribudos e Computao baseada em
Clusters e em Grades (Grid Computing).