Projeto e Análise de Algoritmos

Universidade Federal do Piau
Centro de Educao Aberta e a Distncia

Francisco Jos de Arajo
Jos Messias Alves da Silva
PROJETO E ANLISE DE
ALGORITMOS
Projeto e Anlise de
Algoritmos
Ministrio da Educao - MEC
Universidade Aberta do Brasil - UAB
Universidade Federal do Piau - UFPI
Universidade Aberta do Piau - UAPI
Centro de Educao Aberta e a Distncia - CEAD
Zilda Vieira Chaves
Roberto Denes Quaresma Rgo
Samuel Falco Silva
Antonio F. de Carvalho Filho
Djane Lemos Ferreira Gabriel
Gesiel dos Santos Sobrinho
PRESIDENTE DA REPBLICA
MINISTRO DA EDUCAO
GOVERNADOR DO ESTADO
REITOR DA UNIVERSIDADE FEDERAL DO PIAU
SECRETRIO DE EDUCAO A DISTNCIA DO MEC
PRESIDENTE DA CAPES
COORDENADOR GERAL DA UNIVERSIDADE ABERTA DO BRASIL
DIRETOR DO CENTRO DE EDUCAO ABERTA E A DISTNCIA DA UFPI
Dilma Vana Roussef Linhares
Aloisio Mercadante
Wilson Nunes Martns
Jos Arimatia Dantas Lopes
Carlos Eduardo Bielshowsky
Jorge Almeida Guimares
Joo Carlos Teatni de S. Clmaco
Gildsio Guedes Fernandes
ADMINISTRAO
ADMINISTRAO PBLICA
CINCIAS BIOLGICAS
FILOSOFIA
FSICA
LETRAS PORTUGUS
LETRAS INGLS
MATEMTICA
PEDAGOGIA
QUMICA
SISTEMAS DE INFORMAO
Antonella Maria das Chagas Sousa
Fabiana Rodrigues de Almeida Castro
Maria da Conceio Prado de Oliveira
Zoraida Maria Lopes Feitosa
Miguel Arcanjo Costa
Jos Vanderlei Carneiro
Lvia Fernanda Nery da Silva
Joo Bencio de Melo Neto
Vera Lcia Costa Oliveira
Milton Batsta da Silva
Leonardo Ramon Nunes de Sousa
TCNICA EM ASSUNTOS EDUCACIONAIS
EDIO
PROJETO GRFICO
DIAGRAMAO
REVISO ORTOGRFICA
REVISO GRFICA
Prof. Dr. Ricardo Alaggio Ribeiro ( Presidente )
Des. Tomaz Gomes Campelo
Prof. Dr. Jos Renato de Arajo Sousa
Prof. Dr. Teresinha de Jesus Mesquita Queiroz
Prof. Francisca Maria Soares Mendes
Prof. Iracildes Maria de Moura F Lima
Prof. Dr. Joo Renr Ferreira de Carvalho
EQUIPE DE DESENVOLVIMENTO CONSELHO EDITORIAL DA EDUFPI
2013. Universidade Federal do Piau - UFPI. Todos os direitos reservados.
A responsabilidade pelo texto e imagens desta obra do autor. O contedo desta obra foi licenciado, temporria e
gratuitamente, para utlizao no mbito do Sistema Universidade Aberta do Brasil, atravs da UFPI. O leitor se compromete
a utlizar o contedo desta obra para aprendizado pessoal, sendo que a reproduo e distribuio fcaro limitadas ao mbito
interno dos cursos. A citao desta obra em trabalhos acadmicos e/ou profssionais poder ser feita, com indicao da fonte.
A cpia desta obra sem autorizao expressa, ou com intuito de lucro, consttui crime contra a propriedade intelectual, com
sanes previstas no Cdigo Penal.
proibida a venda deste material.
A663p Arajo, Francisco Jos de.
Projetos e anlise de algoritimos / Francisco Jos de Arajo.
Teresina : EDUFPI/CEAD, 2013.
128p.
1. Algoritimos. 2. Algoritimos - Anlise. 3. Educao a
Distncia. I. Ttulo.
CDD 005.1
Ao desenvolver um sistema computacional, no podemos deixar
de levar em considerao todos os aspectos que infuem 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 efcientemente 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 bibliografa e a web
bibliografa ao fm das notas so sufcientes 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
defnies 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 fm, na Unidade IV apresentada uma classifcao dos principais
problemas computacionais em estudo e as suas ordens de complexidade,
enfocando a natureza de sua resoluo.
UNIDADE 1
FUNDAMENTOS DE ANLISE DE ALGORITMOS
Fundamentos de algoritmos ....................................................... 11
Conceitos bsicos ........................................................................ 18
Recorrncias ................................................................................ 32
UNIDADE 2
TCNICAS DE ANLISE DE ALGORITMOS
Anlise de algoritmos .................................................................. 47
Complexidade de algoritmos ....................................................... 48
UNIDADE 3
TCNICAS DE PROJETO DE ALGORITMOS
Introduo ................................................................................... 63
Fora bruta .................................................................................. 63
Dividir- e-conquistar .................................................................... 64
Programao dinmica ................................................................ 70
Algoritmos gulosos ...................................................................... 76
11
35
35
UNIDADE 4
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
35
UNIDADE 1
Fundamentos de Anlise de
Algoritmo
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.
Resumindo
PROJETO E ANLISE DE ALGORITMOS 11
FUNDAMENTOS DE ANLISE DE
ALGORITMO
FUNDAMENTOS DE ALGORITMOS
Ao verifcar que um dado programa est muito lento, uma pessoa
prtica pede uma mquina mais rpida ao seu chefe, mas o
ganho potencial que uma mquina mais rpida pode proporcionar
tipicamente limitado por um fator de 10 por razes tcnicas
ou econmicas. Para obter um ganho maior, preciso buscar
melhores algoritmos. Um bom algoritmo, mesmo rodando em uma
mquina lenta,sempre acaba derrotando (para instncias grandes
do problema) um algoritmo pior rodando em uma mquina rpida.
Sempre.
- S. S. Skiena, The Algorithm Design Manual
Introduo
Neste captulo, apresentaremos alguns fundamentos de algoritmos
e algumas ideias iniciais sobre funo de complexidade, efcincia de
algoritmos, etapas para o desenvolvimento de algoritmos efcientes, medida
de complexidade e anlise emprica.
Algoritmo
O que um Algoritmo?
Defnies:
Segundo o dicionrio de Aurlio, algoritmo sob o ponto de vista da
matemtica processo de clculo ou de resoluo de um grupo de problemas
UNIDADE 1 12
semelhantes em que se manipulam, com generalidade e sem restries,
regras formais para a obteno do resultado ou da soluo do problema.
Um algoritmo uma sequncia de instrues no ambguas para
resolver um problema, isto , para obter uma sada desejada para qualquer
entrada legtima em um intervalo de tempo fnito.
Um algoritmo qualquer procedimento computacional que recebe
como entrada um valor ou um conjunto de valores e produz como sada um
valor ou um conjunto de valores.
Podemos concluir que um algoritmo uma sequncia de passos
computacionais que transformam a entrada em sada.
Exemplo: Considere a seguinte funo:
F(x)= x
3
/5
A sua entrada o x e a sua sada e o y ou f(x), o valor que a funo
retorna. O algoritmo seria o seguinte:
1. Entrada: receber o valor de x.
2. Elevar x ao cbico e guardar o nmero resultante como z.
3. Dividir z por 5 e guardar o nmero resultante como y.
4. Sada: imprimir o valor de y.
O algoritmo, portanto, a lgica do nosso problema matemtico
ou informtico. a sequncia de passos que eu fao na minha cabea (ou
no papel) antes de escrever para uma das linguagens. Se formos pensar,
veremos que tudo o que fazemos um algoritmo, um procedimento que
recebe uma entrada e envia uma sada, no s no computador, mas na vida.
Exemplo: Encontrar o maior e o menor valor de um vetor com n
valores. Formalmente, o problema poderia ser colocado da seguinte forma:
Entrada: uma sequncia de n nmeros < a
1
, a
2
, a
3
,...,a
n
>
Sada: os valores Min e Max, o menor e o maior valor, respectivamente,
dentre os valores da entrada.
Podem existir vrios algoritmos diferentes para resolver o mesmo
problema. Nos casos acima, poderamos ter um algoritmo que fzesse a
mesma coisa de maneira diferente.
Os algoritmos descritos neste trabalho sero escritos em uma
linguagem de pseudocdigo, por est mais prximo da linguagem natural.
Por que estudar algoritmos?
Devemos conhecer um conjunto de algoritmos de diferentes
reas, alm de sermos capazes de projetar novos algoritmos e analisar
suas efcincias. O estudo de algoritmos , reconhecidamente, a pedra
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
Instncia de um problema consiste de todas as entradas necessrias
para se calcular uma soluo para o problema. Uma instncia de um problema
computacional um possvel valor para a entrada.
Alguns exemplos de problemas e suas instncias:
Os nmeros 25, -30 e 10 defnem uma instncia do problema da
equao do segundo grau. A instncia consiste em encontrar um nmero
inteiro x tal que 25x
2
-30x +10=0.
< 42, 6, 11,17, 4> uma instncia para o problema da ordenao.
Um algoritmo dito correto se, para cada instncia de entrada, ele
para com a sada correta.
Que tipos de Problemas so resolvidos com algoritmos?
A ordenao no o nico problema computacional para o qual foram
desenvolvidos algoritmos.
Algumas aplicaes prticas de algoritmos. Segundo Cormen (2002):
1. O Projeto Genoma Humano: tem como objetivo identifcar todos os
100.000 genes do DNA humano, determinar as sequencias dos 3 bilhes
de pares de bases qumicas que constituem o DNA humano, armazenar
essas informaes em bancos de dados e desenvolver ferramentas para
anlise de dados. Cada uma dessas etapas exige Algoritmos sofsticados.
2. A Internet: permite que pessoas de todo mundo acessem e obtenham com
rapidez grandes quantidades de informaes. Para isso, so empregados
Algoritmos inteligentes com a fnalidade de gerenciar e manipular esse
grande volume de dados.
3. O Comrcio Eletrnico: permite que mercadorias e servios sejam
negociados e trocados eletronicamente. Possui a capacidade de manter
privadas as informaes, como nmeros de cartes de crdito, senhas
e extratos bancrios. As tecnologias usadas so a criptografa e as
ATENO!!
Nem todos os problemas
podem ser resolvidos
por algoritmos. Exemplo.
Como se tornar rico e
famoso?
UNIDADE 1 14
assinaturas digitais e so baseadas em Algoritmos numricos e teoria
dos nmeros.
4. Na indstria: alocar recursos escassos de maneira mais efciente. Localizar
poos, designar as tripulaes para os vos, instalar um provedor de
servios da Internet, etc. Esses exemplos podem ser resolvidos com o
uso da programao linear.
Alguns exemplos de problemas concretos:
1. Mapa rodovirio no qual a distncia entre cada par de pontos marcado,
tendo como objetivo determinar a menor rota de um ponto a outro do
nmero de rotas;
2. Determinao do produto de n matrizes A
1
, A
2
, ... ,A
n
. Como a multiplicao
de matrizes associativa, existem vrias ordens de multiplicao;
3. Temos n pontos no plano e desejamos encontrar a envoltria convexa
desses pontos, ou seja, um polgono convexo que contm os pontos.
Essas listas esto longe de esgotar os exemplos, mas exibem duas
caractersticas comuns a muitos algoritmos interessantes:
1. Existem muitas solues candidatas, porm a maioria no aquilo que
desejamos. Encontrar a soluo que queremos pode representar um
desafo.
2. Existem aplicaes prticas. Dos problemas anteriores, o caminho mais
curto fornece os exemplos mais fceis. Uma empresa de transportes que
utiliza caminhes tem interesse fnanceiro em encontrar os caminhos mais
curtos em uma rede ferroviria ou rodoviria porque menores caminhos
resultam em menor trabalho e menor consumo de combustvel.
Complexidade e custo de um algoritmo
Determinando o menor custo possvel para resolver problemas de
uma dada classe, temos a medida de difculdade inerente para resolver o
problema. Quando o custo de um algoritmo igual ao menor custo possvel,
o algoritmo timo para a medida de custo considerada. Podem existir vrios
algoritmos para resolver o mesmo problema.
Medida do custo para execuo do programa
Em muitas situaes podem existir vrios algoritmos para resolver o
mesmo problema, sendo necessrio escolher o melhor. Se a mesma medida
de custo aplicada a diferentes algoritmos, ento possvel compar-los e
escolher o mais adequado para resolver o problema em questo.
O custo de utilizao de um algoritmo pode ser medido de vrias
maneiras. Uma delas mediante a execuo do programa em um computador,
sendo o tempo de execuo medido diretamente. As medidas de tempo obtidas
so bastante inadequadas e os resultados jamais devem ser generalizados:
os resultados so dependentes do compilador que podem favorecer algumas
construes em detrimento de outras; os resultados dependem de hardware;
quando grandes quantidades de memria so utilizadas, as medidas de
tempo dependem deste aspecto.
Uma maneira mais adequada de medir o custo de utilizao de um
algoritmo por meio do uso de um modelo matemtico baseado em um
computador idealizado. Devendo especifcar o conjunto de operaes e seus
custos de execues, mais usual ignorar o custo de algumas das operaes
e considerar apenas as operaes mais signifcativas.
Funo de Complexidade
Para medir o custo de execuo de um algoritmo, comum defnir
uma funo de custo ou funo de complexidade f. A funo f(n) a medida
do tempo necessrio para executar um algoritmo para um problema de
tamanho n.
Existem dois tipos de funes de complexidade a saber: a funo de
complexidade de tempo, onde f(n) mede o tempo necessrio para executar
um algoritmo em um problema de tamanho n e a funo de complexidade de
espao, onde f(n) mede a memria necessria para executar um algoritmo
em um problema de tamanho n.
Utilizaremos f para denotar uma funo de complexidade de tempo
daqui para frente. A complexidade de tempo na realidade no representa
tempo diretamente, mas o nmero de vezes que determinada operao
considerada relevante executada.
Funo de Complexidade de Espao f(n): mede a memria necessria
para executar um algoritmo em um problema de tamanho n.
UNIDADE 1 16
Complexidade de um algoritmo o tempo requerido para a execuo
deste algoritmo.
Efcincia de Algoritmos
Algoritmos criados para resolver o mesmo problema muitas vezes
diferem de forma drstica em sua efcincia. Essas diferenas podem ser
muito mais signifcativas que as diferenas relativas a hardware e software.
Dado um problema a ser resolvido, interessante procurar diversos
algoritmos que o faa escolher o melhor deles. Mas como decidir quais dos
algoritmos melhor?
Exemplo: Vamos comparar um computador mais rpido (computador
A) que execute a ordenao por insero com um computador mais lento
(computador B) que execute a ordenao por intercalao. Cada um deles
deve ordenar um milho de nmeros.
Suponha que o computador A execute um bilho de instrues
por segundo e o computador B execute apenas dez milhes de instrues
por segundo. Assim, o computador A ser 100 vezes mais rpido que o
computador B.
Suponha que o programador mais esperto codifque a ordenao
por insero em linguagem de mquina para o Computador A e que o
cdigo resultante exija 2n
2
instrues para ordenar n nmeros. Por outro
lado, a ordenao por intercalao programada para o computador B por
um programador mdio que utiliza uma linguagem de alto nvel com um
compilador inefciente, com o cdigo resultante de 50nlogn instrues. Para
ordenar um milho de nmeros, o
Computador A demora:
Computador B demora:
Usando o algoritmo cujo tempo de execuo mais lento, at mesmo
com um compilador fraco, o Computador B funciona 20 vezes mais rpido que
o computador A. Portanto, o algoritmo de ordenao por intercalao gasta
menos tempo computacional, ou seja, mais efciente do que o algoritmo de
ordenao por insero e esta vantagem ainda maior proporo que n
cresce.
Metodologia para Desenvolver Algoritmos Efcientes.
Os passos necessrios para procurar elaborar algoritmos que sejam
efcientes so: Anlise do Problema, Concepo do algoritmo, Anlise de
efcincia, Verifcao e refnamento.
Passo 1: Anlise do Problema
A anlise do problema uma etapa importante, pois permite uma
compreenso do que se pretende e facilita o compartilhamento com outros
pesquisadores.
Passo 2: Concepo do Algoritmo
A concepo uma etapa criativa. Nesta fase, podem ser aplicadas
as principais tcnicas de projeto de algoritmos, as quais sero estudadas
posteriormente.
Passo 3: Anlise de Efcincia
Por outro lado, o algoritmo pode estar correto, mas no ser efciente.
A busca por algoritmos efcientes de suma importncia, pois uma pequena
alterao no algoritmo poder trazer grande melhoria no desempenho do
mesmo.
Passo 4: Verifcao e Refnamento
A verifcao uma etapa importante para garantir que o algoritmo
trabalhe corretamente e faa o que deve fazer. O refnamento consiste em
introduzir alteraes no algoritmo com vistas a torn-lo correto e melhorar
sua efcincia em tempo de execuo e/ou espao de memria utilizada.
Um algoritmo resolve um problema quando, para qualquer entrada,
produz uma resposta correta quando concedidos tempo e memria sufcientes
para sua execuo.
Um algoritmo que resolve um problema (teoricamente) no signifca
UNIDADE 1 18
ser aceitvel na prtica. Os recursos de espao e tempo tm grande
importncia em casos prticos.
s vezes, o algoritmo mais direto est longe de ser razovel em
termos de efcincia. Um exemplo o caso da soluo de sistemas de
equaes lineares. O mtodo de Cramer, resolvendo o sistema atravs de
sua defnio, requer dezenas de milhes de anos para resolver um sistema
20x20. O mesmo sistema pode ser resolvido em tempo razovel pelo mtodo
de Gauss, como mostra a Tabela 1.1.
Tabela 1.1 TAMANHO DO PROBLEMA X TEMPO DE EXECUO
O avano tecnolgico concebe mquinas cada vez mais rpidas e
que passam a resolver problemas maiores, pois a complexidade do algoritmo
que determina o novo tamanho mximo do problema resolvvel.
Uma base slida de conhecimento e tcnicas de algoritmos
uma caracterstica que separa os programadores qualifcados dos no
qualifcados. Com a moderna tecnologia computacional, voc pode executar
alguns trabalhos sem saber muito sobre algoritmos, porm, com uma boa
base em algoritmos, possvel fazer muito mais.
CONCEITOS BSICOS
A arte de programar consiste em organizar e dominar a
complexidade
- Edsger W. Dijkstra
Introduo
A anlise de algoritmos tem como objetivo melhorar, se possvel, seu
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.
Comportamento Assinttico de Funes
O parmetro n fornece uma medida da difculdade para se resolver o
problema. Para valores sufcientemente pequenos de n, qualquer algoritmo
custa pouco para ser executado, mesmo os inefcientes. A escolha do
algoritmo no um problema crtico para problemas de tamanho pequeno.
Logo, a anlise de algoritmos realizada para valores grandes de n. O
comportamento assinttico de funo representa o limite do comportamento
do custo quando n cresce. Para saber o comportamento de um algoritmo ou
problema em relao ao tamanho da entrada, o que relevante?
Exemplo: Suponha dois algoritmos A e B cujos tempos de
execuo sejam TA(n)=3n+10 e TB(n)= n

+1. A Figura 1.1 mostra a
representao grfca,
Qual o maior deles? A Tabela 1.2 mostra onde o algoritmo A maior
do algoritmo B.
Tabela 1.2
UNIDADE 1 20
Para n < 9, T
A
(n) > T
B
(n), ou seja, o algoritmo A maior do que B para
todo n< 9.

Figura 1.1 T
A
(n) > T
B
(n)
Exemplo: Considere a existncia de dois algoritmos A e B para a
soluo de um problema. Se a complexidade de um expressa por T
A
(n)=
n2

e a do outro por T
B
(n)=100n. Isso signifca que, em funo do tamanho da
entrada de dados n, o algoritmo A cresce como uma parbola e o B cresce
linearmente. Desta forma, se os algoritmos forem usados para um conjunto de
30 dados, teremos: T
B
(30)=3000 e T
A
(30)=900, neste caso, T
A
<T
B
. No entanto,
se n=30000, teremos: T
A
(30000)=900.000.000 e T
B
(30000)=3000.000, ou
seja TA>TB.
Exemplo: Suponha T
C
(n) =45n+15 e T
D
(n)=0,1n2+0,5. Qual delas
maior?
Ordens Assintticas
A anlise de um algoritmo geralmente conta com apenas algumas
operaes elementares. A medida de custo ou medida de complexidade
relata o crescimento assinttico da operao considerada.
A complexidade assinttica defnida pelo crescimento da
complexidade para entradas sufcientemente grandes. O comportamento
assinttico de um algoritmo o mais procurado, pois para um volume grande de
dados, a complexidade torna-se mais importante. Algoritmo assintoticamente
mais efciente melhor para as entradas, exceto para entradas relativamente
pequenas.
Consideremos as funes f e g mapeando naturais em reais no
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 n
3
cresce mais rapidamente do que uma quadrtica
n2. Dizemos que a cbica n
3
CAS para n
2
. Do mesmo modo, uma funo
exponencial 2n CAS para n
2
.
Defnio:
Em geral, defne-se que g uma cota assinttica superior para f, se e
somente se (n
0
N)(n n
0
) f(n) g(n)
Para n sufcientemente grande, g(n) domina f(n).
Exemplo: O grfco da Figura 1.2 mostra esta notao O:
Figura 1.2:
Exemplo: Mostre que a funo exponencial 2
n
CAS para n
2
.
Exerccio: Para cada um dos seguintes pares de funes f e g,
verifque se possvel encontrar uma constante n
0
N tal que:
(n n0) f (n) g (n)
a) n, nlog
2
n
b) 2
n
, 3
n+1

Notao O
A notao O defne uma cota assinttica superior.
Seja N o conjunto dos nmeros naturais e R o conjunto dos nmeros
reais. O conjunto N* denota o conjunto dos nmeros naturais estritamente
positivos, R
+
* representa o conjunto dos nmeros reais estritamente positivos
UNIDADE 1 22
e R
+
o conjunto dos reais no negativos.
Seja f: N * R+ uma funo arbitrria.
Defnio:
Dadas duas funes assintoticamente no negativas f e g, dizemos
que f est na ordem de g. Escrevemos f=O(g), se f(n) c.g(n) para algum c
positivo e para todo n sufcientemente grande.
Em outras palavras, existe um nmero positivo c e um nmero natural
n
o
, tais que f(n) c.g(n) para todo n maior que n
o
.
Alternativamente, f(n) O(g(n)) se constante (mas
no infnito).
Exemplo: Seja f(n)=13n
3
+2n
2
+5nlogn e g(n)=n
3
, ento:
Simbolicamente:
O(g(n) = {f : N R
+
| (c R
+
*)(n
0
N)(n n
0
)[f(n) c.g(n)]}
Normalmente diz-se que f(n) O(g(n)) ou f(n) O(g(n)).
Exemplo grfco da Figura 1.3 de dominao assinttica que ilustra a
notao O.
Figura 1.3.
O valor constante n0 mostrado o menor valor possvel, mas qualquer
valor maior vlido.
Exemplos de Notao O
A notao O usada para estabelecer limites superiores de
complexidade.
( )
( )
n g
n f
lim
( )
( )
13
log 5 2
13 lim
log 5 2 13
lim lim
2 3
2 3
=
+ + =
+ +
=
n
n
n n
n n n n
n g
n f
Exemplo: Verifque, se g(n)=(n+1)
2
, ento:
g(n) O(n
2
) ou g(n)=O(n
2
), ou seja, (cR*
+
)((n
0
N)(nn0) g(n)
cf(n)
f(n)=n
2

(n+1)
2
c.n
2
n
2
+2n+1 c.n
2
c 1 + 2/n + 1/n
2
Logo, n
0
=1 e c=4
Isto porque (n+1)
2
4n
2
para n 1.
Exemplo: g(n)=3n
3
+ 2n
2
+ n O(n
3
)
Basta mostrar que 3n
3
+ 2n
2
+ n 6n
3
, para n 1
A funo g(n) = 3n
3
+ 2n
2
+ n tambm O(n
4
), entretanto, esta
afrmao mais fraca do que dizer que g(n) O(n
3
).
Exemplo: g(n)=log
5
n O(logn).
O log
b
n difere do log
c
n por uma contante no caso log
b
c.
Como n=c
logcn
, tomando o logaritmo base b em ambos os lados da
igualdade, temos que log
b
n=log
b
c
logcn
= log
c
n x log
b
c
Exemplo: Suponha que f(n)=2n
2
+ 3n +4 e que g(n)=n
2
. Observe que
2n
2
=3n + 4 2n
2
+ 3n
2
+ 4n
2
= 9n
2
desde que n 1. Resumindo, f(n) 9g(n)
para todo n 1. Portanto, f(n)=O(g(n)).
Exemplo: Suponha que f(n)= 3 + 2/n e que g(n)= n
0
, ou seja, g(n)=1.
Ento, 3 + 2/n 3 + 1 =4 = 4n0 desde que n 2. Resumindo, f(n) 4g(n) para
n 2. Portanto, f(n)=O(gn)).
Exemplo: Suponha que f(n)=n3 e que g(n)=500n2. No verdade
que f(n)=O(g(n)). De fato, se existissem c e n0 tais que f(n)cg(n), teramos
n500c para todo nn0. Mas isso absurdo!
Exemplo: 7n 2 O(n)
Prova: Pela defnio da notao O, precisou achar uma constante
c>0 e uma constante inteira n
0
>1, tais que 7n 2 cn para todo inteiro nn
0
.
fcil perceber que uma escolha poderia ser c=7 e n
0
=1. De fato, esta uma
das infnitas escolhas possveis porque qualquer nmero real maior ou igual
a 7 ser uma escolha possvel para c e qualquer inteiro maior ou igual a 1
uma escolha possvel para n
0
.
Algumas regras se aplicam na avaliao O(.)
Regra das Somas
UNIDADE 1 24
Proposio 1
Se determinado algoritmo P se divide em partes independentes,
digamos P1 e P2 e sendo T
1
(n) e T
2
(n) respectivamente de ordem O(f(n))
e O(g(n)) ento: T(n)=T
1
(n)+T
2
(n) e P ser de ordem O(mximo{f(n), g(n)})
(CAMPELLO & MACULAN, 1994).
Demonstrao:
Para c
1
,c
2
,n
1
e n
2
constantes
T
1
(n) c
1
.f(n), n n
1
T
2
(n) c
2
.g(n), n n
2

Sendo n
o
= mximo{n
1
,n
2
} e com n no.
Ento T
1
(n)+T
2
(n) c
1
.f(n)+c
2
.g(n) (c
1
+c
2
)mximo{f(n),g(n)}
Portanto, T(n) de ordem O(mximo{f(n),g(n)}.
Exemplo: Calcular o tempo de execuo de uma sequncia de trechos
de programas usando a regra da soma para O(f(n))+O(g(n)).
Suponha trs trechos cujos tempos de execuo so O(n), O(n
2
) e
O(n.logn).
O tempo de execuo dos dois primeiros O(max(n,n
2
)) que O(n
2
).
Exemplo: Considere o caso em que as funes f(.) e g(.) so dadas a
seguir:
Neste caso:

O tempo de execuo de todos os trs trechos O(max(n
2
,n.logn))
que O(n
2
).
Regra dos Produtos
( )
=
mpar n se , n
par n se , n
n f
2
4
( )
=
mpar n se , n
par n se , n
n g
3
2
( ) ( ) { }
=
mpar n se , n
par n se , n
n g , n f mximo
3
4
Proposio 2
Se T
1
(n) e T
2
(n) so de ordem O(f(n)) e O(g(n)) respectivamente,
ento:
T(n) = T
1
(n) . T
2
(n) de ordem O(f(n).g(n)).
Demonstrao
Por hiptese constantes c1 , c2, n1, n2 tais que:
T
1
(n) = O(f(n)) T
1
(n) c1.f(n), n n1
T
2
(n) = O(g(n)) T
2
(n) c2.g(n), n n2
Fazendo no = mximo{n1,n2} e c = c1.c2
T(n)= T
1
(n).T
2
(n) c(f(n).g(n)), n no
E, portanto, T(n) de ordem O(f(n).g(n))
Segue-se que O(k.f(n)) o mesmo que O(f(n)) quando k uma
constante positiva.
Outras propriedades:
f(n)=O(f(n))
k. O(f(n))= O(f(n)) k = constate
O(f(n)) + O(f(n)) = O(f(n))
O(O(f(n))) = O(f(n))
f(n)O(g(n)) = O(f(n)g(n))
Teorema:
Se T(n)=t
m
n
m
+t
m-1
n
m-1
+...+ t
1
n+t
o
um polinmio de grau m ento
T(n)=O(n
m
).
Demonstrao:
Usando a defnio:
T(n) = O(n
m
) ( c R
+
) T(n) c.n
2
, n no
|T(n)| |t
m
|n
m
+ |t
m-1
|n
m-1
+...+ |t
1
|n+|t
o
|
|T(n)| (|t
m
|+ |t
m-1
|/n+...+ |t
o
|/n
m
)n
m

|T(n)| = (|t
m
|+...+ |t
o
|)n
m
, n 1
Substituindo c=|t
m
|+...+ |t
o
| e n
o
=1
Temos |T(n)| c|n
m
| T(n) c.n
m
T(n) = O(n
m
)
UNIDADE 1 26
Exemplo: Seja T(n)= 2x
5
+45x
4
+ 100008x
2
-8888888 um polinmio de
grau 5, logo T(n)=O(n
5
), ou seja, despreza todos os termos de grau menor do
que 5 e a constante.
Uma ferramenta poderosa e verstil para provar que alguma funo
de ordem de outra a regra do limite, dadas as funes arbitrrias f,g:NR
+
*.
1. Se lim(f(n)/g(n)) R
+
* ento f(n) O(g(n)) e g(n) O(f(n))
2. Se lim(f(n)/g(n)) = 0 ento f(n) O(g(n)) mas g(n) O(f(n))
3. Se lim(f(n)/g(n)) = + ento f(n) O(g(n)) e g(n) O(f(n))
Exemplo: Sejam f(n) = logn e g(n) = n
Deseja-se determinar a ordem relativa das duas funes.
Desde que f(n) e g(n) tendem ao infnito quando n tende ao infnito,
deve-se usar regra de lHpital para calcular este limite.
Resoluo:
Provar que este limite existe.
Agora, a regra do limite nos mostra que logn O(n) e n O(logn).
Em outras palavras, a funo n cresce assintoticamente mais rpido
que log n.
1. Notao (mega)
A notao O nos d um limite superior para o tempo que algum
algoritmo gastar para qualquer instncia de tamanho n. Para estimar um
limite inferior, podemos usar a seguinte notao: (f(n)).
Exemplo: f(n)=7n
3
+5 cresce menos rapidamente do que uma
exponencial g(n)=2
n
.
Diz-se que a exponencial g(n) f(n)).
Defnio:
( ) ( ) ( ) ( ) n g n f
n
n g n f
n
~ ~
/
lim
/
lim

=

( ) ( ) ( ) 0 / 2 lim )
2
1
/ / 1 lim / log lim = = = n
n
n n n
Diz-se que g(n) (f(n)), se e somente se, para alguma constante c
R*
+
e n
o
N tal que g(n) c.f(n)
Isto : (f(n)) = {g: NR
+
|( c R*
+
)( n
o
N) ( n n
o
)[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 sufcientemente
grande.
Exemplo: Para mostrar que g(n)= 3n
3
+2n
2
(n
3
), basta fazer c=1, e
ento 3n
3
+2n
2
n
3
para n 0.
Exemplo: Seja g(n)=n para n mpar (n 1) e g(n) = n
2
/10 para n par (n
0). Neste caso, g(n) (n
2
), bastando considerar c=1/10 e n=0,2,4,...
Exemplo: A Figura 1.4 mostra o grfco para a notao .
Figura 1.4
Exemplo: Seja t(n)=n
3
-2n
2
+4n, podemos afrmar que t(n) (n
3
), pois
n
3
-2n
2
+4n 0.5n3 para n>1.
Exemplo: Se f(n)=n
2
-1, ento so vlidas as igualdades f(n)=(n
2
),
f(n)=(n) e f(n)=(1), mas no vale f(n)=(n
3
).
Exerccio: Para as funes exponencial f(n)=2
n
e cbica g(n)=7n
3
+5,
verifque que f(n) (g(n)), determinando as constantes c e no.
1. Notao (Theta)
A notao defne um limite assinttico exato. Por exemplo, as
funes quadrtica f(n)=5n
2
+ 4 e g(n)=n
2
+ 1 crescem com a mesma rapidez.
Diz-se que f(n) (f(n)), ou seja, (f(n)) = O(f(n)) (f(n)), se e
somente se, g(n)) = {f: NR
+
|( c, d R*
+
)( n
o
N) (n no)[c.g(n)
UNIDADE 1 28
f(n) d.g(n)]}
Podemos afrmar que duas funes f(n) e g(n), f(n)= (g(n)), se e
somente se, f(n)=O(g(n)) e f(n)= (g(n)).
Na prtica, normalmente aplicamos a notao para descrever um
limite inferior para o melhor caso e a notao O para descrever um limite
superior para o pior caso. A Figura 1.5 abaixo ilustra a notao
Figura 1.5 f(n) (g(n))
Exemplo: Seja g(n)=n
2
/3-2n. Vamos mostrar que g(n) = (n
2
).
Temos de obter constantes c, d e n
0
tais que c.n
2
(1/3)n
2
- 2n d.n
2

para todo n n
0
.
Dividindo por n
2
, temos c 1/3 - 2/n d.
O lado direito da desigualdade ser sempre vlido para qualquer
valor de n 1 quando escolhemos d 1/3. Da mesma maneira, escolhendo c
1/21, o lado esquerdo da desigualdade ser vlido para qualquer valor de
n 7. Logo, escolhendo c = 1/21, d = 1/3 e n
0
= 7, verifca-se que n
2
/3 - 2n=
(n
2
).
Outras constantes podem existir, mas o importante que existe
alguma escolha para as trs constantes.
A regra do limite para a notao reformulada da seguinte forma:
1. Se lim(f(n)/g(n)) R
+
* ento f(n) (g(n))
2. Se lim(f(n)/g(n)) = 0 ento f(n) O(g(n)), mas f(n) (g(n))
3. Se lim(f(n)/g(n)) = + ento f(n) (g(n)), mas f(n) (g(n))
Comparao de Funes
Algumas das propriedades relacionadas a nmeros reais tambm se
aplicam a comparao de funes assintticas. Nas propriedades seguintes,
suponha que f(n) e g(n) sejam assintoticamente positivas.
As notaes apresentadas respeitam as seguintes propriedades:
Refexividade:
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
Se f uma funo de complexidade para um algoritmo A, ento O(f)
considerada a complexidade assinttica ou o comportamento assinttico do
algoritmo A. A relao de dominao assinttica permite comparar funes
de complexidade. Entretanto, se as funes f e g dominam assintoticamente
uma a outra, ento os algoritmos associados so equivalentes. Nestes casos,
o comportamento assinttico no serve para comparar algoritmos.
Exemplo: Dois algoritmos C e D aplicados mesma classe de
problemas, sendo que C leva trs vezes o tempo de D ao ser executado,
isto , f(n) = 3g(n), sendo que O(f(n)) = O(g(n)). Logo, o comportamento
assinttico no serve para comparar os algoritmos C e D porque eles diferem
apenas por uma constante.
Podemos avaliar programas, comparando as funes de
complexidade. Um programa com tempo de execuo O(n) melhor que
outro com tempo O (n
2
). Porm, as constantes de proporcionalidade podem
alterar esta considerao.
Exemplo: Um programa leva 100n unidades de tempo para ser
executado e outro leva 2n
2
. Qual dos dois o melhor?
A resposta a essa pergunta depende do tamanho do problema a ser
executado. Para n<50, o programa com tempo 2n
2
melhor que 100n. Para
problemas com entrada de dados pequena, prefervel usar o programa cujo
tempo de execuo O(n
2
). Entretanto, quando n cresce, o programa com
tempo O(n
2
) leva muito mais tempo que o programa O(n).
Desafo:
D um exemplo de
funo positiva f(n) de
tal forma que f(n) no
seja nem O(n) nem (n).
UNIDADE 1 30
Classes de Comportamentos Assintticos
As principais classes de problemas possuem as funes de
complexidade descritas a seguir. Segundo Zivianni (2007),
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 fxo 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(n
2
)
1. Um algoritmo de complexidade O(n
2
) 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(n
3
)
1. Um algoritmo de complexidade O(n
3
cbica. teis para resolver pequenos problemas.
4. f(n) = O(2
n
)
1. Um algoritmo de complexidade O(2
n
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
comportamento muito pior que O(2
n
).
Segue a ordem de complexidade dos algoritmos.
2. O(1) < O(log n) < O(n) < O(n log n) <O(n
2
) <O(n
3
)<O(2
n
)
Um Algoritmo cuja complexidade O(c
n
), 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.
TABELA 1.3 COMPARAO DE VRIAS FUNES
Um problema considerado intratvel quando ele to difcil que
no existe um algoritmo polinomial para resolv-lo, enquanto um problema
considerado tratvel quando existe um algoritmo polinomial para resolv-lo.
Exemplo: um algoritmo com funo de complexidade f(n)=2
n
mais
rpido que um algoritmo g(n)=n
5
para valores de n menores ou iguais a 20.
Tambm existem algoritmos exponenciais que so muito teis na prtica.
Exemplo: O algoritmo Simplex para programao linear possui
complexidade de tempo exponencial para o pior caso, mas executa muito
rpido na prtica.
Exemplo: Um caixeiro viajante deseja visitar n cidades de tal forma
que sua viagem inicie e termine em uma mesma cidade, sendo que cada
cidade deve ser visitada uma nica vez. Supondo que sempre exista uma
estrada entre duas cidades quaisquer, o problema encontrar a menor rota
para a viagem.
UNIDADE 1 32
A Figura 1.4 abaixo ilustra o exemplo para quatro cidades c1, c2, c3
e c4 em que os nmeros nos arcos indicam a distncia entre as cidades. O
percurso <c1, c3, c4, c2, c1> uma soluo para o problema, cujo percurso
total em distncia 24.
Figura 1.6 Problema do caixeiro viajante
RECORRNCIAS
Introduo
Quando um algoritmo contm uma chamada recursiva, o seu tempo
de execuo pode ser descrito por uma recorrncia. Uma recorrncia uma
equao ou uma inequao que descreve uma funo em termos de seu
valor em entrada menor. Para exemplifcar, vamos apresentar a equao de
recorrncia do Mergesort (Intercalao).
T(n)=
Cuja soluo T(n)=O(nlogn).
Apresentaremos a seguir trs mtodos para resolver recorrncia, isto
, para obter limites assintticos para a soluo.
Algoritmos Defnidos por Recorrncia
1. Quando se deseja especifcar um algoritmo para a soluo de um
determinado problema, podemos utilizar duas abordagens:
1. Defnir um algoritmo iterativo.
2. Defnir um algoritmo recursivo.
Algoritmos Iterativos:
Saiba Mais
O uso da notao O
iniciou vrias discusses
na comunidade de
anlise de algoritmos e
teoria da computao,
como por exemplo, a
de que a igualdade
f(n) = g(n) de mo
nica, ou seja, apenas
no sentido esquerdo
para direita, mesmo
adotando-se o fato de
que a notao O defna
um conjunto de funes.
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
1. Na construo de um algoritmo recursivo devemos ter o
cuidado de sempre especifcarmos primeiro a condio bsica para depois
estabelecermos o passo recorrente. Estes dois elementos devero estar
isolados por intermdio de uma clusula condicional do tipo:
Se <condio bsica> ento:
<ao da condio bsica>
Seno,
<ao do passo recorrente>
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:
Desafo
Apresente um algoritmo
recursivo para calcular o
produto de dois inteiros
m e n usando apenas
adio.
UNIDADE 1 34
retorne (1)
Seno,
retorne (Fib(n - 2) + Fib(n - 1))
Recorrncias
Uma recorrncia uma frmula que defne uma funo sobre os
nmeros naturais. Uma relao de recorrncia um caminho para defnir
uma funo por uma expresso envolvendo a mesma funo.
Exemplo: A recorrncia abaixo defne uma funo T no conjunto dos
nmeros naturais:
T(1) =1 e
T(n)=T(n-1) + 3n + 2 para n=2, 3, 4, ...
Eis os valores de T(n) para valores pequenos de n:
Seja T(n) uma funo de complexidade que representa o nmero de
inspees nos n elementos do conjunto. O termo T(n) especifcado em
funo dos termos anteriores T(1), T(2), ..., T(n - 1).
T(n) = T(n/3) + n, T(1) = 1 (para n=1 fazemos uma inspeo).
Por exemplo: T(3) = T(3/3) + 3 = 4; T(9) = T(9/3) + 9 = 12?, e assim
por diante.
Seja T(n) uma funo de complexidade que representa o nmero de
inspees nos n elementos do conjunto. O termo T(n) especifcado em
funo dos termos anteriores T(1), T(2),... , T(n - 1).
Solucionando Recorrncia
Resolver uma relao de recorrncia nem sempre fcil. Resolvendo
uma relao de recorrncia, determina-se o tempo de execuo do algoritmo
recursivo correspondente.
Exemplo: A sequncia T abaixo se encontra defnida por recorrncia:
1. Condio bsica: T(1) = 2
2. Passo recorrente: T(n) = 2 T(n - 1), para n 2
Solucionando Recorrncia:
De acordo com a defnio da sequncia T, temos os seguintes
termos:
T(1) = 2
T(2) = 2T(1) = 2 2 = 2
2

T(3) = 2T(2) = 2 2
2
= 2
3

T(4) = 2T(3) = 2 2
3
= 2
4

T(5) = 2T(4) = 2 2
4
= 2
5

Podemos concluir que T(n) = 2n. Esta equao denominada de
SOLUO EM FORMA FECHADA para a relao de recorrncia sujeita a
condio bsica T(1). Denomina-se RESOLVER uma recorrncia ao processo
de se encontrar uma soluo em forma fechada para a recorrncia.
Exemplo: Atravs de induo matemtica a conjectura T(n) = 2n,
verifcada da seguinte forma:
Passo bsico:
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 defnio 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) = 3k
2
/2 + 7k/2 - 4
Temos T(k) = T(k-1) + 3k + 2 por defnio
T(k) = [3(k-1)
2
/2 + 7(k-1)/2 - 4] + 3k + 2
T(k) = 3k
2
/2 + 7k/2 - 8/2
T(k) = (3k
2
+ 7k - 8)/2
Logo, est provada nossa conjectura.
Como a frmula est correta, prova-se que T(n) = O(n
2
).
Como determinar a complexidade de um algoritmo recursivo?
Exemplo: Algoritmo Mergesort
UNIDADE 1 36
Pode ser escrito pela recorrncia:

Tcnicas de Recorrncia
Apresentaremos a seguir trs mtodos para resolver recorrncias,
isto , para obter limites assintticos para a soluo.
2. Mtodo da Substituio;
3. Mtodo da rvore de Recurso (iterao);
4. Mtodo Mestre.
Mtodo da Substituio
Este mtodo consiste em propor uma forma para a soluo (por
inspirao); determinar as constantes envolvidas por induo e mostrar que o
limite estabelecido vlido. Substituio vem do fato de substituir a resposta
inspirada pela hiptese indutiva aplicada a valores menores. um mtodo
poderoso, mas depende da percepo de quem analisa. efciente, mas
s pode ser aplicado em casos nos quais seja fcil pressupor a forma de
resposta.
Exemplo: Determinar um limite superior para a recorrncia T(n) =
2T(n/2) +(n)
Supondo que o mtodo da soluo visualizada seja T(n) = O(n log
n, o mtodo consiste em provar que T(n) c n log n para uma constante
c > 0 apropriada.
Assumiremos que este limite verdadeiro para n/2 , isto , T( n/2
) c n/2 log( n/2 ).
Substituindo na recorrncia temos:
T(n) 2(c n/2 log( n/2 ) + n
c n log(n/2) + n
c n logn c n log2 + n
c n logn c n + n
c n logn, para c 1
O prximo passo consiste em provar que a nossa soluo vlida
para as condies de contorno do problema, ou seja, devemos mostrar que
podemos escolher a constante c to grande quanto possvel que o limite T(n)
cnlogn vale para as condies de contorno. Assumindo que T(1) = 1 como
condio de contorno da recorrncia, no conseguiremos encontrar uma
constante c, pois T(1) c 1 log1 = 0. A sada para superar esta difculdade
consiste em usar um valor n n0 sendo n
0
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
4 2 c
c 2, para todo n 2.
Como observamos, qualquer valor de c 2 sufciente para que os
casos bsicos de n=2 e n=3 sejam vlidos.
A grande difculdade 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 verifcado 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(2
m
) = 2T(2
m/2
) + m. Substituindo a recorrncia S(m)
= T(2
m
), produzimos a recorrncia S(m) = 2S(m/2) + m, cuja soluo j
conhecida, ou seja, S(m) = O(m logm) . Substituindo m obtemos T(n) = T(2
m
)
= S(m) = O(m logm)= O(logn.log(logn))
O Mtodo de rvore de Recurso (Iterao)
Embora o mtodo de substituio possa fornecer uma prova de que
uma soluo para uma recorrncia correta, s vezes difcil apresentar
uma boa suposio. Traar uma rvore de recurso um caminho direto
para se criar uma boa suposio. Este mtodo consiste em desenhar uma
rvore cujos ns representam os tamanhos dos subproblemas. Cada nvel i
UNIDADE 1 38
contm todos os subproblemas de profundidade i. Dois aspectos importantes
devem ser considerados: A altura da rvore e o nmero de passos executados
em cada nvel. A soluo de recorrncia (tempo de execuo do algoritmo)
a soma de todos os passos de todos os nveis. No caso particular em que
o total de passos de cada nvel o mesmo, l(n), por exemplo, a soluo
T(n)=h.l(n), onde h a altura da rvore.
Uma rvore de recurso usada para gerar uma boa suposio, o
qual verifcado pelo mtodo de substituio.
Talvez o mtodo seja mais intuitivo.
Exemplo: Considere a equao de recorrncia do Mergesort.
Veremos como uma rvore de recurso forneceria uma boa suposio
para a recorrncia T(n) = 2T(n/2) + n
1. Supomos que n potncia de 2.
n/2
h
= 1 h = log
2
n Total = h.n

A altura da rvore h=logn Logo, O(n . log n)
Mesmo este mtodo no exigindo inspirao, requer mais lgebra que
o mtodo da substituio. A ideia consiste em expandir (iterar) a recorrncia e
express-la como um somatrio e dependendo apenas de n e das condies
iniciais.
Exemplo: Considere a recorrncia
Soluo usando a lgebra:
T(n) = 2(2T(n - 2) + 1) + 1
T(n) = 4T(n - 2) + 2 + 1
T(n) = 4(2T(n - 3) + 1) + 2 + 1
T(n) = 2
3
T(n - 3) + 4 + 2 + 1
- - - - - - - - - - - - - - - - - - - -
T(n) = 2
i
T(n-i) + 2
i-1
+ 2
i-2
+...+ 2
1
+ 2
0

O caso base alcanado quando i = n - 1
Logo, T(n) = 2
n-1
+ 2
n-2
+ 2
n-3
+...+ 2
1
+ 2
0
T(n) = 2
n
- 1 = O(2
n
)
Mtodo Mestre
Este mtodo fornece uma receita de bolo para resolver recorrncia da
forma: T(n) = aT(n/b) + f(n), onde a 1 e b > 1 so constantes e f(n) uma
funo assintoticamente positiva. O mtodo exige a memorizao de trs
casos, mas a soluo de muitas recorrncias torna-se mais simples.
Utilizando o mtodo mestre, a soluo depende do Teorema Mestre.
Teorema Mestre
Sejam a 1 e b > 1, constantes. Seja f(n) uma funo, e seja T(n)
defnido no domnio dos inteiros no negativos pela recorrncia T(n) = aT(n/b)
+ f(n), onde n/b pode ser n/b ou n/b. Ento, T(n) pode ser limitada
assintoticamente por:
1- Se f(n) = O(n
log
b
a-) para uma constante > 0, ento T(n) = (n
log
b
a).
2- Se f(n) = (n
log
b
a), ento T(n) = (n
log
b
alogn).
3- Se f(n) = (nlogba+) para uma constante > 0 e se af(n/b) cf(n)
para alguma constante c < 1 e n sufcientemente grande, ento T(n) = (f(n)).
Para melhor compreender o signifcado deste teorema, observe que
nos trs casos estamos comparando a funo f(n) com a funo n
log
b
a
. A
soluo da recorrncia dada pela maior das duas funes. No caso 1, a
funo nlogba maior, ento a soluo T(n) = (n
log
b
a
). No caso 2, as funes
so de mesma dimenso, sendo introduzido um fator logn e a soluo T(n)
= (n
log
b
a
logn) = (f(n)logn). No caso 3, a funo f(n) maior, ento, a soluo
T(n) = (f(n)).
importante ressaltar que o teorema no cobre todos os casos
possveis, apenas aqueles em que f(n) menor que nlogba por um fator
polinomial, isto , f(n) deve ser assintoticamente menor ou maior que nlogba
UNIDADE 1 40
para os casos 1 e 3 do teorema Mestre. Para o caso 3, deve ser satisfeita a
condio de regularidade onde af(n/b) cf(n).
Exemplo: Considere a seguinte equao de recorrncia
1. T(n) = 9T(n/3) + n
Neste caso, a = 9, b = 3, f(n) = n n
log
b
a
= n
log
3
9
= (n
2
)
Como f(n) = O(n
log
b
a-
), onde = 1, podemos aplicar o caso 1 do

teorema mestre e concluir que a soluo T(n) = (n
2
).
1. T(n) = T(2n/3) + 1
Neste caso, a = 1, b = 3/2, f(n) = 1 e nlogba = 1.
2. Aplica-se o caso 2, desde que f(n) = (n
log
b
a
) = (1) e a soluo da
recorrncia T(n) = (logn).
3. T(n) = 3T(n/4) + nlogn
Neste caso, a = 3, b = 4 e f(n) = nlogn, sendo n
log
b
a
= n
log
4
3
= O(n0,793).
Como f(n) = (n
log
4
2
+
), onde = 0,2, aplica-se o caso 3, caso a condio de

regularidade puder ser preservada.
Mtodo Mestre: Exemplo
Assim, para n tendendo para o infnito, af(n/b) = 3(n/4)log(n/4) (3/4)
nlogn = cf(n), para c = 3/4. Logo, pelo caso 3, a recorrncia corresponde a
T(n) = (nlogn).
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 signifca 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.
Exerccio 2
1. Dois algoritmos gastam n
2
dias e n
3
segundos, respectivamente, para
resolverem uma instncia de tamanho n. Em alguma situao, o algoritmo
quadrtico melhor do que o algoritmo cbico? Justifcar formalmente.
2. Sejam A e B dois algoritmos cujas complexidades so, respectivamente,
determinadas pelas funes f(n) e g(n) dadas abaixo. Para cada caso,
determine os valores inteiros positivos de n para os quais o algoritmo A
leve menos tempo para executar do que o algoritmo B.
1. f(n)= 2n
2
-2 e g(n)= 3n +5
2. f(n)= 3n
4
+ 2n
2
+ 1 e g(n)=4n
2
+ 1
3. Suponha que estamos comparando uma implementao do algoritmo
de ordenao por insero com uma implementao do mergesort. O
primeiro consome 8n
2
unidades de tempo quando aplicado a um vetor de
comprimento n e o segundo consome 64nlogn. Para que valores de n o
primeiro mais rpido que o segundo?
4. Suponha dois algoritmos A e B com funes de complexidade de tempo
a(n)=n
2
-n+549 e b(n)=49n+49, respectivamente. Determine quais valores
de n pertencentes ao conjunto dos nmeros naturais para os quais A leva
menos tempo para executar do que B.
5. Para os seguintes pares de funes, determine o menor valor para n,
para o qual a segunda funo torna-se menor do que a primeira:
a) n
2
, 10n c) n
2
/logn, n(logn)
2
b) 2
n
, 2n
3
d) n
3
/2, n
2.81

6. Para cada um dos seguintes pares de funes f e g, verifque se possvel
encontrar uma constante n
0
N tal que (n n
0
) f(n) g(n)
a) n, nlog
2
(n) b) 2
n
, 3
n+1
UNIDADE 1 42
7. Quais das afrmaes abaixo so verdadeiras? Justifque a sua resposta.
a) 10n = O(n)
b) 10n2 = O(n)
c) 2n+1 = O(2n)
d) 22n = O(2n)
e) n = O(n2)
f) f(n) = O(v(n)) e g(n) = O(u(n)) f(n) + g(n) = (v(n)+u(n))
g) (3/2)n
2
+ (7/2)n 4 =O(n2)
8. Qual das seguintes afrmaes sobre crescimento assinttico de funes
no verdadeira?
a) se f(n)=O(g(n)) e g(n)=O(h(n)), ento f(n)=O(h(n))
b) se f(n) =O(g(n)), ento g(n)=(f(n))
c) 6n
2
+ 8n + 3=O(n
2
)
d) se f(n)=O(g(n)), ento g(n)=Of(n))
e) 3n
3
+ 30n=O(n
3
)
9. verdade que n
2
+ 2000n +5466 = O(n
2
)? Justifque.
10. verdade que n
2
- 2000n +5466 = O(n)? Justifque.
11. verdade que n
4
-99988889n
2
+ 5000008= O(n
3
)? Justifque.
12. Para cada um dos seguintes pares de funes f e g, verifque se possvel
encontrar constantes n
0
N e c R
+
, tais que (n n
0
) f(n) cg(n):
a) 2
5
n, n
3
b) 10
n
n
2
, n2
n

13. Suponha que f(n) = (3/2) n
2
+ (7/2)n-4 e que g(n) = n
2
. Verifque que f(n)
O(g(n)), determinando constantes n
0
N e c R*
+
.
14. Suponha que f(n) = 3n
3
+ 2n
2
e que g(n) = n
3
. Verifque que f(n) O(g(n)),
determinando constantes n
0
N e c R*
+
.
15. Provar que a notao O transitiva, isto , se f(n) O(g(n)) e g(n)
O(h(n)), ento f(n) O(h(n)) para qualquer funo f: N R*.
16. Provar que se f(n) O(n), ento [f(n)]
2
O(n
2
).
17. Sejam duas funes no negativas f(n) e g(n). Diz-se que f(n)=(g(n)) se
f(n)=O(g(n)) e g(n)=O(f(n)). Mostre que max(f(n), g(n)) = (f(n) + g(n)).
EXERCCIO III
1. Considere a equao de recorrncia a seguir, defnindo T(n):
Demonstre por induo que T(n)= n(n +1)/2.
2. Considere a equao de recorrncia a seguir, defnindo T(n):
Demonstre por induo que T(n)=2
n
3. Considere a recorrncia:
Mostre que T(n)8n logn para n8. Deduza da que T(n)=O(nlogn).
4. Usar o mtodo da substituio para provar que a soluo de T(n)= T(n/2)
+ 1 O(logn).
5. Mostre que a soluo de T(n)=2T(n/2) + n O(n2).
6. Atravs do Mtodo da Substituio, prove que:
1. T(n)=T(n/2) + 1 O(logn)
2. T(n)=2T(n/2) + n
3
O(n
3
)
7. Em ambos os casos, considere T(1)=1.
1. Mostrar que a soluo para a recorrncia
T(n)= O(1) para n=0
T(n)= T(n-1) + 1 para n>0
8. Atravs do Mtodo Mestre, determinar limites assintticos para as
seguintes recorrncias.
a) T(n) = 4T(n/2) + n
b) T(n) = 4T(n/2) + n
2

c) T(n) = 7T(n/8) + n
2

9. Atravs do Mtodo Mestre, prove que a ordem assinttica de
1. T(n)=16T(n/4) + n
2
O(n
2
logn)
2. T(n)=2T(n/2 +10) + n O(nlogn)
UNIDADE 1 44
UNIDADE 2
Tcnica de Anlise de
Algoritmos
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.
Resumindo
TCNICA DE ANLISE DE
ALGORITMOS
ANLISE DE ALGORITMOS
"A anlise de algoritmos uma disciplina de engenharia.
Um engenheiro civil, por exemplo, tem mtodos e tcnicas
para prever o comportamento de uma estrutura antes de
construi-la.
Da mesma forma, um projetista de algoritmos deve ser
capaz de prever o comportamento de um algoritmo antes
de implement-lo."
Annimo
Introduo
A anlise de algoritmos um ramo da cincia da computao
que estuda as tcnicas de projeto de algoritmos e os algoritmos de forma
abstrata, sem estarem implementados em uma linguagem de programao
em particular ou implementadas de algum modo. Ela se preocupa com os
recursos necessrios para a execuo do algoritmo, tais como o tempo de
execuo e o espao de armazenamento de dados.
Neste captulo, apresentaremos algumas tcnicas muito teis
para analisar a complexidade do pior caso de um algoritmo, envolvendo
as principais estruturas de controle normalmente encontradas, bem como
mostraremos alguns exemplos de aplicaes.
Analisar Algoritmos
Uma metodologia usada para realizar a complexidade de um
UNIDADE 2 48
algoritmo est baseada na sua estrutura (TOSCANI, 2001). Ela detm a
complexidade do algoritmo, passo a passo, atravs das complexidades de
suas componentes.
Sero analisadas as complexidades de cada uma das principais
estruturas algortmicas a seguir, estabelecendo equaes para elas.
3. Atribuio: v w,
4. Sequncia: S; T,
5. Condicional: se b ento S seno T ou (se b ento S)
6. Iterao defnida (incondicional)
para i de j at m faa S.
7. Iterao indefnida ( condicional )
enquanto b faa S.
Complexidade de Algoritmos
1. O tempo de execuo de um comando de atribuio, leitura ou
de escrita pode ser considerado com O(1). Existem excees
para as linguagens que permitem a chamada de funes em
comandos de atribuio ou quando envolvem vetores de tamanho
arbitrariamente grande.
2. O tempo de execuo de uma sequncia de comandos
determinado pelo maior tempo de execuo de qualquer comando
da sequncia.
3. O tempo de execuo de um comando de deciso dos comandos
executados dentro do comando condicional, mais o tempo para
avaliar a condio, que O(1).
4. O tempo para executar um lao a soma do tempo de execuo
do corpo do lao mais o tempo de avaliar a condio para
determinao, multiplicando pelo nmero de iteraes do lao.
5. Quando o programa possui procedimentos no recursivos, o
tempo de execuo de cada procedimento deve ser computado
separadamente um a um, iniciando com os procedimentos que no
chamam outros procedimentos. A seguir, devem ser avaliados os
procedimentos que chamam os procedimentos que no chamam
outros procedimentos, usando os tempos dos procedimentos j
avaliados. Este processo repetido at se chegar ao programa
principal.
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
A atribuio uma estrutura sintaticamente simples, cuja semntica
depende do tipo de dado atribudo. A atribuio pode ser uma operao
simples, como a atribuio de um valor a uma varivel, ou uma atribuio
mais complexa, como a insero de um nodo num grafo, a atualizao de
uma matriz, dentre outros.
Exemplo: Considere as atribuies a seguir:
7. Para as variveis inteiras i e j:
i 0 {inicializao}
j i {transferncia}
Ambas tm complexidade constante: O(1).
8. Para lista v de inteiros e varivel inteira m:
m Max(v) {valor mximo}
Esta atribuio envolve (sendo n o comprimento da lista em v).
Determinar o mximo da lista v, com complexidade O(n);
Transferir este valor, com complexidade O(1).
Sua complexidade tem ordem linear: O(n) +O(1)=O(n),
9. Para listas u, v e w;
uv {transfere lista}
w Reversa(v) {inverte lista}
A atribuio uv transfere cada elemento da lista v com complexidade
O(n) para uma lista v com comprimento n.
A atribuio wReversa(v) envolve (lista v com comprimento n);
Inverter a lista v com complexidade O(n).
Transferir os elementos da lista invertida com complexidade O(n).
Sua complexidade tem ordem O(n) +O(n) : O(n).
Complexidade de Sequncias

Essa estrutura tem a forma: S; T. A complexidade da sequncia a
soma das complexidades componentes.
UNIDADE 2 50
Exemplo: Considere as sequncias a seguir:
10. Para variveis inteiras n e m:
n 0; m n
Sua complexidade tem ordem 1 + 1: O(1).
11. Para lista v de inteiros e varivel inteira i:
i Max(v); i i + 1;
Sua complexidade tem ordem n + 1: O(n).
12. Para listas u, v e w: (as listas tm comprimento n)
u v; w Reversa(v). (Lista invertida)
Sua complexidade tem ordem n + n: O(n).
Exemplo: Considere o trecho de algoritmo
v Reversa(n);
w Ordene(v);
Onde Reversa e Ordene tem complexidade O(n) e O(n
2
).
O algoritmo tem complexidade de ordem n+n
2
, isto , O(n
2
).
Exemplo: Dados algoritmos Prim(u) e Buscab(a,v), considere a
sequncia:
v Prim(u); Buscab(a,v);
Vamos Supor que:
Prim(u) d como sada a primeira metade da lista em u com
comprimento n/2 e complexidade O(n) (n o comprimento da lista em u).
Buscab(a,v) procura a na lista v, com complexidade O(log m), para
lista v com comprimento m.
O algoritmo composto tem complexidade de ordem n+log n/2, ou
seja, O(n).
Complexidades Condicionais
A estrutura condicional pode apresentar-se de diversas formas, as
mais usuais sendo as seguintes:
Se b ento S seno T
e
Se b ento S
Anlise destas formas:
Vamos iniciar a anlise como a forma mais simples
Estrutura Condicional: Se b ento S
Exemplo: Considere as estruturas condicionais a seguir:
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 afrmativo, 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 afrmativo, 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
Determinar se os valores de i e j so diferentes com complexidade
O(1). Caso afrmativo, 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)
Determinar se as listas u e v so iguais com complexidade O(n). Caso
afrmativo, 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(n
2
).
Sua complexidade total, no pior caso : O(n) +O(n) + O(n
2
)= O(n
2
).
Complexidade de Iterao Defnida
UNIDADE 2 52
A estrutura a ser trabalhada a iterao defnida ou incondicional da
forma:
para i de j at m, faa S.
Esta iterao executa S (m j +1) vezes com valores de i variando
de j at m. Considerando-se que os valores de j e m no so alterados na
execuo de S, o nmero de iteraes determinado por (m j +1).
Exemplo: Considere as iteraes defnidas a seguir:
Para varivel inteira m:
para i de 1 at 20, faa m m + 1
Sua complexidade tem ordem constante 20 . 1, isto , O(20)=O(1)
Para vetor A[1 .. n] de inteiros:
para i de 1 at n faa A[i] 0
Sua complexidade do tipo n . 1, isto , O(n).
Para vetor A[1 .. n] de inteiros:
para i de 1 at n, faa A[i] A[i] + 1
Sua complexidade n . 1: O(n).
Para varivel real s e o vetor R[1..n] de reais:
para i de 1 at n, faa s s + R[i]
Sua complexidade n . 1: O(n).
Para varivel real t e matriz quadrada Q[1..n,1..n] de reais:
para i de 1 at n, faa t t + Q[i,i]
Sua complexidade O(n).
1. Complexidade de Iterao Indefnida
Esses tipos de laos no so to fceis de analisar comparados com
os laos para. O primeiro fator a ser observado a regra de parada do lao.
Se a regra de parada envolve uma varivel inteira e uma constante, o lao
pode ser analisado de maneira semelhante ao lao para. Quando o controle
envolve duas variveis inteiras, a anlise padro consiste em expressar o
comportamento como uma varivel nica a ser decrementada.
Iteraes indefnidas ou condicionais podem tomar vrias formas,
dentre elas ENQUANTO e REPITA.
Enquanto b faa S
Exemplo: Considere os trechos de algoritmos a seguir.
Para varivel inteira i:
i 0
Enquanto i 10 faa:
i i + 1
Sua complexidade tem ordem constante 10.1, isto , O(10).
Inicializao de vetor A [1..n] de inteiros:
i 0
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:
i n
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. fm para
5. fm 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.
UNIDADE 2 54
Linha 1 Ser executada n+1 vezes
Linha 2 Ser executado n x
n
i=1
+ n vezes
Linha 3 Ser executada n x
n
i=1

Linha 4 No tem custo.
O lao da linha 1 voltar para si mesmo n vezes, isto , testar
novamente sua condicional e incrementar um. No fnal ele ter que testar
novamente para dizer que j passou de n. Por isso, ele ser executado n + 1
vez, ao invs de simplesmente n.
O lao da linha 2 ser executado um nmero de vezes que a varivel
i, onde i ir de 1 a n. Portanto, ele ser executado o nmero de vezes que
equivale a soma de 1 a n mais n.
O lao da linha 3 ser executado o mesmo nmero que a linha 2, mas
sem n.
Exemplo : Faa a anlise para o seguinte trecho de programa:
ler(n); T
1
(n)= O(1)
para i de 1 at n faa
para j de 1 at n faa T
2
(n)=O(n
2
)
A[i,j] 0;
para i de 1 at n faa T
3
(n)=O(n)
A[i,j] 1;
T(n) = T
1
(n) + T
2
(n) + T
3
(n)
T(n) = O(1) + O(n2) + O(n) = O(n
2
)
Exemplo: Faa a anlise do trecho do programa:
Se A[i,i] = 0, ento:
para i de 1 at n, faa:
para j de 1 at n , faa f(n) = n
2

A[i,j] 0;
Seno:
para i de 1 at n ,faa g(n) = n
A[i,i] 1;
T(n) = f(n) + g(n) = O(max(f(n),g(n))
T(n) = O(max(n
2
, n)) = O(n2)
Exemplo: Fatorial
Ler(n);
i 2;
Desafo:
Qual o tempo de
execuo total para
contar de 1 a n em
binrio, se o tempo
necessrio para
somar 1 ao nmero i
proporcional ao nmero
de bits na representao
binria de i que devem
ser alterados para
representar i+1?
Fat 1;
enquanto i n, faa:
Fat Fat * i;
i i +1;
escreva Fat;
Exemplo: Verifcar se um inteiro n primo
Primo verdade
i 2
enquanto i * i n, faa:
Se n mod i = 0, ento:
primo falsidade
goto 44
seno:
i i +1;
44 fm
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:
P
n
(x) = a
n
x
n
+ a
n-1
x
n-1
+ ... +a
1
x + a
E so comparadas as suas complexidades.
Algoritmo 1
Ler (n, a
n
,, a
n-1
-,,..., a
0
,,x}
P a
0
y x
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
UNIDADE 2 56
operaes de tempo constante. Como este executado (n-1),
Portanto o algoritmo 1 tem complexidade;
T(n) = (n-1)[O(1)+O(1) +O(1)] = O(n)
Algoritmo 2
Ler (n, a
n
,, a
n+1
-,,..., a
1
, a
0
,x}
P a
0
para i de 1 at n, faa:
P P + a
i
* x
i
;
O lao executado n vezes e a cada execuo (2 + i) as operaes
so realizadas,
portanto,
Algoritmo 3
Ler (n, a
n
,, a
n-1
-,,..., a
1
, a
0
,x}
P a
n
;
para i de n-1 at 0, faa:
P ai + x * P;
Neste caso, cada execuo do lao realiza uma soma e um produto,
ou seja, duas operaes de tempo de execuo. Assim T(n) = n. O(1) = O(n)
Este exemplo mostra claramente a importncia de algoritmos
efcientes.
Para valores grandes, digamos n = 10000, um nmero pequeno de
operaes seriam realizadas (108 ou 104)
Algoritmos de Menor Complexidade para Ordenao
Heapsort
O(n log n)
Mergesort
possvel provar que este limitante o melhor possvel, isto , estes
algoritmos so timos.
Teorema: Dados um vetor A [1],..., A [n] e um valor x, verifcar se x
elemento do vetor.
Qual o melhor algoritmo? Depende! Dados ordenados ou no?
Dados ordenados:
Pesquisa binria com complexidade de O(log n).
Dados no ordenados:
Pesquisa sequencial com complexidade de O(n).
Desafo:
Mostre que qualquer
algoritmo de
ordenao baseado
em comparaes pode
ser transformado em
um mtodo estvel
sem afetar o tempo de
execuo assinttico do
algoritmo.
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 efciente.
O(n log n), O(n
2
)
Exerccio
1. Quanto tempo (em nmero de operaes) gasto para executar o
seguinte algoritmo?
para i1 at n-1, faa:
Para k1 at n, faa:
S[i,k] S[i,k] S[i,k]*S[i,i]/S[i,i]
2. Determine o tempo consumido na execuo do algoritmo abaixo:
S0
para i1 at n, faa:
SS + A[i]
mS/n
k1
para i2 at n, faa:
se (A[i] m)/2 <(A[k] m)/2, ento:
ki
retorne k
UNIDADE 2 58
Lao1(n)
s0
para i1 at n, faa:
ss + 1
Lao2(n),
t1
para t1 at 2n, faa:
tt*i
Lao3(n);
t1
para t1 at n2, faa:
tt*i
Lao 4(n);
s0
para i1 at 2n, faa:
para j1 at i, faa:
ss +i
Lao5(n);
s0
para i1 at n2 , faa:
para j1 at i, faa:
ss +i
Figura 1.8 Algoritmo.
3. Fornea uma estimativa em notao O e em funo de n para o mtodo
do lao1, dado no algoritmo da fgura 1.8.
4. Fornea uma anlise similar para o mtodo lao 2 do algoritmo da fgura
1.8.
1.8.
1.8.
1.8.
8. Faa a anlise do algoritmo de ordenao por insero
1 Ordenao por insero (A, n)
2 Para j2 at n, faa:
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
UNIDADE 1 60
UNIDADE 3
Tcnica de Projeto de
Algoritmos
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.
Resumindo
TCNICA DE PROJETO DE
ALGORITMOS
INTRODUO
"Ter uma base slida de conhecimento das tcnicas de
projeto de algoritmos uma caracterstica que separa
os programadores verdadeiramente qualifcados dos
novatos. Com a moderna tecnologia da computao, voc
pode realizar algumas tarefas sem saber muito sobre
algoritmos, mas com uma boa experincia em algoritmos,
voc pode fazer muito, muito mais."
Cormen, Leiserson, Rivers, Stein, "Introduction to
Algorithms"
Ao se projetar um bom algoritmo, deve-se levar em conta uma
estratgia que possibilite obter uma boa complexidade, tanto temporal quanto
espacial. Diante disso, tcnicas de projeto de algoritmos so conjuntos de
tcnicas que compreendem tantos os mtodos de codifcao de algoritmos
quanto a forma de determinar sua complexidade e que propiciam a produo
de algoritmos fortes e levando em considerao a forma pela qual determinado
algoritmo chega a soluo desejada.
FORA BRUTA
a mais simples estratgia de projeto de algoritmos. Soluo direta
para resolver um problema, usualmente baseada no prprio enunciado do
problema e nas defnies dos conceitos envolvidos. Consiste em enumerar
todos os possveis candidatos de uma soluo e verifcar se cada um satisfaz
o problema. considerada por muitos a tcnica de projeto mais fcil de
aplicar.
UNIDADE 3 64
Apesar desta tcnica, raramente, gerar algoritmos efcientes,
uma importante tcnica para projeto de algoritmos, visto que aplicvel a
uma ampla variedade de problemas, podendo ser empregada em diversas
situaes comuns, porm importantes. Por exemplo, encontrar o maior
elemento de uma lista, somar n nmeros, os divisores de um nmero natural
n, etc.
Assim, uma alternativa vlida quando se deseja resolver um
problema pequeno atravs de um algoritmo simples e direto. A fora bruta
tipicamente usada em problemas cujo tamanho limitado ou quando h
uma heurstica usada para reduzir o conjunto de candidatos para um espao
aceitvel.
Para alguns problemas, a tcnica de fora bruta gera algoritmos
razoveis, prticos e sem limitaes no tamanho da instncia, como por
exemplo, o problema da multiplicao de matrizes, casamento de padres,
etc.
O esforo para projetar algoritmos mais efcientes pode no compensar
o trabalho, quando o tamanho das instncias ou a quantidade de problemas a
resolver pequeno, ou seja, se obtm uma velocidade aceitvel.
Tambm pode ser utilizado quando a simplicidade da implementao
mais importante que a velocidade de execuo como nos casos de aplicaes
crticas em que os erros de algoritmo possuem srias consequncias.
DIVIDIR- E-CONQUISTAR
Introduo
Esta tcnica consiste em decompor instncias a serem resolvidas
em um nmero de subinstncias menores do mesmo problema, resolvendo
sucessivamente e independentemente cada uma delas, combinando-as para
obter a soluo do problema original.
Apresentaremos, a seguir, um exemplo da aplicao desta tcnica de
projeto de algoritmos aplicada ordenao.
Ordenao
Seja T[1..n] um vetor de n elementos. Deseja-se ordenar esses
elementos em ordem crescente.
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 verifca 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 fnal 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 fm
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
Vetor dividido em duas metades
UNIDADE 3 66
Vetor aps retorno das duas ordenaes recursivas
Vetor aps o merge
Correo:
Pelo teorema de Jean Pierre basta olhar, esse algoritmo est correto,
ou seja, dado um vetor T no ordenado, ao fnal 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 t
1
, t
2
, t
m+n
na ordem de seleo do
merge, que corresponde sada.
Para o vetor no ser ordenado, deve haver algum elemento t
i
>t
j
, 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:
O algoritmo recursivo. A parte de merge e inicializao podem ser
feitas em O(n), onde n o tamanho do vetor de determinada instncia.
Sendo T(n) o nmero de passos elementares executados pelo
algoritmo, todos concordam que T(n) = 2T(n/2) + n, abstraindo os detalhes
tcnicos.
Como obter a complexidade desta expresso?
Para responder a esta questo, faremos uso do ferramental
apresentado na Unidade anterior, mais especifcamente o Mtodo Mestre.
Se T(n) = 2.T(n/2) + n, f(n)=n e f(n)=(n
log
b
a
), pois a=b=2
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
4 seno:
5 U[1.. n-1] T[1..n-1]
6 V[1] T[n]
7 mergesort(U)
8 mergesort(V)
9 merge(U,V,T)
10 fm
Qual a complexidade do algoritmo mergesort2?
T(n) = T(n-1)+T(1)+n, o que corresponde claramente a (n
2
).
Quicksort
O Quicksort tem tambm por objetivo ordenar um vetor. Para isto, o
algoritmo escolhe um elemento como pivot, particionando o vetor em dois:
elementos direita e elementos esquerda do pivot. Cada uma das parties
ordenada recursivamente pelo algoritmo quicksort.
Aritmtica com Nmeros Inteiros Grandes
At agora, ns temos considerados que adio e multiplicao so
operaes elementares, isto , o tempo necessrio para executar estas
instrues limitado superiormente por uma constante que depende somente
da velocidade do circuito do computador utilizado. Isto s vlido quando
o tamanho do operando pode ser manuseado diretamente pelo hardware.
Para algumas aplicaes, devem-se utilizar inteiros muito grandes. A
Desafo:
Projete um algoritmo
utilizando a tcnica
dividir-e-conquistar para
encontrar o menor e o
maior elemento entre
n nmeros usando
no mais que 3n/2
comparaes.
UNIDADE 3 68
representao destes nmeros por ponteiro futuante no recomendvel,
a menos que se esteja interessado, exclusivamente, na ordem de magnitude
e com os algarismos mais signifcativos do resultado. Se o mesmo tiver de
ser calculado de forma exata com todos os algarismos, h a necessidade de
implementar operaes aritmticas no software.
Embora uma multiplicao elementar raramente leve mais tempo
do que uma adio na maioria dos computadores, isto est longe de ser
verdade quando os operandos envolvidos so muito grandes. H algoritmos
que somam dois inteiros em tempo linear, por outro lado, o algoritmo clssico
e a multiplicao a la russe leva um tempo quadrtico para multiplicar estes
mesmos operandos. Como melhorar? Seja u e v dois inteiros com n dgitos
decimais a serem multiplicados.
Utilizando a estratgia de Dividir-e-Conquistar, possvel separar
cada um desses operandos em duas partes do mesmo tamanho, o mais
prximo possvel: u = 10
s
w + x; v = 10
s
y + z, onde 0x<10
s
e s=n/2.
Consequentemente, os inteiros w e y possuem n/2 dgitos. Veja a fgura
abaixo.
(Por convenincia, diz que um inteiro tem j dgitos se for menor que
10j, mesmo se no for maior ou igual a 10j-1)
U
V
n/2 n/2
O produto que nos interessa :
uv = 10
2s
wy + 10
s
( wz + xy) + xz
Obtm-se o algoritmo a seguir:
1 funo mult (u,v: inteiros grandes) : inteiros grandes
2 n o menor inteiro tal que u e v sejam de tamanho n
3 se n pequeno, ento multiplicar u por v utilizando o algoritmo
clssico
4 retornar o produto computado
5 seno:
6 s n div 2
7 w u div 10s ; x u mod 10
s

8 y v div 10s ; z v mod 10
s

9 retornar mult (w,y) 102s + (mult(w,z) + mult(x,y)) 10
s
+ mult (x,z)
Seja T(n) o tempo, no pior caso, necessrio para o algoritmo multiplicar
dois inteiros de n dgitos, h algoritmos conhecidos que executam em tempo
linear divises e multiplicaes por 102s e 10s, bem como as adies. O
mesmo ocorre para as operaes de mdulo, uma vez que estas so
equivalentes a uma diviso, uma multiplicao e uma subtrao de inteiros. A
ltima parte do algoritmo consiste em quatro chamadas recursivas, cada uma
delas serve para multiplicar dois inteiros cujo tamanho aproximadamente
n/2. Ento, T(n) 3T(n/2) + T(n/2) + (n).
Esta equao torna-se T(n) 4T(n/2) + (n), quando n uma potncia
de 2. Pode-se, facilmente, verifcar que a complexidade deste algoritmo
O(n2).
O artifcio que permite acelerar o processo consiste em executar os
clculos wy,wz + xy, e xz em menos de quatro meias multiplicaes, mesmo
que seja necessrio ter de fazer mais adies. Isto sensvel, pois a adio
muito mais rpida do que a multiplicao (que quadrtica) quando os
operandos so grandes. Considere o produto:
r = (w + x)( y+ z) = wy + (wz + xy )+ xz.
Depois de apenas uma multiplicao, incluindo os trs termos
necessrios para calcular uv, duas outras multiplicaes so necessrias
para isolar esses termos. Isso sugere que se deve substituir a ltima parte
do algoritmo por:
r mult (w + x, y + z)
p mult (w,y); q mult (x,z)
retorna 102sp+10s(rpq) + q
Seja T(n) o tempo necessrio pelo algoritmo modifcado para
multiplicar dois inteiros no mximo de tamanho n. Sabendo-se que w + x e y
+ z pode ter at 1 + n/2 dgitos, supe-se que exista constante c R
+
e
n
0
N, tal que:
T(n) T (n/2) + T(n/2) + T (1+n/2) + cn para cada n n0 . A
equao equivale a T(n) 3T(n/2) + O(n) .
Assumindo n, sendo potncia de 2, pode-se considerar que:
T(n) = 3T(n/2) + cn
Aplicando o mtodo mestre, n
log
b
a
= n
log
2
3
e f(n)=(n), da f(n)
O(n
log
2
3
). Assim, aplica-se o caso 1 e o algoritmo (n
log
2
3
).
UNIDADE 3 70
Desta forma, o algoritmo de multiplicao de inteiros de n dgitos tem
complexidade O(n
1,59
), para algum valor n > n0, que melhor do que a do
algoritmo clssico O(n
2
).
Entretanto, as constantes escondidas so tantas que o algoritmo
s se torna interessante na prtica quando n bastante grande. Uma boa
implementao provavelmente no usar a base 10, mas de preferncia a
maior base na qual o hardware pode multiplicar diretamente dois dgitos.
Exemplo:
Deseja-se multiplicar u=2.345 e v=6.789. A decomposio inicial
dos operandos dada por n=4, s=2, w=23, x=45, y=67, e z=89. Ns
obtemos sucessivamente p=23X67=1541, q=45X89=4.005 e r=(23+45)
(67+89)=68x156=10.608. Finalmente, o produto desejado uv obtido,
calculando:
1.541x10
4
+(10.6081.5414.005)x10
2
+ 4.005=15.410.000+506.200+
405=15.920.205.
claro que este exemplo muito pequeno e seria mais rpido usar o
algoritmo clssico de multiplicao.
A multiplicao no a nica operao interessante que envolve
inteiros grandes. Diviso de inteiros, operaes, o mdulo e o clculo da
parte inteira da raiz quadrada podem ser executados em um tempo de mesma
ordem que o necessrio para a multiplicao. Um outro ponto importante que
operaes com inteiros grandes so de suma importncia para a criptologia.
PROGRAMAO DINMICA
Introduo
Programao Dinmica resolve problemas combinando as solues
dos subproblemas.
Programao refere-se a um mtodo tabular, no programao no
computador. A tcnica de dividir-para-conquistar particiona o problema em
subproblemas independentes, resolve-os recursivamente e ento combina
suas solues para resolver o problema original. A programao dinmica,
por sua vez, aplicvel quando os subproblemas no so independentes,
havendo assim a necessidade de uma tabela para armazenamento dos
resultados a serem compartilhados e evitar clculos repetidos.
A programao dinmica pode ser dividida em quatro passos:
1. Caracterizao da estrutura de uma soluo tima;
Saiba Mais
A tcnica de diviso-
e-conquista parte do
folclore do projeto de
estruturas de dados e
algortimos. O mtodo
mestre para resolver
recorrncias de diviso-
e-conquista tem suas
origens rastreadas em
um artigo de Bentley,
Haken e Saxe. O
algoritmo de diviso-
e-conquista para a
multiplicao de inteiros
grandes em tempo O
(n
1,59
) normalmente
atribudo aos russos
Karatsuba e Ofman. O
algortimo conhecido
como assintoticamente
mais rpido para
multiplicar dois nmeros
de n dgitos executa em
tempo O (n log n log log
n).
2. Defnir 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.
Multiplicao de Diversas Matrizes
Seja A
1
A
2
...A
n
uma sequncia de n matrizes que devem ser
multiplicadas. H diversas formas de se obter o resultado desejado. Para
maior clareza, apresentamos um exemplo:
Seja A1 uma matriz 13x5, A
2
5x89, A
3
89x3 e A
4
3x34. Para obter
M=((A
1
A
2
)A
3
)A
4
), calculamos sucessivamente
A
1
A
2
- 5785 produtos
(A
1
A
2
)A
3
- 3471 produtos
((A
1
A
2
)A
3
)A
4
) - 1326 produtos
para um total de 10582 produtos escalares. H 5 maneiras diferentes
de se multiplicar essas matrizes e obter o mesmo resultado fnal:
((AB)C)D - 10582
(AB)(CD) 54201
(A(BC)D) - 2856
A((BC)D) - 4055
A(B(CD)) 26418
O modo mais efciente cerca de 19 vezes mais rpido que o menos
efciente.
Os problemas consistem em determinar a forma mais efciente de
parentizao usando um algoritmo adequado.
Para obter a melhor maneira de calcular o produto, podemos usar
o algoritmo da fora bruta e verifcar todas as possveis formas. Seja T(n) o
nmero de modos de parentizao diferentes em um produto de n matrizes.
Fazendo um corte entre a i-sima e a (i+1)-sima matrizes do produto, ento:
M = (M
1
M
2
...M
i
)(M
i+1
M
i+2
...M
n
)
Agora, h T(i) maneiras de parentizar o termo do lado esquerdo e
T(n-i) maneiras de parentizar o termo do lado direito. H T(i)T(n-i) maneiras
de parentizar T(n), e i pode assumir valores de 1 a n-1, o que nos d a
UNIDADE 3 72
seguinte recorrncia:

A condio inicial T(1)=1. A partir da podemos levantar os seguintes
valores:
Os valores de T(n) so chamados nmeros de Catalo. T(n) (4n/
n2) o que pode ser verifcado provando que

e que

No entanto, um algoritmo (4
n
/n
2
) impraticvel para valores n
grandes.
Uma abordagem seria o uso de algoritmos gulosos. No entanto, dentre
os algoritmos gulosos bvios, no permitir a obteno de soluo tima.
Tentaremos verifcar se o princpio de otimizao pode ser empregado
e assim a programao dinmica resolver tal problema.
Passo 1: A estrutura de um parentizao tima
O primeiro passo do paradigma da programao dinmica
caracterizar a estrutura de uma soluo tima. Adotaremos a notao A
i..j

para a matriz que resulta da avaliao do produto A
i
A
i+1
...A
j
.
Para obter a soluo do problema proposto, devemos obter A
1..n
, que
pode ser obtido pelo produto de A
1..k
A
k+1..n
cujo custo timo obtido pela soma
do custo de A
1..k
com A
k+1..n
mais o custo do produto delas. A subcadeia A1..k
deve ter parentizao tima, do contrrio poderamos substitu-la por outra
com custo menor que o timo, o que uma contradio.
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.
Passo 2: Uma soluo tima recursiva
Deve-se defnir uma expresso recursiva para a soluo tima em
funo das subinstncias.
Ser usada uma tabela m
ij
1 i j n para armazenar a soluo
tima para M
i
.M
i+1
. O valor m[i,i]=0, pois Ai..i = Ai, no havendo necessidade
de qualquer clculo.
Para i<j, podemos usar a estrutura tima delineada no passo 1. Assim
Ai..j pode ser dividido em duas partes A
i..k
A
k+1..j
, i k < j, e m[i,j] igual ao
menor custo para calcular A
i..k
e A
k+1..j
mais o custo para multiplicar essas duas
matrizes. O custo para multiplicar A
i..k
A
k+1..j
vale p
i-1
p
k
p
j
O valor m[i,j] d o custo timo, mas no informaes para a construo
de uma soluo tima.
Para facilitar a indicao de uma parentizao tima, basta armazenar
na matriz s[i,j] o valor de k usado para o valor timo de m[i,j], ou seja
m[i,j]=m[i,k]+m[k,j] + p
i-1
p
k
p
j
.
Passo 3: Determinando a Soluo tima
Usando a programao dinmica, passamos a ter (n2) subproblemas
(basta observar que m[i,j] armazena os valores timos desses subproblemas),
bem superior ao algoritmo de fora bruta que exponencial.
Neste ponto deve-se elaborar um algoritmo para resoluo do
problema, fazendo os clculos de tal forma que nenhuma soluo seja
requisitada antes que a mesma j tenha sido calculada.
Fazendo um exemplo, pode-se perceber que o problema deve ser
resolvido em ordem crescente de comprimento da cadeia de matrizes, o que
equivale a percorrer as diagonais superiores da matriz de custo, a partir da
diagonal maior.
UNIDADE 3 74
1 proc Parentizar_Cadeia_Matriz(p:vetor[0..n];s:vetor[1..n,1..n])
2 {p armazena as dimenses das n matrizes }
3 para i:=1 at n, faa:
4 m[i,i]:=0;
5 para d:=2 at n, faa:
6 para i:=1 at n-d+1, faa:
7 j:=i+d-1;
8 m[i,j ]: = min
i k< j
{ m[i,k] + m[ k,j] + p[i1]p[k]p[j] }
9 s[i,j]:= k , tq m[i,j] = m[i,k]+m[k,j]+p[i-1]p[k]p[j]
O algoritmo computa, inicialmente, m[i,i] 0, para i=1,2,...,n (custo
mnimo para cadeias de comprimento 1). Ento, usa a recorrncia para calcular
m[i,i+1], para i=1,2,...,n-1 ( custo mnimo para cadeias de comprimento d=2) e
assim por diante at d=n. Em cada passo, o custo m[i,j] depende apenas dos
valores m[i,k] e m[k+1,j] que j foram calculados.
A complexidade do algoritmo pode ser determinada, observando que
h dois laos (linhas 5 e 6) executando O(n
2
) vezes as linhas 7 e 8. A linha
8 tem complexidade O(n) no pior caso, o que conduz a uma complexidade
O(n
3
) para o algoritmo todo.
Passo 4: Construindo uma soluo tima
O algoritmo apresentado determina o nmero timo de multiplicaes
escalares para calcular o produto de uma cadeia de matrizes, mas no mostra
diretamente como multiplicar as matrizes. O passo 4 constri uma soluo
tima a partir da informao obtida. A tabela s[1..n,1..n] determina a melhor
forma de multiplicar as matrizes atravs do valor k usado na melhor partio
da cadeia. O seguinte algoritmo recursivo calcula o produto da cadeia de
matrizes de forma tima:

A chamada inicial deve ser Produto_Cadeia_Matrizes(A,s,1,n).
O Problema de Caminho Mnimo
Utiliza-se algoritmo que faz uso de tcnicas de programao dinmica,
denominado algoritmo de Dijkstra, para determinao de caminho mnimo
de um n para todos os demais ns de um grafo orientado com arestas
Desafo:
Dado um conjunto P
de n times de futebol,
projete um algoritmo
para organizar um
torneio round-robin, em
que cada time joga com
cada um dos outros
exatamente uma vez,
assumindo que n uma
potncia de 2.
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 fgura, 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
armazenar as distncias e supor que os ns do grafo so representados por
nmeros inteiros.
Para formular o problema como problema de programao dinmica,
vamos imaginar o que acontece quando voc joga uma pedra em um lago,
forma-se uma onda circular que vai aumentando de raio at atingir uma
distncia sufcientemente grande. No nosso problema, vamos aplicar o
conceito da onda procurando primeiro um caminho de um n u para um n v
usando apenas uma aresta, depois procurar caminhos que possam melhorar
os existentes usando 2 arestas, e assim por diante, at n-1 arestas.
O algoritmo proposto poderia ser:
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],
Saiba Mais
A tcnica de
programao dinmica
foi desenvolvida
pela comunidade de
pesquisa operacional e
formalizada por Richard
Bellman. A soluo para
o produto de matrizes
encadeadas descritas
atribuda a Godbole. O
mtodo assintoticamente
mais rpido atribudo a
Hu e Shing.
UNIDADE 3 76
ALGORITMOS GULOSOS
Introduo
uma famlia de algoritmos muito utilizada para resolver problemas
de otimizao. Como o nome sugere a estratgia usada por esses algoritmos
consiste na escolha da melhor soluo em determinado instante. Isto , ele
faz uma escolha tima localmente esperando que esta escolha leve a uma
soluo tima global. Por vezes conduz a uma soluo tima, mas nem
sempre isso ocorre. Esta seo explora problemas de otimizao que so
solucionveis por algoritmos gulosos.
So fceis de implementar e quando trabalham bem, so efcientes.
O Problema do Troco
Suponha que vivemos em um pas onde as seguintes moedas so
usadas: sonho (100 centavos), 25 centavos, 10 centavos, 5 centavos e 1
centavo. Nosso problema consiste em pagar troco com a menor quantidade
de moedas.
Para pagarmos $2,89, a soluo tima consiste em dar 2 sonhos, 3
moedas de 25 centavos, 1 moeda de 10 centavos e 4 de 1 centavo, totalizando
10 moedas.
Para resolvermos esse problema, adotaremos a estratgia gulosa de
usar a maior moeda disponvel que no ultrapasse o troco a ser pago. O
algoritmo pode ser formalizado como abaixo:
1 funo troco(n):conjunto de moedas
2 constante C={100,25,10,5,1}
3 S<- {S o conjunto soluo }
4 s<- 0 { s a soma dos itens em S}
5 enquanto s<n, faa:
6 x<-o maior item em C, tal que s+x n
7 Se no h tal item, ento: retornar no h soluo
8 S<- S {Moeda[x]}
9 s<- s + x
10 retornar S
Para o conjunto de moedas do exemplo, considerado um suprimento
ilimitado de cada tipo a ser obtido. Para outros valores, principalmente quando
h valores mltiplos, o algoritmo no obtm soluo tima.
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 ou lista de candidatas
A soluo conter somente elementos desse conjunto. No caso do
troco, as candidatas so os tipos de moedas.

Conjunto Soluo
Armazena as candidatas selecionadas para fazer parte da soluo.
Normalmente, h outro conjunto com as candidatas rejeitadas.
Soluo vlida
uma funo que verifca se o conjunto soluo corrente prov uma
soluo para nosso problema, independente de ser timo ou no. Para o
problema do troco, essa funo verifca que o valor das moedas do conjunto
soluo no ultrapassa o valor a ser pago.
Funo viabilidade
Verifca se um conjunto soluo parcial ou no vivel. Essa funo
permite verifcar se a adio de candidatas conduz a alguma soluo do nosso
problema. Esta funo verifca se um dado conjunto soluo est ou no
vivel. No caso do troco, verifca se a soma no ultrapassa o valor do troco.
Diferente da funo "soluo vlida" que verifca que a soluo atinge todas
as restries do problema, que no caso do troco deve totalizar exatamente o
valor do troco.
Funo seleo
Indicam quais das candidatas restantes mais promissora. Esta
funo implementa a estratgia gulosa e tem por objetivo atingir a otimizao.
Funo objetivo
UNIDADE 3 78
Determina o valor de uma soluo encontrada. No caso do troco, a
funo objetivo determina o nmero de moedas utilizadas.
1 funo guloso(C: conjunto):conjunto
2 *{C o conjunto de candidatas}
3 S
4 enquanto C e no Soluo(S, faa:
5 x Seleciona(C)
6 C C \ {x}
7 se vivel (S {x}) ento S S {x}
8 se Soluo(S), ento: retornar S
9 seno, retornar No h soluo
A denominao guloso se deve ao fato de que em cada passo, o
procedimento escolhe a melhor fatia que ele pode comer, sem se preocupar
com o futuro. Ele jamais faz uma troca: uma vez que um candidato foi includo
na soluo, jamais retirado.
Problema da rvore Geradora Mnima

Seja G=(V,E) um grafo conexo, no orientado, onde V o conjunto
de ns e E o conjunto de arestas. Cada aresta tem um comprimento no
negativo associado, representado por uma funo Comp: E -> R
+
.
O problema achar um subconjunto T de arestas de G, tal que todos
os ns permaneam conectados usando apenas as arestas de T e a soma dos
comprimentos dessas arestas a menor possvel. Dadas duas solues com
soma dos comprimentos iguais, usaremos a soluo com o menor nmero
de arestas.
Qual o menor nmero de arestas que deve haver em T tal que o grafo
parcial G seja conexo ?
Resposta: n-1 arestas, cada aresta adicional acrescenta pelo menos
um ciclo.
O grafo G chamado rvore geradora mnima do grafo G.
1. Claramente, o nosso conjunto de candidatas o conjunto E de
arestas de G.
2. A funo soluo vlida verifca se a adio de uma aresta ao
conjunto soluo no introduz algum ciclo.
Desafo:
Fornea um exemplo de
um conjunto de moedas
que faa o algoritmo
guloso de fazer troco
no usar o nmero
mnimo de moedas.
3. A funo viabilidade verifca 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
O algoritmo de Kruskal inicia com um conjunto T de arestas vazio e
n conjuntos disjuntos, cada um com um n do grafo G=(V,E). O conjunto de
Arestas E ordenado em ordem crescente dos pesos. A cada iterao, a
aresta de menor peso candidata, sendo aceita apenas se seus ns extremos
no pertencerem ao mesmo conjunto. Caso a aresta estivesse unindo pontos
do mesmo conjunto estaria formando ciclo. Observe que cada componente
de T (cada conjunto disjunto) forma uma rvore. O algoritmo encerra quando
restar apenas um componente (um conjunto), ou seja, quando n-1 arestas
forem adicionadas.
O algoritmo de Kruskal ser apresentado a seguir.
1 funo Kruskal(G=(V,E): grafo; Comprimento: E -> R+): conjunto de
arestas { inicializao }
2 Ordenar E por ordem crescente do comprimento
3 n |V|
4 T { arestas da rvore geradora mnima }
5 Inicializar n conjuntos, cada um com um n de V
6 {lao guloso}
7 repita
8 e {u,v}// a menor aresta no considerada
9 ucomp Achar(u)
10 vcomp Achar(v)
11 Se ucomp vcomp ento
12 Juntar (ucomp,vcomp)
13 T T {e}
14 at |T| = n-1
15 retornar T
Exemplo:

UNIDADE 3 80
Figura 2 : Um grafo e sua rvore geradora mnima
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}
O algoritmo encerra com T={{1,2}, {2,3}, {4,5}, {6,7}, {1,4} e {4,7}} e
comprimento mnimo total igual a 17.
A complexidade do algoritmo pode ser analisada:
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).
Problema do Caminho Mnimo
Considere agora um grafo orientado G=(V,E), onde V o conjunto
de vrtices e E o conjunto de arcos. Cada arco tem um comprimento no
negativo. Um dos ns designado n fonte. O problema determinar o
comprimento do caminho mnimo do n fonte para cada um dos demais ns
do grafo.
Este problema pode ser resolvido pelo algoritmo guloso de Dijkstra.
Esse algoritmo usa um conjunto C que contm inicialmente todos os ns do
grafo e um conjunto S onde esto os ns selecionados pelo algoritmo, cuja
distncia para o n fonte mnima.
Os ns do conjunto C possuem distncia para o n fonte passvel de
melhora. Os conjuntos S e C so disjuntos e V = S C.
1 Algoritmo de Dijkstra
2 {retorna um vetor com a distncia mnima do n fonte a todos os
demais ns}
3 funo Dijkstra(fonte:vertice;G:Grafo;L:E-> R+):vetor[1..n]
4 vetor Dist[1..n] de inteiro
5 {inicializao}
6 CV
7 S
8 para u V faa Dist[u]
9 Dist[fonte] 0
10 {lao guloso}
11 enquanto C , faa:
12 u Min{Dist[u ]}
u C
13 C C \ {u}
14 S S {u}
UNIDADE 3 82
15 para w Adj(u), faa:
16 Dist[w] Min{Dist[w] , Dist[u] + L(u,w)}
17 retornar Dist
Exemplo:
Observe que o algoritmo s calcula a distncia, mas no determina o
caminho mnimo. Como modifc-lo para determinar o caminho mnimo?
Soluo:
Usar um vetor pred [2..n] para armazenar os predecessores dos ns.
Inicializar Pred da seguinte forma:
Pred[i] 0, i V
Adicionar ao lao interno
D[w] D[u] + L(u,w)
Se D[w] > D[u] + L(u,w) ento
P[w] u
Teorema:
Se o algoritmo de Dijkstra for executado sobre um grafo orientado
com as arestas ponderadas com pesos no-negativos e dado um vrtice
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
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).

1
p
UNIDADE 3 84
Desde que o algoritmo faz isto explicitamente, ele assegura a parte b) da
induo que tambm permanece vlida quando um novo n u adicionado
a S.
Para completar a prova de que o algoritmo est correto, observe que
quando o algoritmo para, todos os ns esto em S e o caminho mnimo do
n s para os demais ns um caminho especial. Quando Dist[x]= ento o
caminho (s,x) no existe.
Anlise do algoritmo:
Considere que a lista de prioridades C implementada com o uso de
lista sequencial. Assim a construo ser O(n), a alterao O(1) e remoo
O(n).
A inicializao do algoritmo como um todo requer O(n) passos.
A determinao do n de menor distncia requer O(n) operaes,
executadas n vezes, sendo O(n
2
).
A atualizao da distncia (lao interno) executada, no pior caso, m
vezes, uma para cada aresta, sendo O(m).
Logo, a complexidade do algoritmo O(m+n
2
), o que pode ser limitado
superiormente por O(n
2
).
importante ressaltar que o balanceamento de atividades ao longo
do algoritmo ajuda muito a reduzir a complexidade do mesmo, isto ,
melhor usar uma estrutura de dados que requer mais operaes em um
trecho aliviado do algoritmo, mas que reduza a carga em outro trecho mais
carregado.
Problema da Mochila
Dada uma mochila com capacidade para transportar no mximo W kg
e uma lista de n itens a serem transportados. O i-simo elemento da lista tem
peso wi e valor vi. Selecionar a carga a ser transportado de tal forma que o
valor transportado seja o maior possvel.
A modelagem como problema de programao matemtica pode ser
feita da seguinte forma:
Variveis de deciso:
x
i
= 1, caso o i-simo item seja alocado
x
i
= 0 , caso contrrio
Problema de Programao Matemtica (P.P.M.)

funo objetivo valor transportado
Sujeito a
,
, x
i
{0,1} - restrio referente capacidade da mochila
Este problema chamado problema da mochila 0-1 por no permitir o
uso de fraes de cada item, mas uma escolha binria (sim ou no).
Um algoritmo guloso deve usar como estratgia gulosa a seleo
dos itens com maior razo v
i
/w
i
. Apresentaremos um exemplo para aplicar tal
heurstica.
Se mochila tivesse capacidade W=50, qual seria a soluo dada pela
heurstica gulosa?
Pegaria os objetos 1 e 2, cujos valores totalizam $160. No entanto,
se pegssemos os itens 2 e 3 teramos valor total de $220. Observe que o
algoritmo guloso no fornece uma soluo tima.
O problema da mochila fracionrio pode ser modelado da mesma
forma, permitindo o uso de itens fracionados, ou seja, 0x
i
1, i=1,...,n. Para
o exemplo dado, a seleo gulosa proposta daria como soluo X=(1,1,2/3),
dando o valor da funo objetivo 1*60 + 1*100 + (2/3)*120 = 60+100+80=
$240.
Ser que o algoritmo guloso resolve este problema de forma tima?
Teorema: O algoritmo guloso resolve o problema da mochila fracionrio
de forma tima.
Prova:
=
=
n
i
i i
v x Minx
1
0
W v x
n
i
i i

=1
UNIDADE 3 86
Sem perda de generalidade, supondo que os itens estejam ordenados
pela ordem no crescente da razo v
i
/w
i
. Por contradio, supondo que seja
possvel retirarmos uma quantidade q do item i da soluo fornecida pelo
algoritmo guloso e substituirmos pela mesma quantidade q do item j de forma
tal que o valor a ser transportado seja maior. O valor transportado obtido pelo
algoritmo guloso vale:
Com a retirada de uma quantidade q de um elemento i da soluo e a
colocao da mesma quantidade de um elemento j, o valor a ser transportado
passa a ser:
A hiptese de x
0
>x
0
, de onde se conclui que x
0
- x
0
> 0, e assim,
o que uma contradio.
Logo, o algoritmo guloso sempre acha uma soluo tima para o
problema da mochila fracionrio.
Complexidade do Problema da Mochila Fracionrio:
Para resolver o problema da mochila fracionrio, uma abordagem
consiste em ordenar os valores v
i
/w
i
, o que exige O(nlogn) passos, onde m
o nmero total e elementos.
Resumindo, os passos para o projeto de algoritmos gulosos so:
1. Formule o problema como um problema de otimizao (P.P.M.), no
qual uma escolha feita, restando-nos ento resolver um nico subproblema
a resolver.
2. Provar que existe sempre uma soluo tima do problema que
atende escolha gulosa, ou seja, a escolha feita pelo algoritmo guloso e
segura.
3. Demonstrar que, uma vez feita a escolha gulosa, o que resta a
=
=
n
i i
i
i
w
v
x x
1
0
j
j
i
i
'
v
w
q
v
w
q
x x + - =
0 0
i
i
j
j
j
j
i
i
w
v
w
v
w
v
w
v
q > >
+ 0
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 modifcada possivelmente apos vrios passos at
que ela inclua o(s) elemento(s) identifcado(s) pela escolha gulosa.
Cdigo de Huffman
Esta uma estratgia efciente para a compresso de dados, muito
utilizada em sistemas para internet, que utiliza uma tabela das frequncias de
ocorrncia dos caracteres para elaborar um modo timo de representar cada
caractere como uma cadeia binria.
As redues no tamanho dos arquivos dependem das caractersticas
dos dados contidos nos mesmos. Em geral, os valores tpicos oscilam entre
20% e 90%.
Exemplo: arquivo texto contendo 100.000 caracteres no alfabeto e =
{a; b; c; d; e; f}. As frequncias de cada caractere no arquivo so indicadas
na tabela abaixo.
A codifcao do arquivo consiste em representar cada caractere por
uma sequncia de bits.
Exemplo: Para armazenar compactamente um arquivo de dados com
100.000 caracteres
Observando a tabela que representa cada caractere por cdigos, qual
o tamanho (em bits) do arquivo comprimido usando os cdigos acima?
Por um cdigo de tamanho fxo (3 bits) : 3 x 100.000 = 300.000
Por um cdigo de tamanho varivel:
Saiba Mais
O termo algoritmo
guloso foi criado por
Jack Edmonds em 1971,
embora o conceito
j existisse desde a
segunda grande guerra
mundial.
UNIDADE 3 88
45 x 1 + 13 x 3 + 12 x 3 + 16 x 3 + 9 x 4 + 5 x 4
=
224.000 bits
Cdigos Livres de Prefxo
Cdigos livres de prefxo so aqueles dados dois caracteres quaisquer
i e j representados pela codifcao, a sequncia de bits associada a i no
um prefxo da sequncia associada a j. So cdigos nos quais nenhuma
palavra de cdigo tambm um prefxo de alguma outra palavra de cdigo.
Pode-se provar que sempre existe uma soluo tima do problema da
codifcao que dado por um cdigo livre de prefxo.
O processo de codifcao, ou seja, de gerao do arquivo comprimido
sempre fcil, pois se reduz a concatenar os cdigos dos caracteres
presentes no arquivo original em sequncia.
Por exemplo, usando a codifcao de tamanho varivel do exemplo
anterior, o arquivo original dado por "abc" seria codifcado por 0101100.
A vantagem dos cdigos livres de prefxo se torna evidente quando
vamos decodifcar o arquivo comprimido.
Como nenhuma palavra de cdigo um prefxo de qualquer outra, a
palavra de cdigo que inicia um arquivo codifcado no apresenta ambiguidade.
Pode-se simplesmente identifcar este cdigo inicial, traduzi-lo de volta
ao caractere original e repetir o processo no restante do arquivo comprimido.
Exemplo: usando a codifcao de tamanho varivel do exemplo
anterior, o arquivo comprimido contendo os bits 001011101 divide-se de
forma unvoca em 0 0 101 1101, ou seja, corresponde ao arquivo original
dado por aabe.
O processo de decodifcao precisa de uma representao
conveniente para o cdigo de prefxo, de forma que a palavra de cdigo inicial
possa ser extrada com facilidade. A soluo para isso utilizar rvore binria
Se C o alfabeto do qual os caracteres so obtidos e todas as
frequncias de caracteres so positivas, ento a rvore para um cdigo de
prefxo timo tem exatamente |C| folhas, uma para cada letra do alfabeto e
exatamente |C|1 ns internos. Dada uma rvore T, para cada caractere c no
alfabeto C, seja f(c) a frequncia de c no arquivo e seja dT(c) a profundidade
da folha de c na rvore (ou o comprimento da palavra cdigo). O nmero de
bits exigidos para codifcar um arquivo (ou custo da rvore) :
O flho esquerdo est associado ao bit 1 enquanto o flho direito
fca associado ao bit 0. Nas folhas encontram-se os caracteres presentes no
arquivo original.
rvore de Tamanho fxo:
rvore de Tamanho varivel:
( )

C c
T
c d c f = T B ) ( ) (
UNIDADE 3 90
Huffman criou um algoritmo guloso que produz um cdigo de prefxo
timo chamado cdigo de Huffman.
No pseudocdigo, C um conjunto de n caracteres e cada caractere
c C um objeto com uma frequncia defnida f [c].
O algoritmo constri de baixo para cima a rvore T correspondente
ao cdigo timo.
Comea com um conjunto de |C| folhas e executa uma sequncia
de |C|1 operaes de intercalao para criar a rvore fnal. Uma fla de
prioridade mnima Q, tendo f como chave, usada para identifcar os dois
objetos menos frequentes a serem intercalados. O resultado da intercalao
um novo objeto cuja frequncia a soma das frequncias dos 2 objetos que
foram intercalados.
1 Huffman (C)
Entrada: conjunto de caracteres C e as frequncias f dos caracteres
em C
Sada: raiz de uma rvore binria representando uma codifcao
tima livre de prefxos
2 n |C|
3 Q C # Q a fla de prioridades dada pelas frequncias dos
vrtices ainda no intercalados
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
A seguir, mostraremos como funciona o algoritmo para as frequncias
dadas na tabela inicial. Cada passo mostra o contedo da fla classifcada
crescentemente de acordo com a frequncia. A cada passo, duas rvores
com menores frequncias so unidas. Os ns folhas so exibidos com
retngulos contendo um caractere e sua frequncia. Ns internos so
exibidos com crculos contendo a soma das frequncias dos ns flhos. Como
tratado anteriormente, rotula-se com 0 o conector ao conectar um n pai com
seu flho esquerdo e 1 ao seu flho direito. O cdigo para um caractere a
sequncia de rtulos da raiz at chegar ao caractere.
Passo 1
Passo 2
Passo 3

UNIDADE 3 92
Passo 4

Passo 5

Passo 6 a rvore fnal
Fazendo a Anlise do Algoritmo, temos que os custos so:
5. Construir Heap O(n)
6. (n 1) iteraes, cada uma com 3.O(log n)
Portanto, o algoritmo executa em tempo O(n log n)
Exerccio 1

1. O Professor Chiquinho elaborou um algoritmo para realizar o merge de
k listas ordenadas, cada uma com n/k elementos. O algoritmo pega a
primeira lista e realiza o merge com a segunda lista, fazendo uso de um
algoritmo de tempo linear para fazer o merge de duas listas ordenadas
como o algoritmo de merge do MergeSort. Ento, um merge feito com
a lista resultante de 2n/k elementos e a terceira lista, um novo merge
com a lista resultante de 3n/k elementos e a quarta lista, e assim
sucessivamente, at conseguir uma nica lista ordenada com todos os
n elementos. Faa uma anlise de pior caso do tempo de execuo do
algoritmo do Professor Chiquinho. Apresente o resultado em termos de
n e k.
UNIDADE 3 94
2. Representar o polinmio p(n)=a
0
+a
1
n+a
2
n
2
+...+a
d
n
d
de grau d por um
vetor P[0,...,d] contendo seus coefcientes. Supondo que voc tenha um
algoritmo capaz de multiplicar um polinmio de grau k por um polinmio
de grau 1 em tempo O(k), bem como um outro algoritmo capaz de
multiplicar dois polinmios de grau k em tempo O(k.logk). Sugira um
algoritmo efciente baseado na tcnica dividir-e-conquistar que encontre
o nico polinmio p(n) de grau d cujo coefciente do termo de maior grau
1, tal que p(n
1
)= p(n
2
)= ... =p(n
d
) = 0, para n
1
, n
2
e n
d
inteiros. Analise a
efcincia do algoritmo sugerido.
3. Considere n pontos distribudos ao longo do eixo dos x. O objetivo
encontrar os dois pontos com menor distncia mtua.
a) Escreva um algoritmo baseado na estratgia dividir-e-conquistar que
resolva o problema. Indique a complexidade do algoritmo.
b) Se utilizarmos fora bruta, qual a complexidade desta soluo?
4. Dados n pontos no plano de coordenadas cartesianas, sugerir um
algoritmo capaz de achar o par de pontos mais prximos em O(n.logn)
passos no pior caso.
5. Considere um array A de nmeros reais. Escreva um algoritmo O(n.log n)
que encontre um par de elementos (x, y) de A, em que |x + y| seja mnimo.
6. Um switch um circuito com duas entradas, um controle e duas sadas.
A entrada A sair na sada correspondente; A e B sair na sada B ou
A sair em B e B sair em A, dependendo da posio do controle. Use
estes switches para construir uma rede com n entradas e n sadas tal
que qualquer das n! das entradas seja possvel na sada. O nmero de
switches deve ser O(n.logn).
7. Um problema que est relacionado com o problema de ordenao o de
encontrar o k-simo menor elemento de uma lista no ordenada.
a) Escreva um algoritmo que encontre o k-simo menor elemento. Esse
algoritmo deve ser (n) na mdia e no melhor caso.
b) Argumente que seu algoritmo est correto.
c) Efetue a anlise de complexidade de sua soluo para melhor caso, pior
caso e caso mdio.
8. Dados os pontos P
1
(x
1
,y
1
,h
1
) e P
2
(x
2
,y
2
,h
2
), onde x
i
,y
i
so as coordenadas
no plano e hi a altura do ponto. Considerando que tais pontos esto sobre
um terreno real e que ao terreno foi associada uma matriz InfoTerreno[0..
max,0..max] com cada clula representando uma clula de terreno
de dimenses kxk em metros e cada clula da matriz armazena os
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=foresta, 4=urbano, 5=estrada. As coordenadas
dos pontos P
1
e P
2
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 foresta 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 x
1
, x
2
, ..., x
n
, 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 x
1
, x
2
, ..., x
n
. 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 efciente para
a soluo computacional.
Exerccio 2
1. Determinar uma parentizao tima para o produto de matrizes cuja
sequncia de dimenses [5,10,3,12,5,50,6]
UNIDADE 3 96
2. Elaborar um algoritmo que imprima a parentizao tima de uma cadeia
de matrizes usando a matriz s fornecida pelo algoritmo Parentizar_
Cadeia_Matriz(p:vetor[0..n]).
3. Mostrar que uma parentizao completa de uma expresso com n
elementos tem exatamente n-1 pares de parnteses.
4. Seja T(n) um nmero de Catalo, propor um algoritmo efcaz para avaliar
5. Aplicar o algoritmo de caminho mnimo apresentado ao seguinte grafo G
representado pela sua matriz de distncias.
6. Voc dispe de um container com capacidade para W toneladas e dispe
de diversas mercadorias a serem transportadas. Cada mercadoria
caracterizada por seu peso e valor. Aplicar a tcnica de programao
dinmica para conceber um algoritmo para alocao tima de mercadorias
de forma a maximizar o valor transportado. dado como entrada uma
matriz de mercadorias e a capacidade do container. Implementar o
algoritmo e resolver o problema abaixo.
W = 15 ton
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
fm 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.
8. O Secretrio de Segurana do Estado do Piau constatou que o nmero de
crimes em uma determinada localidade depende do nmero de patrulhas
alocadas, segundo a tabela abaixo:
UNIDADE 3 98
O secretrio conta com 8 viaturas. Use a programao dinmica para
determinar a alocao de patrulhas que minimize o total de crimes.
9. Um investidor tem 6 unidades monetrias (digamos 6 mil reais para serem
investidos em lotes de 1 mil reais) para investir em um negcio de risco.
O capital ganho numa etapa tambm pode ser investido. Um determinado
investimento oferece as seguintes possibilidades.
Dobrar o valor investido 30%
Manter mesmo valor 40%
Perder o valor investido 30%
1. Qual o maior ganho possvel para os prximos quatro anos?
2. Qual a probabilidade de conseguir este ganho?
3. Qual a estratgia adotada se quiser maximizar a probabilidade acumulada
de conservarmos no mnimo 25 unidades (25 mil reais) ao fm de quatro anos?
10. Seja B1,..., Bn um conjunto de n caixas todas com um mesmo peso p e
tais que a caixa Bi tem um custo Ci.
a) Escreva um algoritmo que dado um valor K, determina um subconjunto de
caixas cujo peso menor ou igual a K e tal que o custo total mximo.
b) Determine a complexidade de pior caso do seu algoritmo, considerando o
nmero de vezes que cada caixa analisada.
c) Mostre que o seu algoritmo est correto, isto , que nenhum outro
subconjunto de caixas com peso total menor ou igual a K possui um custo
total maior do que o custo total do subconjunto obtido pelo seu algoritmo.
Exerccio 3

1. O mtodo guloso sempre fornece uma soluo tima? Justifque a sua
resposta atravs de um exemplo.
2. Sobre mtodos gulosos:
a) Apresente sua defnio.
b) Quais as suas vantagens?
c) Quais as suas desvantagens?
3. Para o problema do troco, suponha que as moedas disponveis so c
0
,
c
1
,..., c
k
, para inteiros c>1 e k>1. Mostrar que o algoritmo guloso sempre
leva a uma soluo tima.
4. Suponha que temos um conjunto de m atividades a serem alocadas a um
grande nmero de locais. Deseja-se alocar todas as atividades usando
o menor nmero possvel de locais. Cada atividade possui um tempo
inicial e um tempo fnal. 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 efciente, 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.
7. Dados seis DVD+Rs, cada um com capacidade de armazenamento de
10GB, necessitamos armazenar seis arquivos de tamanhos 5GB, 6GB,
3GB, 7GB, 5GB e 4GB nestes DVD+Rs. O problema encontrar o nmero
mnimo de DVD+Rs necessrios para armazenar todos estes arquivos.
Considere que os arquivos no podem ser particionados.
a) possvel obter uma soluo exata para este problema? Caso positivo,
descreva a sua soluo.
b) possvel obter uma soluo exata para este problema utilizando um
algoritmo de efcincia polinomial? Explique a sua resposta.
c) Utilizando a estratgia fora bruta, projete um algoritmo para determinar
o nmero mnimo de DVD+Rs necessrios para armazenar todos estes
arquivos. Apresente o pseudocdigo ou a descrio dos passos, utilizando
linguagem natural.
d) Qual o menor nmero de DVD+Rs encontrado pelo seu algoritmo para
armazenar os seis arquivos?
UNIDADE 3 100
e) possvel utilizar a estratgia dividir-e-conquistar para resolver este
problema? Justifque sua resposta.
8. O professor Joo est planejando uma viagem entre as cidades A e B. Ele
dispe da distncia total entre as duas cidades, a localizao de todos os
postos de abastecimento ao longo do trajeto e a autonomia do veculo. O
professor deseja fazer o menor nmero possvel de paradas. Descrever
uma estratgia efciente para determinar em quais postos parar e provar
que sua estratgia conduz a uma soluo tima.
9. Modifcar o algoritmo de Dijkstra implementando a lista de prioridade com
o uso de heap. Determinar a complexidade desse algoritmo. melhor
do que o algoritmo apresentado?
10. Modifcar o algoritmo de Dijkstra implementando a lista de prioridade com
o uso de lista encadeada ordenada. Determinar a complexidade desse
algoritmo. melhor do que o algoritmo apresentado?
11. Mostrar como resolver o problema da mochila em tempo O(n), onde n o
nmero de itens disponveis.
12. O problema conhecido como task-scheduling para um processador tem
como entrada as duraes das tarefas t1, t2,...,tn. Programar a ordem das
tarefas tal que o tempo mdio gasto por cada uma delas no sistema seja
mnimo. Propor um algoritmo guloso que resolva o problema e provar sua
otimizao usando matrides. Qual a complexidade do algoritmo?
13. Seja o problema para achar um subconjunto T de arestas de um grafo
conexo G, tal que todos os ns permaneam conexos quando somente
as arestas de T so usadas e a soma das arestas a menor possvel.
Imagine a possibilidade de haver arestas com comprimentos negativos. A
soluo pode no ser uma rvore.
14. Considere um arquivo texto onde encontramos apenas os seguintes
caracteres: a(25), b(12), c(4), d(4), e(7), i(30), z(18). Entre parnteses
est indicada a frequncia de ocorrncia de cada caractere. Aplicar a
estratgia de Huffman para a compresso de arquivos. Qual seria o fator
de compresso neste caso?
UNIDADE 4
Classes de Problemas
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).
Resumindo
CLASSES DE PROBLEMAS
INTRODUO
"Alguns problemas computacionais so difceis. Tentamos
e tentamos
encontrar algoritmos efcientes para resolv-los, mas
falhamos
repetidamente. Seria bom se pudssemos provar que
impossvel
encontrar um algoritmo efciente nestes casos. Tal prova
seria til,
pois poderamos nos tranquilizar sabendo que um
algoritmo
desse tipo no pode ser achado.
Goodrich, Michael T., Tamassia, Roberto
H alguns problemas computacionais que so difceis de serem
resolvidos ou que impossvel se provar que no existe soluo efciente.
Vimos a convenincia de se utilizar medidas de complexidade como
medida de efcincia. Aprendemos que um algoritmo efciente quando a
sua complexidade for polinomial em relao ao tamanho de sua entrada. Um
algoritmo dito ser de tempo polinomial se for O(nk), para alguma constante
k > 0. Qualquer outro algoritmo que no for polinomial exponencial.
Contudo, essa classifcao no absoluta. Algumas vezes pode ser
apenas satisfatria, mas, na maioria dos casos, aceitvel.
Solucionabilidade de Problemas
Problemas Resolvveis e No Resolvveis
UNIDADE 4 104
De uma maneira geral, os problemas podem ser divididos em
Resolvveis e No Resolvveis:
Resolvveis - H pelo menos um algoritmo que o descreve e o resolve.
No Resolvveis - No h um algoritmo para resolv-los. So tambm
chamados de Problemas Halting, ou seja, problemas onde: Sejam dados
um programa qualquer e um conjunto de entradas vlidas e genricas. O
programa ir terminar?
Problemas Tratveis e Intratveis
Problemas Tratveis
So todos os tipos de problemas da natureza que podem ser resolvidos
em tempo hbil, independentemente do tamanho da entrada. Nestes casos,
compensa investir em melhorias nas velocidades de processamento do
hardware ou at mesmo em reprojetar processos, como por exemplo, uma
implementao do algoritmo timo por meio de processamento paralelo ou
distribudo, para que seja possvel a obteno de respostas em tempo mais
breve, uma vez que o tempo de resposta dos algoritmos timos dos problemas
tratveis previsivelmente de natureza igual ou abaixo complexidade
polinomial. Entre os exemplos, podemos destacar:
1. Problemas de Ordenao;
2. Soma, multiplicao, produto, diviso, MDC, MMC e exponenciao
em aritmtica ilimitada;
3. Problemas de Atribuio;
4. Problema de Filas de Prioridade;
5. Problemas de seleo em estruturas ordenadas;
Problemas Resolvveis, mas Intratveis
So todos os tipos de problemas da natureza que podem ser
resolvidos, porm no em tempo hbil. A solucionabilidade desses problemas
necessita de um grande poder de computao ainda no desenvolvido, o
que torna invivel a sua tratabilidade. Como exemplos, temos o Problema do
Caixeiro Viajante, Problema do Ciclo Hamiltoniano, o Problema de encontrar
subconjuntos mutuamente disjuntos de um conjunto, dadas condies de
formao (Restries), o Problema de encontrar o melhor preenchimento de
uma mochila, sabendo que ela tem um limite de peso para carregar itens de
valor, dentre muitos itens existentes de valor conhecido, etc.
Problemas Intratveis e Indecidveis
Esta classe de problemas extrema, em termos de complexidade,
uma vez que estes no tm nenhuma garantia sobre sua programabilidade,
ou at mesmo, se um algoritmo existe para trat-lo de alguma forma, tal
algoritmo no h prova dele ser timo a menos que P=NP, o que ser visto
mais adiante.
Sendo assim, nem sempre possvel afrmar que a soluo
tima desejada possvel de ser obtida, uma vez que no existe mtodo
generalista que a encontre para toda instncia. Como exemplos, pode-se
citar: o problema do Nmero Cromtico; o problema de Steiner Euclidiano;
o problema de Empacotamento de Vrtices (Vertex Packing), etc. Tais
problemas aproximam-se queles do tipo Halting, porm, no so Halting.
Formas de Problemas
Para melhor abordar a questo da complexidade de problemas e o
enquadramento dos mesmos nas classes P e NP, conveniente classifc-los
nas seguintes categorias:
1. Problemas de deciso;
2. Problemas de localizao;
3. Problemas de otimizao.
Problemas de Deciso
Os problemas de deciso so problemas cuja soluo corresponde
a responder sim ou no ao que foi formulado. Por exemplo, dado um grafo
G(V,E), orientado e ponderado nas arestas, dois vrtices u, v V e um inteiro
no negativo k. Existe um caminho em G entre u e v com comprimento menor
ou igual a k? Ento, dada a instncia I=<G,u,v,k>, a resposta ser sim se
houver tal caminho; ou no, caso contrrio.
UNIDADE 4 106
Problemas de Localizao
Os problemas de localizao so aqueles nos quais o objetivo
encontrar, caso exista, determinada estrutura satisfazendo requisitos
especifcados por uma questo. No caso do problema de caminho, dado o
grafo G(V,E) ponderado nas arestas, os vrtices u, v e um nmero inteiro k.
O problema formulado consiste em localizar, caso exista, um caminho com
comprimento menor ou igual a k. A resposta seria exibir uma sequncia de
vrtices u, ....,v.
Problemas de Otimizao
Os problemas de otimizao so os que tm por objetivo encontrar
uma determinada estrutura satisfazendo critrio timo predefnido. Para
problema do caminho, um critrio timo poderia ser o caminho de menor
comprimento possvel.
Apesar da classifcao, tais classes apresentam um ntimo
relacionamento entre si. O problema de deciso parece ser bem mais fcil que
os de localizao e otimizao, o que no totalmente verdadeiro. Podemos
afrmar que o problema de deciso apresenta difculdade no maior que a
do problema de localizao, e este, por sua vez, apresentam difculdade no
maior que a do problema de otimizao correspondente. H casos em que os
Problemas de Localizao e Otimizao so to difceis quanto o Problema
de Deciso respectivo.
Sendo o problema de deciso normalmente mais fcil e pelo fato do
tamanho da sada do mesmo ser constante, sim ou no, torna-o padro para
anlise de intratabilidade de problemas.
Problemas de Deciso da Classe P
Estudaremos agora a classe de problemas que possuem soluo em
tempo polinomial e so tambm chamados de tratveis. Cumpre ressaltar
que um problema que requer tempo (n
100
) intratvel, bem como qualquer
problema que exige tempo polinomial com grau muito elevado.
Podemos afrmar que um problema tratvel, caso ele possa ser
solucionado em um tempo oportuno para o fm a que se destina.
Outro aspecto a considerar que muitos problemas que podem ser
resolvidos em tempo polinomial em um modelo computacional pode ser
resolvido em tempo polinomial em outro modelo.
Defnio - Classe P
P a classe de problemas de deciso que podem ser resolvidos por
um algoritmo de tempo polinomial.
A classe de problemas polinomiais tem propriedades de fechamento
em relao adio, multiplicao e composio. Assim, um algoritmo
polinomial que gera entradas para outro algoritmo polinomial forma um
algoritmo composto tambm polinomial.
O problema de caminho apresentado no pargrafo anterior um caso
tpico de problema da classe P.
Observe que dado um problema para o qual no se conhece algoritmo
polinomial no signifca, necessariamente, que tal problema no pertena
classe P. Para tal afrmao, deve ser exibida uma prova formal de que todo
algoritmo possvel para resolver tal problema no polinomial.
Apresentaremos, a seguir, dois problemas para os quais no se
conhece algoritmo exato e tempo polinomial:
Problema de Satisfabilidade (Satisfability Problem - SAT)
Dada uma expresso lgica E(x1,x2,...,xn) na forma normal conjuntiva,
isto , constituda de uma conjuno de clusulas, cada uma delas constituda
de uma disjuno de literais.
Exemplo:
onde x
1
,x
2
,x
3
so variveis lgicas denominadas literais e as
expresses entre parnteses so as clusulas.
O problema da Satisfabilidade consiste em determinar se a expresso
verdadeira para uma data atribuio das variveis lgicas. Dado x
1
=V, x
2
=F,
x
3
=F, a resposta exige o teste de cada uma das clusulas o que conduz
resposta F. No problema dado, a expresso ser verdadeira quando x
1
= x
2

= x
3
=F.
Desafo:
Suponha que um
orculo deu a voc um
computador mgico C
que recebe qualquer
frmula booleana B
em FNC (forma normal
conjuntiva) e responde
uma etapa se B pode ser
satisfeita ou no. Mostre
como usar C para
construir uma atribuio
de valores booleanos
que satisfaam qualquer
frmula booleana B que
possa ser satisfeita.
Quantas chamadas voc
precisa fazer a C para
fazer isso, no pior caso?
UNIDADE 4 108
Problema do Ciclo Hamiltoniano
Dado um grafo G=(V,E), onde V um conjunto de vrtices e E um
conjunto de pares (u,v) tal que u,v V, denominados arestas. O grafo G dito
no orientado, pois (u,v) = (v,u) denotam uma s aresta. O conjunto V tem n
vrtices e o conjunto E tem m arestas.
Um ciclo hamiltoniano consiste em um caminho fechado v
1
,v
2
,...,v
n
,v
1

e o problema de deciso correspondente pode ser formalizado da seguinte
forma:
Entrada: Grafo G
Questo: G possui um Ciclo Hamiltoniano?
At o momento, no se conhece um algoritmo polinomial que resolva
este problema.
Classe NP
Algoritmos de Verifcao
Consideramos um problema bem mais fcil. Dados um grafo G
hamiltoniano e uma sequncia de vrtices C, provar que C forma um ciclo
hamiltoniano. Todos concordam que um problema bem mais fcil e para
resolv-lo basta percorrer cada um dos vrtices, na ordem, verifcando a
existncia de arestas. Este algoritmo de verifcao pode ser implementado
em O(n
2
), onde n o nmero de vrtices.
Um algoritmo de verifcao um algoritmo A com 2 argumentos onde
um argumento uma cadeia x de entrada e o outro argumento uma cadeia
binria y denominado certifcado. O algoritmo A verifca a entrada x para obter
um certifcado y, tal que A(x,y)=1. Intuitivamente, um algoritmo A verifca uma
linguagem L em busca de um certifcado y para a entrada x L. Entretanto,
para alguma entrada x L e no deve haver certifcado provando que x L.
No caso do Problema Ciclo Hamiltoniano(PCH), o certifcado uma lista de
vrtices do ciclo hamiltoniano.
Defnio da Classe NP
A classe de problemas NP a classe de linguagens que podem ser
verifcadas por um algoritmo de tempo polinomial.. Uma linguagem L pertence
a NP se e somente se existe um algoritmo A que verifque um certifcado em
tempo polinomial.
Ento, podemos concluir que o Problema do Ciclo Hamiltoniano
pertence a NP.
Relao entre P e NP
O que falar de P em relao a NP?
Pela defnio da classe NP, podemos afrmar que se L P, ento,
L NP. A justifcativa imediata, pois se L pode ser resolvido em tempo
polinomial, a verifcao tambm ser em tempo polinomial.
A classe Co-NP
Reduo Linear
Determinar a complexidade exata de um dado problema no uma
tarefa fcil na prtica. Uma soluo consiste em comparar a difculdade
relativa de diferentes problemas. Dizemos que um problema reduz a outro
se podemos transformar efcientemente instncias do primeiro problema em
instncias do segundo problema, tal que, resolvendo o segundo problema,
estaremos resolvendo o primeiro.
Sejam os problemas de multiplicao e quadrado (um nmero elevado
ao quadrado) de grandes nmeros inteiros. J estudamos uma forma de
resolver o problema de multiplicao de inteiros grandes com um algoritmo
O(n
1,59
), que bem melhor em relao ao algoritmo tradicional quadrtico.
Podemos fazer tal clculo com menor complexidade? Achar um algoritmo
melhor funo do desenvolvedor de algoritmos; provar que um algoritmo
UNIDADE 4 110
timo do escopo da complexidade. No entanto, no se conhece limites
inferiores para a multiplicao e para o quadrado.
Multiplicar dois nmeros requer (n), pois uma entrada com n dgitos
exige que cada digito seja verifcado. Procura-se um algoritmo ainda no
conhecido que processe a multiplicao em tempo O(n).
Considerando agora o problema quadrado, ele parece ser mais
simples do que a multiplicao.
Como resolver o problema quadrado usando multiplicao?
x
2
= x.x
Desta forma, estamos reduzindo o problema quadrado ao problema
multiplicao.
Como resolver o problema multiplicao usando quadrado?
x.y = ((x+y)
2
-(x-y)
2
)/4
Desta forma, estamos reduzindo o problema multiplicao ao
problema quadrado.
Quando um problema X redutvel a um problema Y e este redutvel
ao problema X, dizemos que X e Y so computacionalmente equivalentes, ou
seja, a difculdade para resolver X e Y de mesma ordem. Para formalizar a
transformao, basta exibir os algoritmos:
funo quadrado(x)
retornar multiplicar(x,x)
funo multiplicar(x,y)
retornar ((quadrado(x+y) - quadrado(x-y))/4)
Defnio: Sejam A e B dois problemas. Diz-se que A linearmente
redutvel a B, denotado por A l B, se a existncia de um algoritmo para B
que trabalha em um tempo O(t(n)) para uma funo arbitrria t(n) implica que
existe um algoritmo para A que tambm trabalha em um tempo O(t(n)).
Quando A l B e B l A, diz-se que A e B so linearmente equivalentes
e se escreve Al B.
A Classe NP-Completo
H um grande nmero de problemas do mundo real para os quais
no se conhece algoritmos computacionais efcientes para resolv-los e
cuja difculdade intrnseca ainda no foi provada. No entanto, h diversos
problemas, tais como Caixeiro Viajante, Nmero Cromtico em grafos,
Problema da Mochila, Ciclo Hamiltoniano, SAT, Programao Inteira para os
quais h provas formais da difculdade 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 verifc-la. Esta
intuio pode conduzir conjectura de que P NP o que at hoje no
foi possvel verifcar. 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, defnida a seguir.
Defnio: Um problema de deciso X NP-completo se,
i) X NP, e
ii) Y
p
t
X, para todo problema Y NP.
Pela defnio, 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 defnio acima, caso tenhamos um problema X NP-
completo e um problema Z da classe NP, se X
p
t
Z, o que pode-se afrmar ?
Pode-se afrmar 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
p
t
Z. Ento, Z tambm pertence a
NP-completo.
Prova:
Para z ser NP-Completo deve satisfazer as duas condies da
defnio 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
p
t
X. Pela hiptese X
p
t
Z.
Agora, dado um novo problema Z, como provar que ele pertence
a NP-Completo? Aplicando a defnio de NP-Completo, primeiro deve-se
provar que Z pertence a NP, conforme a defnio anterior. A seguir, deve-se
provar que todos os problemas da classe NP so redutveis a Z. Como provar
isto?
UNIDADE 4 112
Este teorema um mecanismo de grande valia para provar que um
novo problema Z pertence classe NP-Completo. Basta provar que Z pertence
a NP e escolher um problema X conveniente do conjunto de problemas NP-
Completo conhecido e mostrar que X Turing polinomialmente redutvel a Z.
Os seis problemas NP-completo bsicos so:
1. 3-SATISFATIBILIDADE (3-SAT);
2. 3-Matching Dimensional (3-DM);
3. Cobertura de Vrtices (VC);
4. Clique;
5. Circuito Hamiltoniano(HC);
6. Partio
As redues obtidas:
1. SAT -> 3-SAT
2. 3-SAT -> 3-DM e 3-SAT -> VC
3. 3-DM -> Partio
4. VC -> HC e VC -> Clique
Algumas Redues
Teorema: 3-SAT NP-completo
Prova:
fcil de ver que 3-SAT pertence a NP, pois dada uma expresso
com clusulas de 3 literais cada, a verifcao de uma atribuio feita em
tempo polinomial.
Para transformar SAT em 3-SAT, seja U={u
1
,u
2
,...,u
n
} um conjunto
de variveis e C={c
1
,c
2
...,cm} um conjunto de clusulas construindo uma
instncia arbitrria de SAT.
Construiremos um conjunto C de clusulas com 3 literais sobre um
conjunto U de variveis, tal que C satisfaz se, e somente se, C conseguir
satisfazer.
Conjuntos Independentes
Cada literal de cada clusula representa um vrtice. Ligam-se os
vrtices referentes mesma clusula e ligam-se os vrtices que representam
Saiba Mais
O primeiro problema
NP-Completo foi o
problema SAT pela
prova apresentada por
Stephen Cook em 1971.
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:

A Classe NP-Difcil
Defnio: Um problema de deciso X NP-Difcil se
i) Y
p
t
X, para todo problema Y NP.
Conclui-se que um problema NP-Difcil pelo menos to difcil quanto
qualquer problema em NP.
Relaes entre Classes de Problemas
H basicamente quatro possibilidades de relacionamentos entre as
classes de problemas.
) ( ) ( ) ( ) (
5 4 3 5 3 2 4 2 1 3 2 1
x x x x x x x x x x x x
UNIDADE 4 114
A maioria dos pesquisadores considera a possibilidade (a) a mais
improvvel, ou seja, P = NP = co-NP.
Em (b), se NP fechado para complemento, ento NP=co-NP, mas
isso necessrio para o caso de no se ter P=NP. A regio em laranja
so os problemas P. Em (c), P=NP co-NP, mas NP no fechado para
complemento.
Por outro lado, boa parte dos pesquisadores considera a possibilidade
(d) como a mais provvel, onde NPco-NP e P NP co-NP. A regio em
bege representa os problemas P.
Backtracking e branch-and-bound
Backtracking
uma estratgia para sistematicamente determinar uma lista de
possveis solues, eliminando (explicitamente) a verifcao de uma boa
parte dos possveis candidatos. Pode ser considerado como uma variao de
busca em profundidade, pois utiliza uma rvore implcita.
O projeto com backtracking uma forma de construir algoritmos
para um problema difcil L. Esse algoritmo procura sistematicamente em um
grande (possivelmente exponencial) conjunto de possibilidades. A estratgia
de procura geralmente otimizada para evitar simetrias em instncias para
L e para percorrer o espao de busca de forma que seja encontrada uma
soluo fcil para L, se tal soluo existir.
A tcnica de backtracking tira a vantagem da estrutura inerente a
muitos problemas NP-completos. Lembre que a aceitao de uma instncia
x de um problema NP pode ser feita em polinomial, dado um certifcado de
tamanho polinomial. Frequentemente, esse certifcado consiste em uma srie
de escolhas tais como valores para variveis booleanas, um subconjunto de
vrtices de um grafo ou um conjunto de objetos para colocar em uma mochila.
De forma similar, a verifcao de um certifcado, frequentemente, envolve um
teste simples para verifcar se o certifcado fornece uma confgurao bem-
sucedida para x, tal como satisfazer uma frmula, cobrir todas as arestas de
um grafo ou estar de acordo com algum critrio de desempenho. Nesses casos
podemos usar um algoritmo de backtracking para procurar sistematicamente
pela soluo do problema, se esta soluo existir (GODRICH, TAMASSIA,
2004).
O algoritmo backtracking percorre os possveis caminhos de procura
para localizar solues ou pequenas sadas. A confgurao no fnal 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 confgurao (x,y) no conduz a uma soluo
vlida, no importando quantas escolhas adicionais sejam feitas, ento ele
evita todas as procuras a partir dessa confgurao 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 confguraes de
subproblemas}
5. enquanto F 0 faa
6. retire de F a confgurao (x,y) mais promissora
7. expanda (x,y) fazendo um pequeno conjunto de escolhas
adicionais
8. sejam (x
1
,y
1
),(x
2
,y
2
),...,(x
k
,y
k
) o conjunto de novas confguraes
9. para cada nova confgurao (x
i
,y
i
), faa:
10. verifque a consistncia de (x
i
,y
i
)
11. se a verifcao retornar soluo encontrada, ento:
12. retorne a soluo derivada de (x
i
,y
i
)
13. se a verifcao retornar sem sada, ento:
14. descarte a confgurao (x
i
,y
i
) {Backtrack}
15. seno
16. F F {(x
i
,y
i
)} {(x
i
,y
i
) inicia uma procura mais promissora}
17. retorne sem soluo
Resumindo, de uma maneira geral, a ideia para se resolver um
problema utilizando backtracking usando espao de soluo, onde as
solues so representadas por n-tuplas ou vetores de soluo <v
1
, v
2
, ...,
v
n
>, em que cada vi escolhido a partir de um conjunto fnito de opes Si.
Inicia-se com um vetor vazio, onde em cada etapa o vetor estendido
com um novo valor. O novo vetor , ento, avaliado, sendo que se no for
soluo parcial, o ltimo valor do vetor eliminado e outro candidato
UNIDADE 4 116
considerado.
As restries explcitas correspondem s regras que restringem cada
vi em tomar valores de um determinado conjunto. Est relacionado com a
representao do problema as escolhas possveis. J as restries implcitas
determinam como os vis se relacionam entre si.
Exemplos de Problemas:
Alguns exemplos de problemas onde se pode utilizar a tcnica de
backtracking.
Problema do Labirinto
Jogo da Troca de Bolas
O problema consiste em n bolas amarelas e n bolas azuis, com
tabuleiro (uma linha) com 2n + 1 posies, onde bolas com a mesma cor em
extremidades diferentes, e um espao vazio separando o conjunto de bolas
diferentes.
Os possveis movimentos so:
1. Bola azul para a esquerda e amarela para a direita;
2. Mover um espao se o espao est vazio;
3. Pular sobre exatamente uma bola de cor diferente, se o espao
logo aps a bola estiver vazio.
Alvo a atingir:
rvore com possibilidades e alvo:

Observa-se nesses problemas que:
1. Toma-se uma srie de decises entre vrias opes;
2. Cada deciso leva a um novo conjunto de decises;
3. Alguma(s) sequncia(s) de decises pode(m) conduzir a soluo
do problema;
4. Encontrar uma soluo consiste em:
1) Fazer uma lista com todos os candidatos possveis;
2) Examinar todas as respostas ou alguma delas;
3) Retornar a soluo.
Assim, se fossemos aplicar Fora bruta, na prtica, esta abordagem
no seria muito efciente, visto que a lista de candidatos grande.
Branch-and-bound
O algoritmo de backtracking efciente para problemas de deciso,
mas no foi planejado para problemas de otimizao, em que, alm de termos
UNIDADE 4 118
de satisfazer alguma condio de validade para um certifcado y, associado
a uma instncia x, tambm desejamos que uma dada funo f(x) seja
maximizada ou minimizada (sem perda da generalidade, vamos assumir que
a funo deve ser minimizada). Mesmo assim, podemos estender o algoritmo
backtracking para trabalhar com um problema de otimizao e, ao fazer isso,
obteremos o padro de algoritmos chamada de brach-and-bound.
O padro brach-and-bound dado pelo algoritmo seguinte tem todos
os elementos de backtracking, mas ele no termina simplesmente ao achar
a primeira soluo. Em vez disso, continuamos at a melhor soluo ser
encontrada. Alm disso, o algoritmo tem um mecanismo de pontuao para
escolher sempre a confgurao mais promissora a ser explorada em cada
iterao. Devido a essa abordagem, brach-and-bound chamado por vezes
de estratgia de busca best-frst (GODRICH, TAMASSIA, 2004).
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 confguraes}
5. b{(+,0)} {custo e confgurao da melhor soluo conhecida}
6. enquanto F0, faa:
7. retire de F a confgurao (x,y) mais promissora
8. expanda (x,y) obtendo um conjunto (x
1
,y
1
),..., (x
k
,y
k
) de
confguraes adicionais
9. para cada nova confgurao (x
i
,y
i
), faa:
10. verifque a consistncia de (x
i
,y
i
)
11. se a verifcao retornar soluo encontrada, ento:
12. se o custo c da soluo para (x
i
,Y
i
) for melhor que b, ento:
13. b<- (c, (x
i
,y
i
))
14. seno,
i
,y
i
)
16. se a verifcao retornar sem sada, ento:
i
,y
i
) {Backtrack}
18. seno,
19. se min b(x
i
,y
i
) o menor custo de b, ento:
20. F F {(x
i
,y
i
)} {(x
i
,y
i
) inicia um novo caminho promissor}
21. seno,
i
,y
i
) {o valor alto demais e j no
interessa}
23. retorne b
Para fornecer um critrio de otimizao e poder escolher a confgurao
mais promissora, adicionamos mais uma hiptese s trs hipteses usadas
para um algoritmo de backtracking:
Para qualquer confgurao (x,y), assumimos que temos uma funo
min b(xi, yi) que retorna um limite inferior para o custo de qualquer soluo
derivada desta confgurao.
A nica exigncia sobre min b(xi, yi) que ela seja menor ou igual
ao custo de qualquer soluo derivada. Como deve ser claro a partir do
algoritmo de branch-and-bound, quanto mais preciso for esse limite inferior,
mais efciente ser o algoritmo.
Exerccio 1

1. Julgue as seguintes assertivas com verdadeiro (V) ou falso (F), justifque
ou d contraexemplos:
( ) Existem problemas na classe NP que no esto na classe NP-completo.
( ) A classe NP-completo contm todos os problemas NP-difceis.
( ) Se houver uma soluo polinomial para o problema SAT, ento P = NP.
( ) NP-completo a classe dos problemas computacionais para os quais
no existe um algoritmo polinomial.
( ) Assim como os problemas P so problemas polinomiais, os NP so os
problemas no polinomiais.
( ) Se um problema A, de custo polinomial, redutvel polinomialmente a
outro B, ento B tambm ter custo polinomial.
( ) Se um problema A, NP-difcil, redutvel a outro B, ento B tambm
ser NP- difcil.
( ) Se um problema NP-difcil redutvel polinomialmente a outro NP,
ento eles so polinomialmente equivalentes. Neste caso, ambos so NP-
completo.
( ) Se dois problemas NP-difcil so polinomialmente equivalentes, ento
ambos so NP-completo ou ambos no o so.
( ) Se um problema NP-difcil reduz-se polinomialmente a um P, ento P =
UNIDADE 4 120
NP, e todos os problemas NP-completo faro parte do conjunto P tambm.
( ) As solues dos problemas NP so implementveis, havendo
vrias tcnicas para isso, como algoritmo exponencial, probabilstico e de
aproximao.
2. Mostrar que se NP um problema, ento uma resposta SIM ou NO
para pode ser obtida em tempo exponencial com o tamanho de sua
entrada.
3. Prove que a seguinte afrmativa verdadeira: Se o complemento de um
problema NP-Completo est em NP, ento NP = CoNP
4. Pesquise como o Problema do Ciclo Hamiltoniano pode ser reduzido ao
Problema de Deciso do Caixeiro Viajante.
5. Um array booleano M[1..n,1..n] representa um labirinto quadrado.
Estando em um determinado ponto do labirinto possvel se movimentar
para pontos adjacentes na mesma linha ou mesma coluna. Se M[i,j]
True, possvel passar pelo ponto (i,j); se M[i,j] False, no possvel
passar pelo ponto (i,j). possvel usar uma soluo por backtracking
que encontra um caminho, se existir, do ponto (1,1) para o ponto (n,n).
Abaixo encontramos um exemplo de um labirinto 5x5. Defna restries
implcitas e explcitas para a sua soluo de backtracking e monte a
rvore de espao de estados, indicando a soluo.
AZEREDO, Paulo A. Mtodos de classifcao 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.
BERG, M.; KREVELD, M. V.; OVERMARS, M.; SCHWARZKOPF, O.
Computational Geometry, Algorithms and Applications. 2nd edition,
Springer, 2000.
BOAVENTURA, P. O. Grafos: Teoria, Modelos, Algoritmos. Blucher: Ed.
Edgard, 1996.
BRASSARD, G., BRATLEY, P. Algorithmics: Theory and Practice. Prentice-
Hall.
CAMPELLO, R.E. & MACULAN, N. Algoritmos Heursticos: desenvolvimento
e avaliao de perfomance. Rio de Janeiro: Ed. EDUFF, 1994.
CORMEN, T. H.; LEISERSON, C. E.; RIVEST, R. L.; STEIN, C. Algoritmos:
Teoria e Prtica, Ed. Campus. Rio de Janeiro, 2002.
DIESTEL, R. Graph Theory. Ed. Springer, 1997.
FUIRTADO, A. L. , Teoria dos Grafos: Algoritmos. Ed. LTC, 1973.
GAREY Michael R. and JOHNSON David S. Computers and Intractability -
A Guide to the Theory of NP-Completeness.
GERSTING, Judith L. Fundamentos matemticos para a Cincia da
computao. Rio de Janeiro, LTC, 1995.
GOODRICH, M. T. & TAMASSIA, R. , Projeto de Algoritmos: Fundamentos,
anlise e exemplos da internet, Ed. Bookman. Porto Alegre, 2004.
GOULD, R. , Graph Theory. The Benjamim/Cummings Publishing Company,
1988.
GRAHAM, Ronald L. Knuth, DONALD, E. Patashnik, Oren. Matemtica
concreta: fundamentos para a cincia da computao. Rio de Janeiro,
LTC, 1995.
KLEINBERG, J. Kleinberg, TARDOS, E. Algorithm Design. Addison Wesley,
2005.
KNUTH, D. E.; GRAHAM, L. R.; PATASHNIK, O. Concrete Mathematics - A
Foundation for Computer Science. Addison-Wesley, 1989.
LEVTIN, A. Introduction to the design and analysis of algorithms. Addison-
Wesley, 2003.
LEWIS, Harry R. and PAPADIMITRIOU, Christos H. Elementos de Teoria da
Computao.
MANBER, U. Introduction to Algorithms: a creative approach. Addison-
Wesley, 1988.
MIYAZAWA, F. K. Notas de Aula de Complexidade de Algoritmos. Relatrio
Tcnico, Unicamp, 1999.
RESENDE, P. J.; STOLFI, J. Fundamentos de geometria computacional.
IX Escola de Computao, 1994.
SZWARCFITER, J. L. Grafos e Algoritmos computacionais. Rio de Janeiro:
Campus, 1984.
______. Estruturas de Dados e seus Algoritmos. LTC Editora, 1994.
TERADA, R. Desenvolvimento de Algoritmos e Estrutura de Dados. So
Paulo: Makron Books, 1991.
TOSCANI, L.V. & VELOSO, P.A.S. Complexidade de Algoritmos. Porto
Alegre: Ed. Sagra Luzzatto, 2001.
WEST, D. Introduction to Graph Theory. Prentice Hall, 1996.
WILSON, R. J., Introduction to Graph Theory, Ed. AddisonWesley, 1996.
ZIVIANI, N. Projeto de Algoritmos com implementao em JAVA e C++.
So Paulo: Ed. Thomson, 2007.
______. Projeto de Algoritmos com implementao em PASCAL e C. So
Paulo: Ed. Thomson, 2005.
______. Projeto de Algoritmos com implementao em JAVA e C++. So
Paulo: Ed. Thomson. 2007.
WEB BIBLIOGRAFIA
Algorithms and Data Structures http://www.csse.monash.edu.au/~lloyd/
tildeAlgDS/
Algoritmos Animados em Java - http://gdias.artinova.pt/projecto/pt/menu_
applets.php
Algoritmos em grafos - http://www.ime.usp.br/~pf/algoritmos_em_grafos/
index.html
Algoritmos para grafos - http://www.ime.usp.br/~pf/algoritmos_para_grafos/
Anlise de algoritmos uma coletnea de textos - http://www.joinville.udesc.
br/portal/professores/gilmario/materiais/Analise_de_algoritmos__.pdf
Associao Brasileira de Educao a Distncia ABED - www.abed.org.br
Dictionary of Algorithms and Data Structures - http://www.itl.nist.gov/div897/
sqg/dads/
Graph Theory Tutorials - http://www.utm.edu/departments/math/graph/
Graphviz - http://www.graphviz.org/
Open Problems Graph Theory and Combinatorics, de Douglas West: - http://
www.math.uiuc.edu/~west/openp/
Projeto de Algoritmos - http://www.dcc.ufmg.br/algoritmos/
Secretaria de Educao a Distncia do MEC SEED - www.seed.mec.gov.br
Teoria dos Grafos - http://www.icmc.usp.br/manuals/sce183/grafos.html
Teoria dos Grafos - http://www.inf.ufsc.br/grafos/
Teoria dos Grafos, na Wikipdia: http://pt.wikipedia.org/wiki/Teoria_dos_
grafos
Uma Introduo Sucinta Teoria dos Grafos - http://www.ime.usp.br/~pf/
teoriadosgrafos/
Universidade Aberta do Brasil UAB - www.uab.gov.br
Universidade Aberta do Piau UAPI - www.ufpi.br/uapi
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
Unifcado 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 Criptografa, Anlise de Desempenho,
Processamento Paralelo, Sistemas Distribudos e Computao baseada em
Clusters e em Grades (Grid Computing).

Projeto e Análise de Algoritmos

Caricato da

Informazioni sul documento

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Projeto e Análise de Algoritmos

Caricato da

Copyright:

Formati disponibili

Universidade Federal do Piau

Centro de Educao Aberta e a Distncia

), onde = 1, podemos aplicar o caso 1 do

), onde = 0,2, aplica-se o caso 3, caso a condio de

Potrebbero piacerti anche