Você está na página 1de 258

Algoritmos e complexidade

Notas de aula

Marcus Ritt
Luciana S. Buriol
Edson Prestes

28 de Abril de 2010

Conteúdo

I Análise de algoritmos 5
1 Introdução e conceitos básicos 7
1.1 Notação assintótica . . . . . . . . . . . . . . . . . . . . . . . . . 19
1.2 Notas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
1.3 Exercı́cios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

2 Análise de complexidade 31
2.1 Introdução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
2.2 Complexidade pessimista . . . . . . . . . . . . . . . . . . . . . 35
2.2.1 Metodologia de análise de complexidade . . . . . . . . . 35
2.2.2 Exemplos . . . . . . . . . . . . . . . . . . . . . . . . . . 41
2.3 Complexidade média . . . . . . . . . . . . . . . . . . . . . . . . 48
2.4 Exercı́cios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63

II Projeto de algoritmos 69
3 Introdução 71

4 Algoritmos gulosos 73
4.1 Introdução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
4.2 Algoritmos em grafos . . . . . . . . . . . . . . . . . . . . . . . . 77
4.2.1 Árvores espalhadas mı́nimas . . . . . . . . . . . . . . . . 77
4.2.2 Caminhos mais curtos . . . . . . . . . . . . . . . . . . . 82
4.3 Algoritmos de seqüenciamento . . . . . . . . . . . . . . . . . . 83
4.4 Tópicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
4.5 Notas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
4.6 Exercı́cios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93

5 Programação dinâmica 95
5.1 Introdução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
5.2 Comparação de sequências . . . . . . . . . . . . . . . . . . . . . 99
5.2.1 Subsequência Comum Mais Longa . . . . . . . . . . . . 99

1

Conteúdo

5.2.2 Similaridade entre strings . . . . . . . . . . . . . . . . . 103
5.3 Problema da Mochila . . . . . . . . . . . . . . . . . . . . . . . . 107
5.4 Multiplicação de Cadeias de Matrizes . . . . . . . . . . . . . . . 109
5.5 Tópicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
5.5.1 Algoritmo de Floyd-Warshall . . . . . . . . . . . . . . . 113
5.5.2 Caixeiro viajante . . . . . . . . . . . . . . . . . . . . . . 115
5.5.3 Árvore de busca binária ótima . . . . . . . . . . . . . . 116
5.6 Exercı́cios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120

6 Divisão e conquista 121
6.1 Introdução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
6.2 Resolver recorrências . . . . . . . . . . . . . . . . . . . . . . . . 123
6.2.1 Método da substituição . . . . . . . . . . . . . . . . . . 124
6.2.2 Método da árvore de recursão . . . . . . . . . . . . . . . 128
6.2.3 Método Mestre . . . . . . . . . . . . . . . . . . . . . . . 131
6.2.4 Um novo método Mestre . . . . . . . . . . . . . . . . . . 136
6.3 Tópicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
6.4 Exercı́cios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139

7 Backtracking 141

8 Algoritmos de aproximação 155
8.1 Introdução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
8.2 Aproximações com randomização . . . . . . . . . . . . . . . . . 165
8.3 Aproximações gulosas . . . . . . . . . . . . . . . . . . . . . . . 166
8.4 Esquemas de aproximação . . . . . . . . . . . . . . . . . . . . . 173
8.5 Exercı́cios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175

III Teoria de complexidade 177
9 Do algoritmo ao problema 179
9.1 Introdução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179

10 Classes de complexidade 191
10.1 Definições básicas . . . . . . . . . . . . . . . . . . . . . . . . . . 191
10.2 Hierarquias básicas . . . . . . . . . . . . . . . . . . . . . . . . . 193
10.3 Exercı́cios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197

11 Teoria de NP-completude 199
11.1 Caracterizações e problemas em NP . . . . . . . . . . . . . . . 199

2

Conteúdo

11.2 Reduções . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201

12 Fora do NP 211
12.1 De P até PSPACE . . . . . . . . . . . . . . . . . . . . . . . . . . 214
12.2 De PSPACE até ELEMENTAR . . . . . . . . . . . . . . . . . . . 220
12.3 Exercı́cios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222

A Conceitos matemáticos 223
A.1 Funções comuns . . . . . . . . . . . . . . . . . . . . . . . . . . . 223
A.2 Somatório . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226
A.3 Indução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229
A.4 Limites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231
A.5 Probabilidade discreta . . . . . . . . . . . . . . . . . . . . . . . 231
A.6 Grafos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233

B Soluções dos exercı́cios 235

3

compilada em 28 de Abril de 2010. 4 . Versão 3271 do 2010-04-28.Conteúdo Essas notas servem como suplemento à material do livro “Complexidade de algoritmos” de Toscani/Veloso e o material didático da disciplina “Complexi- dade de algoritmos” da UFRGS.5 Brasil). A obra está licenciada sob uma Licença Creative Commons (Atribuição-Uso Não- Comercial-Não a obras derivadas 2.

Parte I Análise de algoritmos 5 .

.

são tão complicados. por exemplo um PC ou um Mac. e descobriram que todos são (polinomialmente) equivalen- tes em poder computacional. Exemplo 1. Kleene e Turing. têm o mesmo poder computacional. • Ela é pré-requisito para o projeto de algoritmos.1 Introdução e conceitos básicos A teoria da computação começou com a pergunta “Quais problemas são efeti- vamente computáveis?” e foi estudada por matemáticos como Post. e logo do nosso conhecimento da fı́sica. porque a resposta depende das possibi- lidades computacionais do nosso universo. a máquina de Turing e a máquina de RAM.1 Não existe um algoritmo que decide o seguinte: Dado um programa arbitrário (que podemos imaginar escrito em qualquer linguagem de programação como C ou Miranda) e as entradas desse programa. Nossa pergunta é mais especı́fica: “Quais problemas são eficientemente com- putáveis?”. mesmo sendo efetivamente computáveis. que a solução deles para instâncias do nosso interesse é impraticável. o estudo teórico do desempenho e uso de recursos. • Parte 2: As principais técnicas para projetar algoritmos. 7 .e. • Parte 1: Análise de algoritmos. Ele termina? Esse problema é conhecido como “problema de parada”. Essa pergunta é motivada pela observação de que alguns proble- mas que. as funções parcialmente recursivas. Church. A nossa intuição é que todos os computadores diferentes. Matemáticos inventaram vários modelos de computação. Mas não é possı́vel imaginar algum outro tipo de máquina que seja mais poderosa que essas? Cujos programas nem podem ser implementadas num PC ou Mac? Não é fácil responder essa pergunta. i. ♦ Visão geral • Nosso objetivo: Estudar a análise e o projeto de algoritmos. e são considerados como máquinas universais. entre eles o cálculo lambda.

manutenabilidade.. uso de espaço (cache. memória. custo de implementação. se forem concedidos tempo e memória sufici- entes para a sua execução. legibilidade. • Uma definição razoável é considerar algoritmos em tempo polinomial como eficiente (tese de Cobham-Edmonds). uma sequência finita de operações. para cada entrada. Motivação • Na teoria da computação perguntamos “Quais problemas são efetiva- mente computáveis?” • No projeto de algoritmos. Custos de algoritmos • Também temos que definir qual tipo de custo é de interesse. • Um algoritmo resolve um problema quando. • A complexidade pode ser vista como uma propriedade do problema Mesmo um problema sendo computável. corretude. • Uma execução tem vários custos associados: Tempo de execução. O problema Expressões regulares com ·2 8 . a pergunta é mais especı́fica: “Quais proble- mas são eficientemente computáveis?” • Para responder. não significa que existe um algoritmo que vale a pena aplicar. consumo de energia. pro- duz uma resposta correta. extensibilidade. • Existem caracterı́sticas e medidas que são importantes em contextos diferentes Linhas de código fonte (LOC). robustez. terminando com uma saı́da correspondente. • A medida mais importante e nosso foco: tempo de execução. para qualquer entrada. . temos que saber o que “eficiente” significa.....1 Introdução e conceitos básicos Introdução • Um algoritmo é um procedimento que consiste em um conjunto de regras não ambı́guas as quais especificam. disco).

01. . . 100. 110. A seguinte tabela contém alguns dados básicos: Idade 13. Instância Uma expressão regular e com operações ∪ (união). de fato. . Corolário 2.9 × 10−30 g/cm3 Número de átomos 1080 Número de bits 10120 Número de operações 10120 lógicas elementares até hoje Operações/s ≈ 2 × 10102 (Todos os dados correspondem ao consenso cientı́fico no momento. 1100. ·∗ (fecho de Kleene).ex.2 Com e = 0 ∪ 12 temos L(e) = {0. EXPSPACE-completo (Meyer and Stockmeyer. 1972. O universo do ponto da vista da ciência da computação Falando sobre os recursos. a decisão da validade na lógica monádica fraca de segunda ordem com sucessor). Fontes principais: (Wilkinson. 2002)) 9 . 000. 1000.5 × 1016 s Tamanho ≥ 78 × 109 anos-luz Densidade 9. ♦ Existem exemplos de outros problemas que são decidı́veis. Lloyd.}. Decisão L(e) 6= Σ∗ ? que parece razoavelmente simples é. 11.7 ± 0.1) (no momento é suficiente saber que isso sig- nifica que o tempo para resolver o problema cresce ao menos exponencialmente com o tamanho da entrada). é de interesse saber quantos recursos nosso universo disponibiliza aproximadamente.2 × 109 anos ≈ 43. 0000. 10. Exemplo 1. 1}. · (concatenação) e ·2 (quadratura) sobre o alfabeto Σ = {0. Com e = (0 ∪ 1)2 · 0∗ temos L(e) = {00. mas têm uma com- plexidade tão grande que praticamente todas instâncias precisam mais recur- sos que o universo possui (p. obviamente novos descobrimentos podem os mudar. 11}. 010. 0100.

Um método simples usa a fórmula de Leibniz   X Y det(A) = sgn(σ) ai.) Portanto. se o trabalho de calcular o determinante de uma matriz de tamanho n × n é Tn . Com det(Ui ) = xi e det(A) det(Ui ) = det(Ai ) temos o resultado. O método de Cramer nos fornece as equações det(Ai ) xi = det(A) seja Ai a matriz resultante da substituição de b pela i-gésima coluna de A. (A prova dessa fato é bastante simples. e nossos custos são √ (n + 1)(n!A + n!nM ) ≥ n!(A + M ) ≈ 2πn(n/e)n (A + M ) um número formidável! Mas talvez a fórmula de Leibniz não é o melhor jeito de calcular o determinante! Vamos tentar a fórmula de expansão de Laplace X det(A) = (−1)i+j aij det(Aij ) 1≤i≤n (sendo Aij a matriz A sem linha a i e sem a coluna j).1 Introdução e conceitos básicos Métodos para resolver um sistema de equações lineares Como resolver um sistema quadrático de equações lineares a11 x1 + a12 x2 + · · · + a1n xn = b1 a21 x1 + a22 x2 + · · · + a2n xn = b2 ··· an1 x1 + an2 x2 + · · · + ann xn = bn ou Ax = b? Podemos calcular a inversa da matriz A para chegar em x = bA−1 . Seja Ui a matriz identidade com a i-gésima coluna substituı́do por x: é simples verificar que AUi = Ai . essa abordagem custa (n+1)Tn . 10 .σ(i)  σ∈Sn 1≤i≤n mas ele precisa n! adições (A) e n!n multiplicações (M ). O trabalho Tn nesse caso é dado pelo recorrência Tn = n(A + M + Tn−1 ). T1 = 1 cuja solução é   X Tn = n! 1 + (A + M ) 1/i! 1 1≤i<n 1 n! P 1≤i<n 1/i! = bn!(e − 1)c.

. . o método de Gauss para resolver um sistema de equações lineares. . . . . P e como 1≤i<n 1/i! aproxima e temos n! ≤ Tn ≤ n!(1 + (A + M )e) e logo Tn novamente é mais que n!. . tivermos um algoritmo em tempo aproximadamente n3 .3 Para resolver      1 2 3 x1 2 4 5 7 x2  = 4 7 8 9 x3 6 vamos aplicar a eliminação de Gauss à matriz aumentada   1 2 3 2 4 5 7 4 7 8 9 6 obtendo     1 2 3 2 1 2 3 2 0 −3 −5 −4 . Mas qual é o método mais eficiente para calcular o determinante? Caso for possı́vel em tempo proporcional ao tamanho da entrada n2 . n do { elimina linha j } 4 f o r k := n. i do 5 ajk := ajk − aik aji /aii 6 end f o r 7 end f o r 8 end f o r Exemplo 1. . n do { elimina coluna i } 3 f o r j := i + 1. . . Algoritmo 1. 0 −3 −5 −4 0 −6 −12 −8 0 0 −2 0 e logo x3 = 0.1 (Eliminação de Gauss) Entrada Uma matriz A = (aij ) ∈ Rn×n Saı́da A em forma triangular superior. x1 = 1/2 é uma solução. 1 e l i m i n a ç ã o g a u s s ( a ∈ Rn×n )= 2 f o r i := 1. . x2 = 3/4. ♦ 11 . . Antes de resolver essa pergunta. vamos estudar uma abordagem diferente da pergunta original. o matriz é transformada em forma triangular e cada passo não precisa mais que n2 operações (nesse caso inclusive divisões). Em n passos.

Um deles é que o método de Gauss pode produzir resultados intermediários cuja repre- sentação precisa um número exponencial de bits em relação à entrada. • Usando um computador de 3 GHz que é capaz de executar um OPF por ciclo temos n Cramer Gauss 2 4 ns 2 ns 3 12 ns 8 ns 4 48 ns 20 ns 5 240ns 40 ns 10 7. Resultados atuais mos- tram que uma complexidade de operações de bits n3. Qual o melhor algoritmo? • Para um dado problema. existem diversos algoritmos com desempenhos diferentes. Portanto.3ms 330 ns 20 152 anos 2. • O método de Gauss precisa ≈ n3 − n OPF. o método é um dos melhores para calcular o determinante.2 log kAk1+o(1) é possı́vel (Kaltofen and Villard. o método de Gauss formal mente não tem complexidade O(n3 ). Observe que esse método também fornece o determinante do matriz: ela é o produto dos elementos na diagonal! De fato. 2004). • Queremos resolver um sistema de equações lineares de tamanho n.7 µs 2O resultado pode ser melhorado considerando que aji /aii não depende do k 3O estudo da complexidade do determinante tem muito mais aspectos interessantes. Observe também que ela não serve para melhorar o método de Cramer.1 Introdução e conceitos básicos Logo temos um algoritmo que determina a solução com X 3(n − i + 1)(n − i) = n3 − n 1≤i≤n operações de ponto flutuante. que é (exceto valores de n bem pequenos) con- sideravelmente melhor que os resultados com n! operações acima2 . • O método de Cramer precisa ≈ 6n! operações de ponto flutuante (OPF). porque a solução do problema original já vem junto3 . 12 .

um computador rápido não ajuda! • Suponha que uma máquina resolva um problema de tamanho N em um dado tempo.2N 2n N + log2 10 ≈ N + 3. ele é capaz de executar c vezes mais passos que a primeira. Em geral obtemos n0 = f −1 (cf (n)) (isso faz sentido para funções monotônicas.1 Exemplo 1.Motivação para algoritmos eficientes • Com um algoritmo ineficiente. Portanto. temos log2 n0 = 10 log2 n ⇐⇒ n0 = n10 . Por exemplo para f (n) = log2 n e c = 10 (exemplo acima).3 3n N + log3 10 ≈ N + 2. qual seria o tamanho de problema n0 que a nova máquina é capaz de resolver? Temos f (n0 ) = cf (n).2N n3 3 10N ≈ 2.4 Esse exemplo mostra como calcular os dados da tabela acima. • Qual tamanho de problema uma máquina 10 vezes mais rápida resolve no mesmo tempo? Número de operações Máquina rápida log2 n N 10 n 10N n log2 n 10N √ (N grande) n2 √ 10N ≈ 3. Ao mesmo tempo. ♦ Crescimento de funções 13 . Suponha um algoritmo que precisa f (n) passos de execução numa dada máquina e uma outra máquina que é c vezes mais rápida. que têm inversa).

7 × 106 2 × 107 n2 102 104 106 108 1010 1012 n3 103 106 109 1012 1015 1018 2n 103 1.6 × 102 104 1. .2 × 109 s 1 milênio ≈ 3.1 × 10301 2 × 103010 1030103 10301030 1 ano ≈ 365.2425d ≈ 3.3 × 105 1. memória..2 × 107 s 1 século ≈ 3.1 Introdução e conceitos básicos Crescimento de funções n= 101 102 103 104 105 106 log2 n 3 7 10 13 17 20 n 101 102 103 104 105 106 n log2 n 33 6. cache.2 × 1010 s Comparar eficiências • Como comparar eficiências? Uma medida concreta do tempo depende – do tipo da máquina usada (arquitetura.3 × 1030 1..) – da qualidade e das opções do compilador ou ambiente de execução – do tamanho do problema (da entrada) • Portanto. 14 . foram inventadas máquinas abstratas.

. e – os coeficientes constantes. Existem vários exemplos de algoritmos com desempe- nho bom assintoticamente.) em relação ao tamanho da entrada. denotado com O(n2 ). soma.. porque sempre é possı́vel enganar com um algoritmo que é rápido para alguma entrada. analisamos somente a taxa ou ordem de crescimento. Observe que essas simplificações não devem ser esquecidas na escolha de um algoritmo na prática. • Logo o tempo da execução tem cota n2 . Observe que nessa medida o tempo é “discreto”. • A análise da complexidade de um algoritmo consiste em determinar o número de operações básicas (atribuição. • Portanto. Análise assintótica • Em geral. comparação. 15 . Exemplo • Imagine um algoritmo com número de operações an2 + bn + c • Para análise assintótica não interessam – os termos de baixa ordem.. mas não são viáveis na prática em comparação com algoritmos “menos eficientes”: A taxa de crescimento esconde fatores constantes e o tamanho mı́nimo de problema tal que um algoritmo é mais rápido que um outro. • Duas medidas são de interesse particular: A complexidade – pessimista e – média Também podemos pensar em considerar a complexidade otimista (no caso melhor): mas essa medida faz pouco sentido. o número de operações fornece um nı́vel de detalhamento grande. substi- tuindo funções exatas com cotas mais simples.

Para n grande. não podemos esquecer o tamanho do problema real. • Mas na prática. • De fato. isso é verdadeiro. respectivamente. Qual deles é o mais eficiente ? • Considere dois programas A e B com tempos de execução 100n2 milise- gundos. Qual o tempo de execução de cada combinação para ordenar 106 elementos? 16 .e 5n3 milisegundos.5 Considerando dois algoritmos com tempo de execução O(n2 ) e O(n3 ) espera- mos que o primeiro seja mais eficiente que o segundo.6 Considere dois computadores C1 e C2 que executam 107 e 109 operações por segundo (OP/s) e dois algoritmos de ordenação A e B que necessitam 2n2 e 50n log10 n operações com entrada de tamanho n. respectivamente. mas o tempo de execução atual pode ser 100n2 no primeiro e 5n3 no segundo caso. Logo para n < 20 o segundo algoritmo é mais rápido. 100000 80000 60000 40000 20000 0 0 5 10 15 20 25 30 x n^2 n^3 Exemplo 1. respectivamente. ♦ Comparação de tempo de execução • Assintoticamente consideramos um algoritmo com complexidade O(n2 ) melhor que um algoritmo com O(n3 ). qual é o mais eficiente? Exemplo 1.1 Introdução e conceitos básicos Complexidade de algoritmos • Considere dois algoritmos A e B com tempo de execução O(n2 ) e O(n3 ). para n suficientemente grande O(n2 ) sempre é melhor.

Exemplo 1. de todas permutações de uma sequência. C1 Comp. etc): Rápido. Algoritmo Comp. • Tempo n log n: Comum em algoritmos de divisão e conquista. Observe que o al- goritmo não pode ler toda entrada.7 Exemplos de algoritmos para as complexidades acima: • Tempo constante: Determinar se uma sequência de números começa com 1. log(log(n)). • Tempo sublinear (log(n). ♦ 17 . n!. • Tempo linear: Número de operações proporcional à entrada. nn considerado intratável. • Tempo sublinear: Busca binária. • Tempo polinomial nk : Freqüentemente de baixa ordem (k ≤ 10). C2 2×(106 )2 OP 2×(106 )2 OP A 107 OP/s = 2 × 105 s 109 OP/s = 2 × 103 s 50(106 ) log 106 OP 50(106 ) log 106 OP B 107 OP/s = 30s 109 OP/s = 0. • Tempo exponencial: Busca exaustiva de todos subconjuntos de um con- junto. • Tempo linear: Buscar o máximo de uma sequência.3s ♦ Um panorama de tempo de execução • Tempo constante: O(1) (raro). • Tempo polinomial: Multiplicação de matrizes. • Tempo n log n: Mergesort. • Tempo exponencial: 2n . etc. consi- derado eficiente.

um caminho v1 . Decisão Existe um ciclo euleriano.8. i. Ciclo hamiltoniano Instância Um grafo não-direcionado G = (V. . • Vários problemas NP-completos são parecidos com problemas que têm algoritmos eficientes. • NP é outra classe importante que contém muitos problemas práticos (e a classe P). v2 . . Solução eficiente conhecida Solução eficiente improvável Ciclo euleriano Ciclo hamiltoniano Caminho mais curto Caminho mais longo Satisfatibilidade 2-CNF Satisfatibilidade 3-CNF Ciclo euleriano Instância Um grafo não-direcionado G = (V. i. 2005. Decisão Existe um ciclo hamiltanio. • Problemas NP-completos são os mais complexos do NP: Se um deles tem uma solução eficiente.1)) que um grafo conexo contém um ciclo euleriano sse cada nó tem grau par. toda classe tem. . vn tal que v1 = vn que usa todos arcos exatamente uma vez? Comentário Tem uma decisão em tempo linear usando o teorema de Eu- ler (veja por exemplo (Diestel. Teorema 1. . .e. E). vn tal que v1 = vn que usa todos nós exatamente uma única vez? 18 . E). . • Não se sabe se todos possuem algoritmo eficiente. . No caso de um grafo direcionado tem um teorema correspondente: um grafo fortemente conexo contém um ciclo euleriano sse cada nó tem o mesmo número de arcos entrantes e saintes.1 Introdução e conceitos básicos Problemas super-polinomiais? • Consideramos a classe P de problemas com solução em tempo polinomial tratável. . v2 . um caminho v1 .e.

que associa com todos entradas de um tamanho n um custo (médio. por- que os recursos de nosso interesse são positivos.máximo) c(n). Notação assintótica: O • Freqüentemente nosso interesse é o comportamento assintótico de uma função f (n) para n → ∞.1 Notação assintótica O análise de algoritmos considera principalmente recursos como tempo e espaço. A seguir. • O primeiro exemplo é a classe de funções que crescem menos ou igual que g(n) O(g(n)) = {f : N → R+ | (∃c > 0)∃n0 (∀n > n0 ) : f (n) ≤ cg(n)} A definição do O (e as outras definições em seguido) podem ser generalizadas para qualquer função com domı́nio R. Observe.1 Notação assintótica 1. que é suficiente trabalhar com funções positivas (com co-domı́nio R+ ). Analisando o comportamento de um algoritmo em termos do ta- manho da entrada significa achar uma função c : N → R+ . vamos introduzir classes de crescimento. supomos que todas funções são dessa forma. 1. Notação assintótica: O 19 . • Por isso.

p.4n2 = O(λn. O define uma cota assintótica superior a menos de constantes. O(n2 ) = 4n2 + 2n + 5 não é definido. digamos que g é uma cota assintótica superior de f (Toscani and Veloso.n2 ) 20 . 4 Um jeito mais correto (mas menos confortável) seria escrever λn.1 Introdução e conceitos básicos Notação assintótica • Com essas classes podemos escrever por exemplo 4n2 + 2n + 5 ∈ O(n2 ) • Outra notação comum que usa a identidade é 4n2 + 2n + 5 = O(n2 ) • Observe que essa notação é uma “equação sem volta” (inglês: one-way equation). Em outras palavras. para f = O(g) leiamos as vezes simplesmente “f é O de g”. não valores4 . as expressões 4n2 e n2 denotam funções. Para f ∈ O(g) leia: “f é do ordem de g”. 15). Observe que numa equação como 4n2 = O(n2 ). 2005. Caso f ∈ O(g) com constante c = 1.

. n0 = 1 n 2 n 10 n 6∈ O(n2 ) porque 10n n2 ≤ cn2n ⇐⇒ 5n n ≤ c n log2 n ∈ O(n log10 n) c = 4. 1.1 Para um polinômio p(n) = 0≤i≤m ai ni temos P |p(n)| ∈ O(nm ) (1. n0 = 2 3 32n ∈ O(n ) c = 32. n0 = 1 ♦ O: Exemplos Proposição 1.8 Mais exemplos n2 ∈ O(n3 log2 n) c = 1.1) Prova.1 Notação assintótica O: Exemplos 5n2 + n/2 ∈ O(n3 ) 5n2 + n/2 ∈ O(n2 ) sin(n) ∈ O(1) Exemplo 1.

.

.

.

.

X ai ni .

.

.

|p(n)| = .

.

.

0≤i≤m .

X ≤ |ai |ni Corolário A.1 0≤i≤m X X ≤ |ai |nm = nm |ai | 0≤i≤m 0≤i≤m  21 .

possuem uma definição de O diferente.2) • Funções que crescem mais ou igual à g(n) Ω(g(n)) = {f : N → R+ | (∃c > 0)∃n0 (∀n > n0 ) : f (n) ≥ cg(n)} (1. que é suficiente para a análise de algoritmos.3) • Funções que crescem (estritamente) mais que g(n) ω(g(n)) = {f : N → R+ | (∀c > 0)∃n0 (∀n > n0 ) : f (n) ≥ cg(n)} (1. Ω e ω são f (n) f (n) ∈ O(g(n)) ⇐⇒ lim sup <∞ (1.7) n→∞ g(n) f (n) f (n) ∈ Ω(g(n)) ⇐⇒ lim inf >0 (1. substituindo < para ≤ e > para ≥ (veja exercı́cio 1.4) • Funções que crescem igual à g(n) Θ(g(n)) = O(g(n)) ∩ Ω(g(n)) (1.1 Se o contexto permite.8) n→∞ g(n) f (n) f (n) ∈ ω(g(n)) ⇐⇒ lim =∞ (1.5) Observe que a nossa notação somente é definida “ao redor do ∞”. o.1 Introdução e conceitos básicos Notação assintótica: Outras classes • Funções que crescem (estritamente) menos que g(n) o(g(n)) = {f : N → R+ | (∀c > 0)∃n0 (∀n > n0 ) : f (n) ≤ cg(n)} (1. As definições ficam equivalente. usadas no cálculo. Convenção 1.9) n→∞ g(n) 22 .6) n→∞ g(n) f (n) f (n) ∈ o(g(n)) ⇐⇒ lim =0 (1.5).2 (Caracterização alternativa) Caracterizações alternativas de O. escrevemos f ∈ O(g) ao invés de f (n) ∈ O(g(n)). Proposição 1. f ≤ cg ao invés de f (n) ≤ cg(n) etc. Equações como ex = 1 + x + O(x2 ).

. i. para todo c > 0 existe um n0 tal que ∀n > n0 f (n)/g(n) < c pela definição do limite. que para o mesmo n0 . “⇐”: Seja lim supn→∞ f (n)/g(n) < ∞. é suficiente mostrar que existe um n tal que s(n) < ∞. Pela definição do limite existe n0 tal que ∀n > n0 |l − f /g| ≤ l/2. 23 . .e. i. m≥n Isso implica. i(n) não tem limite superior. Logo ∀n > n0 supm≥n f (m)/g(m) ≤ c. . Então ∃c > 0∃n0 ∀n > n0 ( sup f (m)/g(m)) < c. que justifique limn→∞ f (n)/g(n) = 0 (veja lema A. para todo c > 0 temos um n0 tal que ∀n > n0 f ≤ cg. Prova de 1.1 Notação assintótica Prova. g(n).9: f ∈ ω(g) ⇐⇒ (∀c > 0)∃n0 (∀n > n0 ) : f ≥ cg ⇐⇒ (∀c > 0)∃n0 (∀n > n0 ) : f (n)/g(n) ≥ c ⇐⇒ f (n)/g(n) não possui limite  Convenção 1. i. Prova de 1. caso não tem ambigüedade no contexto. Caso l = ∞.e. (∀c > 0)∃n0 i(n0 ) > c.7: “⇒”: Seja f ∈ o(g). Prova de 1. g. i. i(n0 + 1) > 0.6: “⇒”: Seja f ∈ O(g). Portanto ∀n > n0 f > cg e f ∈ ω(g) ⊆ Ω(g).8: “⇒”: Seja f ∈ Ω(g). Por definição do O temos c > 0 e n0 tal que ∀n > n0 f ≤ cg. Como i(n) é não-decrescente isso implica (∀c > 0)∃n0 (∀n > n0 ) i(n) > c. por exemplo. Vamos considerar os casos l < ∞ e l = ∞ separadamente. Pela definição de Ω existem c > 0 e n0 tal que ∀n > n0 f ≥ cg. Como s(n) = supm≥n f (m)/g(m) é não-crescente e maior ou igual que 0. Caso l < ∞: Escolhe. Logo ∀n > n0 f (n)/g(n) ≥ c > 0.2 Escrevemos f. que existe um n tal que i(n) > 0. para funções f (n). Logo ∀n > n0 f ≤ cg.1). ∀n > n0 f < cg e logo f ∈ O(g). c = l/2.e. . tal que f ∈ o(g). “⇐”: Seja limn→∞ f (n)/g(n) = 0. . Logo f ≥ l/2g (f /g aproxima l por baixo) e f ∈ Ω(g).e. é suficiente mostrar. Prova de 1. 1. . Como i(n) = inf m≥n f (m)/g(m) é não-decrescente. Logo ∀n > n0 f (n)/g(n) ≤ c. “⇐”: Suponha lim inf n→∞ f (n)/g(n) = l > 0.

♦ Uma notação assintótica menos comum é f = Õ(g) que é uma abreviação para f = O(g logk g) para algum k. temos g = cg 0 e existem c0 > 0 e n0 tal que ∀n > n0 g 0 ≤ c0 f . Portanto ∀n > n0 g = cg 0 ≤ cc0 f e com cc0 e n0 temos g ∈ O(f ).10: Escolhe c = 1. • Se um conjunto ocorre em uma fórmula.13) O(f )O(g) = O(f g) (1.1 Introdução e conceitos básicos Operações • As notações assintóticas denotam conjuntos de funções. f = O∗ (g) ignora fatores polinomiais.11: Se g ∈ cO(f ). i. Prova de 1.11) O(f ) + O(f ) = O(f ) (1.10) cO(f ) = O(f ) (1.12) O(O(f )) = O(f ) (1. existe um g ∈ O(n4 ) tal que n2 + f = g. 24 . Caracterı́sticas f = O(f ) (1.15) Prova. (1 − o(1)) ln n • Em uma equação o lado esquerdo é (implicitamente) quantificado uni- versal. n0 = 0.14) O(f g) = f O(g) (1. • Exemplo: n2 + O(n) = O(n4 ) Para todo f ∈ O(n). f = O(gp) para um polinômio p(n). Prova de 1. n1+o(1) .9 nO(1) denota {nf (n) | ∃c f (n) ≤ c} ⊆ {f (n) | ∃c∃n0 ∀n > n0 f (n) ≤ nc } o conjunto das funções que crescem menos que um polinômio.e. Õ é usado se fatores logarı́tmicos não importam. e o lado direto existencial. Similarmente. Exemplo 1. • Exemplos: nO(1) . log O(n2 ). resulta o conjunto de todas combinações das partes.

1.1 Notação assintótica

Prova de 1.12: Para g ∈ O(f ) + O(f ) temos g = h + h0 com c > 0 e n0 tal
que ∀n > n0 h ≤ cf e c0 > 0 e n00 tal que ∀n > n0 h0 ≤ c0 f . Logo para
n > max(n0 , n00 ) temos g = h + h0 ≤ (c + c0 )f .
Prova de 1.13: Para g ∈ O(O(f )) temos g ≤ ch com h ≤ c0 f a partir de
ı́ndices n0 e n00 , e logo g ≤ cc0 h a partir de max(n0 , n00 ).
Prova de 1.14: h = f 0 g 0 com f 0 ≤ cf f e g 0 ≤ cg g tal que h = f 0 g 0 ≤ cf cg f g.
Prova de 1.15: Para h ∈ O(f g) temos c > 0 e n0 tal que ∀n > n0 h ≤ cf g.
Temos que mostrar, que h pode ser escrito como h = f g 0 com g 0 ∈ O(g). Seja
(
0 h(n)/f (n) se f (n) 6= 0
g (n) =
cg(n) caso contrário

Verifique-se que h = f g 0 por análise de casos. Com isso, temos também
g 0 = h/f ≤ cf g/f = cg nos casos f (n) 6= 0 e g 0 = cg ≤ cg caso contrário. 

Exemplo 1.10
Por exemplo, (1.12) implica que para f = O(h) e g = O(h) temos f +g = O(h).

As mesmas caracterı́sticas são verdadeiras para Ω (prova? veja exercı́cio 1.1).
E para o, ω e Θ?

Caracterı́sticas: “Princı́pio de absorção” (Toscani and Veloso, 2005, p. 35)

g = O(f ) ⇒ f + g = Θ(f )

Relações de crescimento Uma vantagem da notação O é que podemos usá-
la em fórmulas como m + O(n). Em casos em que isso não for necessário,
e queremos simplesmente comparar funções, podemos introduzir relações de
crescimento entre funções, obtendo uma notação mais comum. Uma definição
natural é

Relações de crescimento

25

1 Introdução e conceitos básicos

Definição 1.1 (Relações de crescimento)

f ≺ g ⇐⇒ f ∈ o(g) (1.16)
f  g ⇐⇒ f ∈ O(g) (1.17)
f  g ⇐⇒ f ∈ ω(g) (1.18)
f  g ⇐⇒ f ∈ Ω(g) (1.19)
f  g ⇐⇒ f ∈ Θ(g) (1.20)
Essas relações também são conhecidas como a notação de Vinogradov5 .
Caso f  g digamos as vezes “f é absorvido pela g”. Essas relações satisfazem
as caracterı́sticas básicas esperadas.

Caracterı́sticas das relações de crescimento

Proposição 1.3 (Caracterı́sticas das relações de crescimento)
Sobre o conjunto de funções [N → R+ ]
1. f  g ⇐⇒ g  f ,
2.  e  são ordenações parciais (reflexivas, transitivas e anti-simétricas
em relação de ),
3. f ≺ g ⇐⇒ g  f ,
4. ≺ e  são transitivas,
5.  é uma relação de equivalência.
Prova.
1. Temos as equivalências
f  g ⇐⇒ f ∈ O(g)
⇐⇒ ∃c ∃n0 ∀n > n0 f ≤ cg
⇐⇒ ∃c0 ∃n0 ∀n > n0 g ≥ c0 f com c0 = 1/c
⇐⇒ g ∈ Ω(f )

2. A reflexividade e transitividade são fáceis de verificar. No exemplo do
, f  f , porque ∀nf (n) ≤ f (n) e f  g, g  h garante que a partir de
um n0 temos f ≤ cg e g ≤ c0 h e logo f ≤ (cc0 )h também. Caso f  g e
g  f temos com item (a) f  g e logo f  g pela definição de Θ.
5 Uma notação alternativa é  para  e  para . Infelizmente a notação não é padro-
nizada.

26

1.1 Notação assintótica

3. Temos as equivalências

f ≺ g ⇐⇒ f ∈ o(g)
⇐⇒ ∀c ∃n0 ∀n > n0 f ≤ cg
⇐⇒ ∀c0 ∃n0 ∀n > n0 g ≥ c0 f com c0 = 1/c
⇐⇒ g ∈ ω(f )

4. O argumento é essencialmente o mesmo que no item (a).

5. Como Θ é definido pela intersecção de O e Ω, a sua reflexividade e
transitividade é uma consequência da reflexividade e transitividade do
O e Ω. A simetria é uma consequência direta do item (a).


Observe que esses resultados podem ser traduzidos para a notação O. Por
exemplo, como  é uma relação de equivalência, sabemos que Θ também
satisfaz

f ∈ Θ(f )
f ∈ Θ(g) ⇒ g ∈ Θ(f )
f ∈ Θ(g) ∧ g ∈ Θ(h) ⇒ f ∈ Θ(h)

A notação com relações é sugestiva e freqüentemente mais fácil de usar, mas
nem todas as identidades que ela sugere são válidas, como a seguinte pro-
posição mostra.

Identidades falsas das relações de crescimento

Proposição 1.4 (Identidades falsas das relações de crescimento)
É verdadeiro que

f  g ⇒ f 6 g (1.21)
f ≺ g ⇒ f 6 g (1.22)

mas as seguintes afirmações não são verdadeiras:

f 6 g ⇒ f  g
f 6 g ⇒ f ≺ g
f ≺g∨f g∨f g (Tricotomia)

27

1 Introdução e conceitos básicos

Prova. Prova de 1.21 e 1.22: Suponha f  g e f  g. Então existe um c
tal que a partir de um n0 temos que f = cg (usa as definições). Mas então
f 6 g é uma contradição. A segunda caracterı́stica pode ser provada com um
argumento semelhante.
Para provar as três afirmações restantes considere o par de funções n e en sin(n) .
Verifique-se que nenhuma relação ≺, , ,  ou  é verdadeira. 
Considerando essas caracterı́sticas, a notação tem que ser usada com cau-
tela. Uma outra abordagem é definir O etc. diferente, tal que outras relações
acima são verdadeiras. Mas parece que isso não é possı́vel, sem perder outras,
veja (Vitányi and Meertens, 1985).

Outras notações comuns

Definição 1.2
O logaritmo iterado é
(
∗ 0 se n ≤ 1
log n = ∗
1 + log (log n) caso contrário

O logaritmo iterado é uma função que cresce extremamente lento; para valores
práticos de n, log∗ n não ultrapassa 5.

1.2 Notas
Alan Turing provou em 1936 que o “problema de parada” não é decidı́vel.
O estudo da complexidade de algoritmos começou com o artigo seminal de
Hartmanis and Stearns (1965).

1.3 Exercı́cios
(Soluções a partir da página 235.)

Exercı́cio 1.1
Prove as caracterı́sticas 1.10 até 1.15 (ou caracterı́sticas equivalentes caso al-
guma não se aplica) para Ω.

Exercı́cio 1.2
Prove ou mostre um contra-exemplo. Para qualquer constante c ∈ R, c > 0

f ∈ O(g) ⇐⇒ f + c ∈ O(g) (1.23)

28

1.3 Exercı́cios

Exercı́cio 1.3
Prove ou mostre um contra-exemplo.

1. log(1 + n) = O(log n)

2. log O(n2 ) = O(log n)

3. log log n = O(log n)

Exercı́cio 1.4
Considere a função definido pela recorrência

fn = 2fn−1 ; f0 = 1.

Professor Veloz afirme que fn = O(n), e que isso pode ser verificado simples-
mente da forma

fn = 2fn−1 = 2O(n − 1) = 2O(n) = O(n)

Mas sabendo que a solução dessa recorrência é fn = 2n temos dúvidas que
2n = O(n). Qual o erro do professor Veloz?

Exercı́cio 1.5
Mostre que a definição

ô(g(n)) = {f : N → R+ | (∀c > 0)∃n0 (∀n > n0 ) : f (n) < cg(n)}

(denotado com ô para diferenciar da definição o) e equivalente com a definição
1.2 para funções g(n) que são diferente de 0 a partir de um n0 .

Exercı́cio 1.6
Mostre que o números Fibonacci
(
n se 0 ≤ n ≤ 1
fn =
fn−2 + fn−1 se n ≥ 2

têm ordem assintótica fn ∈ Θ(Φn ) com Φ = (1 + 5)/2.

Exercı́cio 1.7
Prove a seguinte variação do princı́pio de absorção:

g ∈ o(f ) ⇒ f − g ∈ Θ(f ).

29

n3 log1/3 log n/log 1/3 n. f ∈ Θ(g) ou f ∈ Ω(g). Exercı́cio 1.12 1. mas o contrário O(f ) = Θ(f ) não é correto.8 Prove que f ≤ g ⇒ O(f ) = O(g). n3 log5/7 log n/log 5/7 n. O que se pode afirmar sobre a função composta g(f (n))? 2. Exercı́cio 1. Exercı́cio 1. 3.9 Prove que Θ(f ) = O(f ). n3 log1/2 log n/log 1/2 n. n3 log2 log n/logn.11 Prove: 2−m = 1 + O(m−1 ). 30 . Suponha que f e g são funções polinomiais e N em N: f (n) ∈ Θ(nr ) e g(n) ∈ Θ(ns ).1 Introdução e conceitos básicos Exercı́cio 1.13 Mostra que log n ∈ O(n ) para todo  > 0. Exercı́cio 1. Classifique as funções f (n) = 5 · 2n + 3 e g(n) = 3 · n2 + 5 · n como f ∈ O(g). n3 log1/2 . Verifique se 2n · n ∈ Θ(2n ) e se 2n+1 ∈ Θ(2n ). n3 log n. analisa a complexidade mutual. n3 log5/4 log n/log 5/4 n. n3 log3 log n/log 2 n Exercı́cio 1.10 Para qualquer par das seguintes funções. n3 log1/2 log n/logn. n3 .

2 Análise de complexidade 2. as medidas são difı́ceis de comparar. cuja poder computacional não é equi- valente em termos de complexidade (que não viola a tese de Church-Turing). porque devido a diferentes conjuntos de instruções. usamos um modelo de uma máquina que re- flita as caracterı́sticas de computadores comuns. arquiteturas e desempenho dos processadores. O plano Uma hierarquia de abstrações: Tempo de Complexidade Número / de / Operações no / pessimista execução [s] operações caso pessimista assintótica Custos de execuções • Seja E o conjunto de sequências de operações fundamentais. A tese que todos modelos computacionais são polinomialmente equivalentes as vezes está chamado tese de Church-Turing estendida. Conhe- cemos vários modelos de computadores. • uma memória infinita de números inteiros e • um conjunto de instruções elementares que podem ser executadas em tempo O(1) (por exemplo funções básicas sobre números inteiros e de ponto flutuante.1 Introdução Para analisar a eficiência de algoritmos faz pouco sentido medir os recur- sos gastos em computadores especı́ficos. mas é independente de uma implementação concreta. essas operações refletem operações tı́picas de máquinas concretas. Observe que a escolha de um modelo abstrato não é totalmente trivial. Portanto. e com apontador de ins- truções. acesso à memória e transferência de dados). 31 . e portanto. Um modelo comum é a máquina de RAM com as seguintes caracterı́sticas: • um processador com um ou mais registros. a noção de eficiência fica a mesma. Mas todos os modelos encontrados (fora da computação quântica) são poli- nomialmente equivalentes.

com entradas D seja exec[a] : D → E a função que fornece a sequência de instruções executadas exec[a](d) para cada entrada d ∈ D. Em geral. • Essa medida depende somente do tamanho da entrada tam : D → N • O objetivo é definir uma função aval[a](n) : N → R+ que define o desempenho do algoritmo em relação ao tamanho. não interessam os custos especı́ficos para cada entrada. 32 . Observe que as vezes R+ é denotado R+ . tem várias entradas d tal que tam(d) = n temos que definir como condensar a informação de desemp[a](d) delas.1 O sı́mbolo ◦ denota a composição de funções tal que (f ◦ g)(n) = f (g(n)) (leia: “f depois g”). em geral. • Como. podemos calcular também o custo de uma execução custo : E → R+ • e o custo da execução do algoritmo a depende da entrada d desemp[a] : D → R+ = custo ◦ exec[a] Definição 2. mas o “com- portamento” do algoritmo. Uma medida natural é como os custos crescem com o tamanho da entrada. • Se atribuı́mos custos para cada operação básica.2 Análise de complexidade • Para um algoritmo a. Condensação de custos • Queremos condensar os custos para uma única medida.

ela é difı́cil de determinar. tam(d) = n} 33 . se é importante saber quando uma execução de um algoritmo termina. ou é diferente em aplicações diferentes.1 Introdução ?>=< 89:. es- tamos interessados como eles se comportam na média (complexidade média). ela depende da distri- buição das entradas. para vários algoritmos com desempenho ruim no pior caso. Em comparação. que freqüentemente não é conhecida ou difı́cil de deter- minar. por várias razões. independente da entrada. A complexidade média é menos usada na prática. 2. preferimos a complexidade pessimista. Definição alternativa • A complexidade pessimista é definida como Cp= [a](n) = max{desemp[a](d) | d ∈ D. D desemp/ GFED @ABC Condensação Entrada R+ Custo da instância O tam ?>=< 89:. • Ela é baseada na distribuição das entradas. uma complexidade pessimista significa um desempenho garantido. uma complexidade média de. Por isso. Primei- ramente. Além disso. O(n2 ). duas medidas condensadas são de interesse particular • A complexidade pessimista Cp= [a](n) = max{desemp[a](d) | d ∈ D. tam(d) = n} • A complexidade média X Cm [a](n) = P (d) desemp[a](d) tam(d)=n • Observe: A complexidade média é o valor esperado do desempenho de entradas com tamanho n. Mesmo assim. / GFED @ABC   Tamanho N aval R+ Custo com tamanho n Condensação • Na prática. Infelizmente. por exemplo. não exclui que em certos casos uma entrada com tamanho n precisa muito mais tempo.

return} e atribuir um custo constante de 1 para cada um de- las.1 Vamos aplicar essas noções num exemplo de um algoritmo simples. . Saı́da True. caso contrário. Algoritmo 2. 1 f o r i :=1 t o n do 2 i f ( ai = 1 ) then 3 return t r u e 4 end i f 5 end f o r 6 return f a l s e Para analisar o algoritmo. if. (Observe que como “operação básica” for são consideradas as operações de atribuição.1 (Busca1) Entrada Uma sequência a1 . an de números em N. por exemplo. incremento e teste da expressão booleana i ≤ n. caso existe um i tal que ai = 1.2 Análise de complexidade • Uma definição alternativa é Cp≤ [a](n) = max{desemp[a](d) | d ∈ D. tam(d) ≤ n} • Cp≤ é monotônica e temos Cp= [a](n) ≤ Cp≤ [a](n) • Caso Cp= seja monotônica as definições são equivalentes Cp= [a](n) = Cp≤ [a](n) Cp= [a](n) ≤ Cp≤ [a](n) é uma consequência da observação que {desemp[a](d) | d ∈ D. .) Logo as execuções possı́veis são E = O∗ (o fecho de Kleene de O) e temos a função de custos 34 . Exemplo 2. se A ⊆ B tem-se que max A ≤ max B. tam(d) = n} ⊆ {desemp[a](d) | d ∈ D. tam(d) ≤ n} Analogamente. O objetivo é decidir se uma sequência de números naturais contém o número 1. as operações básicas O = {f or. . . false. podemos escolher.

A função de execução atribui a sequência de operações executadas a qualquer entrada. . Por exemplo custo((f or. D = N∗ e como tamanho da entrada escolhemos tam : D → N : (a1 . e portanto Cp= = Cp≤ . if )i return caso existe i = min{j | aj = 1} (a1 . return)) = 4. an ) 7→ n. As entradas desse algoritmo são sequências de números naturais.1 Metodologia de análise de complexidade Uma linguagem simples • Queremos estudar como determinar a complexidade de algoritmos me- todicamente. logo. Temos exec[Busca1](d) : D → E : ( (f or. Um caso que em geral é menos interessante podemos tratar nesse exemplo também: Qual é a complexidade otimista (complexidade no caso melhor)? Isso acontece quando 1 é o primeiro elemento da sequência.2 Complexidade pessimista 2. f or. . logo. . • Para este fim. .2. . if )n return caso contrário Com essas definições temos também a função de desempenho desemp[Busca1](n) = custo ◦ exec[Busca1] : ( 2i + 1 caso existe i = min{j | aj = 1} (a1 . . an ) 7→ 2n + 1 caso contrário Agora podemos aplicar a definição da complexidade pessimista para obter Cp≤ [Busca1](n) = max{desemp[Busca1](d) | tam(d) = n} = 2n + 1 = O(n). vamos usar uma linguagem simples que tem as operações básicas de 35 . if. . 2. Co [Busca1](n) = 2 = O(1). . an ) 7→ (f or. ♦ 2. . . . Observe que Cp= é monotônica.2 Complexidade pessimista custo : E → R+ : e 7→ |e|. .

A. g com dom(f ) = dom(g) temos ∀d ∈ dom(f ) (f ◦ g) = f (d) ◦ g(d). • Exemplo: Suponha que um algoritmo A produz. n /A / n2 /A / n4 • A sequência A. • Portanto. Iteração indefinida: enquanto b faça c A forma se b então c1 vamos tratar como abreviação de se b então c1 else skip com comando skip de custo 0. • Objetivo: Analisar as componentes independentemente (como sub-algoritmos) a depois compor as complexidades delas.1 A seguir vamos entender implicitamente todas operações sobre funções pon- tualmente. i.2 Análise de complexidade 1. uma lista de tamanho n2 em tempo Θ(n2 ). a partir de uma lista de tamanho n. Iteração definida: para i de j até m faça c 5.e.c2 3. Componentes • A complexidade de um algoritmo pode ser analisada em termos de suas componentes (princı́pio de composicionalidade). computa a complexidade dele. para alguma operação ◦. vamos diferençar entre 36 . • Pode-se diferenciar dois tipos de componentes: componentes conjuntivas e componentes disjuntivas. Sequência: c1. dado um algoritmo como entrada. mesmo sendo composta pelos dois algoritmos com Θ(n2 ) individualmente. Convenção 2. tem complexidade Θ(n4 ). Este problema não é computável (por quê?). Observe que a metodologia não implica que tem um algoritmo que. Atribuição: v:=e 2. e funções f. Composição de componentes • Cautela: Na composição de componentes o tamanho da entrada pode mudar. Condicional: se b então c1 senão c2 4.

c2 ] = Θ(cp [c1 ] + cp [c2 ]) = Θ(max(cp [c1 ]. c2 ](d) = desemp[c1 ](d) + desemp[c2 ](d) logo para todas entradas d com tam(d) = n max max(desemp[c1 ](d). • Neste curso tratamos somente o primeiro caso. c2 ] ≤ cp [c1 ] + cp [c2 ]  Exemplo 2.2 Complexidade pessimista – algoritmos que preservam (assintoticamente) o tamanho. cp [c2 ]) ≤ cp [c1 . c2 ] ≤ cp [c1 ] + cp [c2 ] e como f + g ∈ O(max(f. desemp[c2 ](d)) ≤ max desemp[c1 . • Qual a sua complexidade cp [c1 . w := soma(u) com complexidades cp [v := ordena(u)](n) = n2 e cp [w := soma(u)](n) = n. ♦ 37 . desemp[c2 ](d)) ≤ desemp[c1 . desemp[c2 ]) e portanto (veja A.8) max(cp [c1 ]. Componentes conjuntivas A sequência • Considere uma sequência c1 . e – algoritmos em que modificam o tamanho do problema. g)) tem-se que cp [c1 . c2 ](d) d d = max (desemp[c1 ](d) + desemp[c2 ](d)) d ⇐⇒ max(cp [c1 ]. cp [c2 ])) Prova. max(desemp[c1 ](d). 2.2 Considere a sequência S ≡ v := ordena(u). Então cp [S] = Θ(n2 + n) = Θ(n2 ). c2 ] = desemp[c1 ]+desemp[c2 ] ≥ max(desemp[c1 ]. c2 . cp [c2 ]) ≤ cp [c1 . c2 ] em termos dos componentes cp [c1 ] e cp [c2 ]? • Temos desemp[c1 .

3 Considere uma partição das entradas do tamanho n tal que {d ∈ D | tam(d) = . A2 ] = n2 + n e portanto max(cp [A1 ]. A2 . • Inicialização ou transferência da variáveis inteiras tem complexidade O(1) i := 0. A2 ] = n2 + n < cp [A1 ] + cp [A2 ] = 2n2 ♦ A atribuição: Exemplos • Considere os seguintes exemplos. desemp[v := e] = desemp[e] + desemp[←e ] • Ela se comporta como uma sequência dessas duas componentes. A1 precisa n passos para instâncias em D1 . precisa n2 para instâncias em D1 . Com isso obtemos cp [A1 ] = n2 .2 Análise de complexidade Exemplo 2. portanto cp [v := e] = Θ(cp [e] + cp [←e ]) • Freqüentemente cp [←e ] é absorvida pelo cp [e] e temos cp [v := e] = Θ(cp [e]) 38 . e n2 para instâncias em D2 . cp [A2 ]) = n2 < cp [A1 . i. cp [A2 ] = n2 . j := i • Determinar o máximo de uma lista de elementos v tem complexidade O(n) m := max(v) • Inversão de uma lista u e atribuição para w tem complexidade 2n ∈ O(n) w := reversa(u) A atribuição • Logo. n} = D1 (n) ∪ D2 (n) e dois algoritmos A1 e A2 . contrariamente. cp [A1 .e. a atribuição depende dos custos para a avaliação do lado direito e da atribuição. e n passos para instâncias em D2 .

b. 39 . • Tendo N ∗ . Com complexidade pessimista para a ordenação da lista cp [ordene(w)] = O(n2 ) e complexidade cp [←e ] = O(n) para a transferência. em geral a questão não é decidı́vel.4 Continuando o exemplo 2. c. c. c. • N ∗ (n) é o máximo de iterações para entradas de tamanho até n.2 podemos examinar a atribuição v := ordene(w). ♦ Iteração definida Seja C =para i de j até m faça c • O número de iterações é fixo. 0}. 2. • Em analogia com a iteração definida temos uma sequência b. c. · · · . b. temos cp [v := ordene(w)] = O(n2 ) + O(n) = O(n2 ). • Seja N (n) = maxd {m(d)−j(d)+1 | tam(d) ≤ n} e N ∗ (n) = max{N (n). podemos tratar a iteração definida como uma sequência c. c | {z } N ∗ (n) vezes que resulta em cp [C] ≤ N ∗ cp [c] Iteração indefinida Seja C =enquanto b faça c • Para determinar a complexidade temos que saber o número de iterações.2 Complexidade pessimista Exemplo 2. b | {z } h(n)−1 vezes e portanto cp [C] ≤ (h − 1)cp [c] + hcp [b] • Caso o teste b é absorvido pelo escopo c temos cp [C] ≤ (h − 1)cp [c] Observe que pode ser difı́cil de determinar o número de iterações H(d). • Seja H(d) o número da iteração (a partir de 1) em que a condição é falsa pela primeira vez • e h(n) = max{H(d) | tam(d) ≤ n} o número máximo de iterações com entradas até tamanho n. mas j e m dependem da entrada d. · · · .

Relax to M xAO(f. but not (iv): too strong. desemp[c] ≤ max(desemp[c1 ].5 Considere um algoritmo a que. g) = h for any h ∈ O(max(f. cp [c2 ]) Para se b então c1 obtemos com cp [skip] = 0 cp [C] ≤ cp [b] + cp [c1 ] Exemplo 2. desemp[c2 ]) e temos cp [a] ≤ max(cp [c1 ]. O condicional Seja C =se b então c1 senão c2 • O condicional consiste em – uma avaliação da condição b – uma avaliação do comando c1 ou c2 (componentes disjuntivas). (see also lecture 4). cp [c2 ]) = O(max(cp [c1 ]. cp [c2 ])). No.(ii).(iii) hold. Componentes disjuntivas • Suponha um algoritmo c que consiste em duas componentes disjuntivas c1 e c2 . Logo. ordena a lista ou determina seu somatório: 40 . cp [c2 ]) Caso a expressão para o máximo de duas funções for difı́cil. no. podemos simpli- ficar cp [a] ≤ max(cp [c1 ]. • Aplicando as regras para componentes conjuntivas e disjuntivas obtemos cp [C] ≤ cp [b] + max(cp [c1 ]. g)). treat MxAO like the func- tion class above! Then (i). i tend to let M xAO(f. dependendo do primeiro elemento de uma lista u.2 Análise de complexidade Componentes disjuntivas To make the MxAO thingy more concrete. This definition unfortunately satisfies not exactly (but only in terms of O) the axioms. g) = O(g) is reasonable.

tal que cp [a] ≤ max(cp [v := ordena(u)].2 Complexidade pessimista Exemplo 1 s e hd(u) = 0 e n t ã o 2 v := ordena(u) 3 s e n ã o 4 s := soma(u) Assumindo que o teste é possı́vel em tempo constante. cp [s := soma(u)]) e com. aj+1 6 end i f 7 end f o r 8 end f o r Uma ilustração: http://www. ele é absorvido pelo trabalho em ambos casos.2.2 Exemplos Exemplo 2. an de números inteiros. Bubblesort Algoritmo 2. n] tal que para i < j temos aπ(i) ≤ aπ(j) . .cs. .6 (Bubblesort) Nesse exemplo vamos estudar o algoritmo Bubblesort de ordenação. aπ(n) de números inteiros onde π uma permutação de [1.ca/~harrison/Java/sorting-demo. Saı́da Uma sequência aπ(1) . . . 2.ubc.2 (Bubblesort) Entrada Uma sequência a1 . . 1 f o r i :=1 t o n 2 { Inv : an−i+2 ≤ · · · ≤ an são os i − 1 maiores elementos } 3 f o r j :=1 t o n i 4 i f aj > aj+1 then 5 swap aj . . . por exemplo. html 41 . cp [v := ordena(u)](n) = n2 e cp [s := soma(u)](n) = n temos cp [a](n) ≤ n2 ♦ 2. .

) 42 . . n] e para i < j temos aπ(i) ≤ aπ(j) . ai−1 ordenado } 3 { coloca item i na posição correta } 4 c:=ai 5 j :=i . .2 Análise de complexidade Bubblesort: Complexidade • A medida comum para algoritmos de ordenação: o número de com- parações (de chaves). 6 while c < aj−1 and j > 1 do 7 aj :=aj−1 8 j :=j − 1 9 end while 10 aj :=c 11 end f o r (Nesse algoritmo é possı́vel eliminar o teste j > 1 na linha 6 usando um elemento auxiliar a0 = −∞. . . aπ(n) de números inteiros tal que π é uma permutação de [1. . 1≤i≤n 1≤j≤n−i • Qual a diferença se contamos as transposições também? ♦ Exemplo 2. 1 f o r i :=2 t o n do 2 { invariante : a1 . .7 (Ordenação por inserção direta) Ordenação por inserção direta Algoritmo 2. . .3 (Ordenação por inserção direta (inglês: straight insertion Entrada Uma sequência a1 . . . an de números inteiros. • Qual a complexidade pessimista? X X 1 = n/2(n − 1). Saı́da Uma sequência aπ(1) . . .

4 (Máximo) Entrada Uma sequência de números a1 . Podemos obter uma cota superior simples de O(n) observando que o laço sempre executa um número fixo de operações (ao máximo dois no corpo). É fácil ver que assintoticamente todos os casos. . 3. . Para uma análise mais detalhada vamos denotar o custo em números de operações de cada linha como li e supomos que toda operação básico custa 1 e a linha 2 do laço custa dois (l2 = 2. Saı́da O máximo m = maxi ai . cap. an com n > 0. . . . . para fazer um teste e um incremento).9 (Busca seqüencial) O segundo algoritmo que queremos estudar é a busca seqüencial. No melhor caso temos k = 0 e custos de 3n − 1.8 (Máximo) (Ver Toscani and Veloso (2005.2 Complexidade pessimista Para a complexidade pessimista obtemos X X X cp [SI](n) ≤ O(1) = = O(n2 ) 2≤i≤n 1<j≤i 2≤i≤n ♦ Exemplo 2. têm custo Θ(n). No pior caso m = n − 1 e custos de 4n − 2. aritmética) têm um custo constante. comparação. . inclusive o caso médio. . 2. então temos l1 + (n − 1)(l2 + l3 ) + kl4 + l7 = 3n + k − 1 com um número de execuções da linha 4 ainda não conhecido k. ♦ Exemplo 2. n do 3 i f ai > m then 4 m := ai 5 end i f 6 end f o r 7 return m Para a análise supomos que toda operação básica (atribuição.3). 1 m := a1 2 f o r i := 2.) Máximo Algoritmo 2. 43 .

. . uma sequência de números a1 . ♦ Counting-Sort Algoritmo 2. Saı́da Uma sequência ordenada de números b1 . • Logo temos complexidade pessimista Θ(n). . . . Saı́da A primeira posição p tal que ap = c ou p = ∞ caso não existe tal posição. . . . n do 5 cai := cai + 1 44 . . . . an com n > 0 e um chave c. an e uma sequência de contadores c1 . .6 (Counting-Sort) Entrada Um inteiro k. . .2 Análise de complexidade Busca seqüencial Algoritmo 2. n do 2 i f ai = c then 3 return i 4 end i f 5 end f o r 6 return ∞ Busca seqüencial • Fora do laço nas linhas 1–5 temos uma contribuição constante. . . . . . . . . bn . . . . k do 2 ci := 0 3 end f o r 4 f o r i := 1. . 1 f o r i := 1.5 (Busca seqüencial) Entrada Uma sequência de números a1 . cn . 1 f o r i := 1. . temos que fazer n iterações. • Caso a sequência não contém a chave c. .

. . Saı́da Um vetor p[1.2 Complexidade pessimista 6 end f o r 7 f o r i := 2. . . 13 do 5 i f Ai. . . . . . 1 do 11 bcai := ai 12 cai := cai − 1 13 end f o r 14 return b1 . k do 8 ci := ci + ci−1 9 end f o r 10 f o r i := n. . . . . . . . 2.j = rj then pi := pi + 1 6 end f o r 7 i := i + 1 8 end while 9 f o r i de1. .7 (Loteria Esportiva) Entrada Um vetor de inteiros r[1. . n do 10 i f pi = 13 then p r i n t ( Apostador i é ganhador ! ) 11 end f o r 12 return p Exemplo 2. . . 1 i := 1 2 while i ≤ n do 3 pi := 0 4 f o r j de 1. n] com os pontos feitos por cada apostador. . bn Loteria Esportiva Algoritmo 2. n] com o resultado e uma matriz A13xn com as apostas dos n jogadores. . . . . .10 (Busca Binária) Busca Binária 45 . . .

32. . a2 .n. Ex: 3.12.7.2 Análise de complexidade Algoritmo 2.8 (Busca Binária) Entrada Um inteiro x e uma sequência ordenada S = a1 . Neste caso a sequência de dados é dividida pela metade até o término da busca.14. ou seja. .31. e no caso de números ordenados e sem gaps (nenhum número faltante na sequência.27. o pior caso acontece quando o último elemento que for analisado é o procurado... .18. Saı́da Posição i em que x se encontra na sequência S ou −1 caso x ∈ / S. Se os números não estiverem ordenados um algoritmo linear resolveria o problema.4. Neste caso log2 n X Cp [a] = = c i=1 = O(log2 n) ♦ Exemplo 2.11 (Busca em Largura) Busca em Largura 46 . ou seja 2x = n. um algoritmo constante pode resolver o problema. 1 i := 1 2 f := nj k f −i 3 m := 2 +i 4 while i ≤ f do 5 i f am = x then return m 6 i f am < x then f := m − 1 7 e l s e ji :=km + 1 f −i 8 m := 2 +i 9 end while 10 return −1 A busca binária é usada para encontrar um dado elemento numa sequência ordenada de números com gaps. No caso da busca binária. no máximo log2 n = x vezes. an de números.

O laço while (linhas 9-19) será executado no máximo |V | vezes. 1 f o r cada v é r t i c e u ∈ V − {s} do 2 cu :=BRANCO 3 du = ∞ 4 end f o r 5 cs :=CINZA 6 ds := 0 7 Q := ∅ 8 Enqueue (Q. Desta forma. n × o) segue diretamente a definição X cik = aij bjk 1 ≤ i ≤ m. os dois laços executarão |E| vezes (este tipo de análise se chama de análise agregada).12 (Multiplicação de matrizes) O algoritmo padrão da computar o produto C = AB de matrizes (de tamanho m × n.2 Complexidade pessimista Algoritmo 2. v ) 16 end i f 17 end f o r 18 cu =PRETO 19 end while Este algoritmo. Já o laço for (linhas 11-17) executará du vezes. Como o primeiro laço for do algoritmo tem complexidade O(|V |). ♦ Exemplo 2. 47 . s ) 9 while Q 6= ∅ 10 u := Dequeue (Q) 11 f o r cada v ∈ Adj(u) 12 i f cv =BRANCO 13 then cv =CINZA 14 dv = du + 1 15 Enqueue (Q.9 (Busca em Largura) Entrada Um nó origem s e um grafo direcionado estruturado como uma sequência das listas de adjacências de seus nós. sendo du o grau de saı́da do nó u. então a complexidade total do algoritmo será O(|V | + |E|). 1 ≤ k ≤ o 1≤j≤n e resulta na implementação Algoritmo 2. B = (bjk ) ∈ Rn×o .. 2001). Saı́da Posição i vetor de distâncias (número de arcos) de cada nó ao origem. 2. para cada nó do grafo. estão disponı́veis no livro do Cor- men (Cormen et al. bem como sua análise. ou seja.10 (Multiplicação de matrizes) Entrada Duas matrizes A = (aij ) ∈ Rm×n .

• Para tamanho n. precisamos mno(M +A) operações. com M denotando multiplicações e A adições. . A conjetura atual é que existe um algoritmo (ótimo) de O(n2 ). Motivação • A complexidade pessimista é pessimista demais? • Imaginável: poucas instâncias representam o pior caso de um algoritmo. no caso de Coppersmith-Winograd o algoritmo não é praticável). Ambas são pouco usadas na prática porque o desempenho real é melhor somente para n grande (no caso de Strassen n ≈ 700. o do 3 cik := 0 4 f o r j := 1.376 multi- plicações (Coppersmith and Winograd. Senão a complexidade seria 2n/33/2 = O(n3/2 ). . .2 Análise de complexidade Saı́da O produto C = (cik ) = AB ∈ Rm×o . • Isso motiva a estudar a complexidade média. . . . . n do 5 cik := cik + aij bjk 6 end f o r 7 end f o r 8 end f o r No total. vamos estudar algumas técnicas de análise da complexidade média. Esse algoritmo não é o melhor possı́vel: Temos o algoritmo de Strassen que precisa somente nlog2 7 ≈ n2. 1987).3 Complexidade média Nesse capı́tulo. ♦ 2. tal que temos uma entrada de tamanho Θ(n2 ) e Θ(n3 ) operações1 . . vamos considerar 1 Também é de costume contar as operações de ponto flutuante diretamente e não em relação ao tamanho da entrada.807 multiplicações (o algoritmo está detalhado no capı́tulo 6. . 48 . . m do 2 f o r k := 1.3) e o algoritmo de Coppersmith-Winograd com n2. . . É costume estudar a complexidade no caso n = m = o e somente considerar as multiplicações. 1 f o r i := 1.

1997) (Parada em k passos). • Uma função sem volta f : {0.) Criptografia • Criptografia somente é possı́vel se existem “funções sem volta (inglês: one-way functions). 1}∗ é tal que – dado x. computar f (x) é fácil (eficiente) – dada f (x) achar um x0 tal que f (x0 ) = f (x) é difı́cil Método 49 . 2. 1}∗ → {0. Du and Ko. (Wang. 1987.3 Complexidade média – O espaço amostral Dn = {d ∈ D | tam(d) = n} – Uma distribuição de probabilidade Pr sobre Dn – A variável aleatória desemp[a] – O custo médio X Cm [a](n) = E[desemp[a]] = P (d) desemp[a](d) d∈Dn Tratabilidade? • Possibilidade: Problemas intratáveis viram tratáveis? • Exemplos de tempo esperado: – Caminho Hamiltoniano: linear! – Parada não-determinı́stico em k passos: fica NP-completo. (Resultados citados: (Gurevich and Shelah. 1997) (Caminho Hamiltanio).

• Caso a chave não ocorra no conjunto. EXPANDE Resolve as equações com álgebra clássica e expande os coeficientes das soluções. 50 .13 (Busca seqüencial) (Continuando exemplo 2. temos que fazer i iterações.2 Análise de complexidade (Vitter and Flajolet. Exemplo 2. ASSINT Usa métodos assintóticas para obter estimativas. COMPLEX Usa análise complexa para obter estimativas assintóticas direta- mente. SÍMBOL Traduz as definições das estruturas diretamente para funções gera- trizes. temos que fazer n iterações. FUNGER Transforma as recorrências para equações de funções geratrizes.) Busca seqüencial • Caso a chave esteja na i-ésima posição. 1990) RECOR Acha recorrências para os valores esperados.9. RESOLVE Resolve usando álgebra clássica.

.3 Complexidade média • Supondo uma distribuição uniforme da posição da chave na sequência. . . . .1). Pr[ai = 1] = 1/2 e Pr[ai 6= 1] = 1/2. . . an ) | a1 ≥ 1. . temos   1  X n+ i n+1 1≤i≤n iterações e uma complexidade média de Θ(n). Seja n um tamanho fixo. i − 1 devem ser diferente de 1. O caso p = n tem duas causas: ou a posição do primeiro 1 é n ou a sequência não contém 1. . 2. . considere o caso em que não há números repetidos no conjunto.) Neste exemplo vamos analisar o algoritmo considerando que a ocorrência dos números siga uma outra distribuição que não a uniforme. an )] = 2−ai 1≤i≤n e.1. ♦ Exemplo 2. Ambas têm probabilidade 2−n e logo Pr[p = n] = 21−n . . . . Para Busca1 temos o espaço amostral Dn = {(a1 . Supondo que os números sigam uma distribuição na qual cada elemento da sequência é gerado independentemente com a probabilidade Pr[ai = n] = 2−n −i P (que é possı́vel porque 1≤i 2 = 1). e ai deve ser 1. an ≥ 1}. .33) 2−n cp [a](n) = 5 − 2 = O(1) 51 .14 (Continuando o exemplo 2. Logo para 1 ≤ i < n Pr[p = i] = Pr[a1 6= 1] · · · Pr[ai−1 6= 1] Pr[ai = 1] = 2−i . A complexidade média calcula-se como cp [a](n) = E[desemp[a]] = E[2p + 1] = 2E[p] + 1 X X E[p] = Pr[p = i]i = 2−n n + 2−n n i≥0 1≤i≤n −n −n =2 n+2−2 (n + 2) = 2 − 21−n (A. Ainda. . . Considere as variáveis aleatórias desemp[a] e ( µ se o primeiro 1 está na posição µ p= n caso contrário Temos desemp[a] = 2p + 1 (veja os resultados do exemplo 2. Com isso temos Y Pr[(a1 . Para i estar na primeira posição com elemento 1 as posições 1.

7.992 Exemplo 2.969 4. • Logo chave i precisa X i+1 j/i = 2 1≤j≤i comparações em média.16 (Bubblesort) (Continuando exemplo 2.) Ordenação por inserção direta • Qual o número médio de comparações? • Observação: Com as entradas distribuı́das uniformemente. com essa operação básica temos uma complexidade pessimista e média de Θ(n2 ).938 4.2 Análise de complexidade A seguinte tabela mostra os custos médios para 1 ≤ n ≤ 9 n 1 2 3 4 5 6 7 8 9 ♦ Cm 3 4 4.) O número de comparações do Bubblesort é independente da entrada.984 4.75 4.5 4.6. a posição da chave i na sequência já ordenada também é.875 4. Logo. • Logo o número esperado de comparações é X i+1   1 X 1 (n + 1)(n + 2) = i= − 3 = Θ(n2 ) 2 2 2 2 2≤i≤n 3≤i≤n+1 ♦ Exemplo 2. Bubblesort: Transposições • Qual o número de transposições em média? 52 .15 (Ordenação por inserção direta) (Continuando exemplo 2.

i.0x10 5. n] distribuı́das uniformemente resulta em n/4(n − 1) transposições em média. Inversões • Uma inversão em uma permutação é um par que não está ordenado.5x104 2.5x104 4 1.0x103 0 5 10 15 20 25 30 35 Número de transposições Qual a complexidade contando o número de transposições? A figura acima mostra no exemplo das instâncias com tamanho 9. a metade do pior caso. que o trabalho varia en- tre 0 transposições (sequência ordenada) e 36 transposições (pior caso) e na maioria dos casos.e.0x104 Quantidade 1. Permutação #Inversões 123 0 132 1 • Exemplos 213 1 231 2 312 2 321 3 • Freqüentemente o número de inversões facilita a análise de algoritmos de ordenação. 53 .3 Complexidade média Distribuição das transposições no Bubblesort para n=9 2. A análise no caso em que todas entradas são permutações de [1. 2. i<j tal que ai > aj . precisamos 18 transposições.

e.) Queremos analisar o número médio de atribuições na determinação do máximo. ♦ Exemplo 2.2 Análise de complexidade • Em particular para algoritmos com transposições de elementos adjacen- tes: #Transposições = # Inversões Número médio de transposições • Considere o conjunto de todas permutações Sn sobre [1. n]. o número de atualizações do máximo.17 (Máximo) (Continuando exemplo 2. Número médio de transposições • O número médio de inversões é ! X X X 1/n! inv(π) = 1/(2n!) inv(π) + inv(π) π∈Sn π∈Sn π∈Sn ! X X − = 1/(2n!) inv(π) + inv(π ) π∈Sn π∈Sn ! X = 1/(2n!) (inv(π) + inv(π − )) π∈Sn ! X = 1/(2n!) n(n − 1)/2 π∈Sn = n(n − 1)/4 • Logo. • Para cada permutação π existe uma permutação π − correspondente com ordem inversa: 35124. • Denota-se por inv(π) o número de inversões de uma permutação. 42153 • Cada inversão em π não é inversão em π − e vice versa: inv(π) + inv(π − ) = n(n − 1)/2.8. i. a complexidade média (de transposições) é Θ(n2 ). 54 .

se todos números que são maiores são no seu direito. • bi é o número de elementos na esquerda de i que são maiores que i.e. i. o número esperado de máximos locais é   X X E[X] = E  Xi  = E[Xi ] 1≤i≤n 1≤i≤n X X 1 X 1 = Pr[Xi ] = = = Hn n−i+1 i 1≤i≤n 1≤i≤n 1≤i≤n 55 . • Portanto. . se bi = 0. . . na busca do máximo i é máximo local se todos números no seu esquerdo são menores. Tabelas de inversões • Observação: Cada tabela de inversões corresponde a uma permutação e vice versa. • Temos Pr[Xi = 1] = Pr[bi = 0] = 1/(n − i + 1). . 2.e. • Observação. P • O número de máximos locais é X = 1≤i≤n Xi . i. bn .3 Complexidade média Máximo • Qual o número esperado de atualizações no algoritmo Máximo? • Para uma permutação π considere a tabela de inversões b1 . b1 b2 b3 b4 b5 • Exemplo: A permutação correspondente com 3 1 2 1 0 • Vantagem para a análise: Podemos escolher os bi independentemente. Número esperado de atualizações • Seja Xi a variável aleatória Xi = [i é máximo local]. b1 b2 b3 b4 b5 • Exemplo: Para 53142 2 3 1 1 0 • Os bi obedecem 0 ≤ bi ≤ n − i.

11 (Partition) Entrada Índices l.18 (Quicksort) Nessa seção vamos analisar é Quicksort. m[ e am ≤ ai para i ∈]m. – Divide: Particione o vetor em elementos menores que o pivô e maiores que o pivô. 1962). r e um vetor a com elementos al .A. 1 e s c o l h e um p i v ô ap 2 t r o c a ap e ar 3 i := l − 1 { último ı́ndice menor que pivô } 4 f o r j := l t o r − 1 do 5 i f aj ≤ ar then 6 i := i +1 7 t r o c a ai e aj 8 end i f 9 end f o r 10 t r o c a ai+1 e ar 11 return i + 1 56 . r]. . . ar . Saı́da Um ı́ndice m ∈ [l. • Quicksort usa divisão e conquista. • Idéia: – Escolhe um elemento (chamado pivô). um algoritmo de ordenação que foi inventado pelo C. . .R. r] e a com elementos ordenados tal que ai ≤ am para i ∈ [l. ♦ Exemplo 2.2 Análise de complexidade • Contando atualizações: tem uma a menos que os máximos locais Hn −1. Particionar Algoritmo 2. Quicksort • Exemplo: o método Quicksort de ordenação por comparação. Hoare em 1960 (Hoare. – Conquiste: Ordene as duas partições recursivamente.

Complexidade de particionar • O tamanho da entrada é n = r − l + 1 • Dependendo da escolha do pivô: precisa nenhuma ou uma comparação. • Vamos usar a segunda opção. . • O trabalho no corpo do laço é 1 = Θ(1) (uma comparação) • Portanto temos a complexidade pessimista cp [Partition] = n − 1 = n = Θ(n) cp [Partition] = n − 1 + 1 = n = Θ(n). i.. 57 . .12 (Quicksort) Entrada Índices l. Quicksort Algoritmo 2. . – Escolhe o maior dos primeiros dois elementos. 2. ar . Saı́da a com os elementos em ordem não-decrescente. • Dois exemplos – Escolhe o primeiro elemento.e. . • Operações relevantes: Número de comparações entre chaves! • O desempenho de Partition depende da escolha do pivô.3 Complexidade média Escolher o pivô • Partition combina os primeiros dois passos do Quicksort. para i < j temos ai ≤ aj . r e um vetor a com elementos al . • O laço nas linhas 4–9 tem n − 1 iterações.

Seja Dn = i Dni uma partição das entradas com tamanho n tal que para d ∈ Dni temos |dl |= i − 1 (e conseqüentemente |dr |= n − i). Então max desemp[QS](dl ) + desemp[QS](dr ) d∈Dn = max maxi desemp[QS](dl ) + desemp[QS](dr ) separando Dn 1≤i≤n d∈Dn = max maxi cp [QS](i − 1) + cp [QS](n − i) 1≤i≤n d∈Dn 58 . ar ) = desemp[P ](al . . . . a ) . . ar ) cp [QS](n) = max desemp[P ](d) + desemp[QS](dl ) + desemp[QS](dr ) d∈Dn = n + max desemp[QS](dl ) + desemp[QS](dr ) d∈Dn = n + max cp [QS](i − 1) + cp [QS](n − i) 1≤i≤n • cp [QS](0) = cp [QS](1) = 0 Esse análise é válido para escolha do maior entre os dois primeiros elementos como pivô. . ar ) desemp[QS](al . sejam dl = (al . . . . . . . . . . . . 4 Quicksort (m + 1 .a ) . an ). . 3 Quicksort (l . . . Também vamos S justificar o último passo na análise acima com mais detalhes.r . . . . . r . .2 Análise de complexidade 1 i f l < r then 2 m := P a r t i t i o n ( l . am−1 ) e dr = (am+1 . . . 5 end i f desemp[QS](al .m − 1 . ar ) = 0 se l ≥ r Complexidade pessimista • Qual a complexidade pessimista? • Para entrada d = (a1 .a ) . . am−1 ) + desemp[QS](am+1 . . . ar ) + desemp[QS](al . . . .

n]). Para determinar o máximo da última expressão. uma permutação de [1. no pior caso. e existe uma entrada d em que as duas sub- partições assumem o máximo. podemos observar que ele deve ocorrer no ı́ndice i = 1 ou i = bn/2c (porque f (i) = cp [QS](i − 1) + cp [QS](n − i) é simétrico com eixo de simetria i = n/2). X cm [QS] = Pr[d] desemp[QS](d) d∈Dn X = Pr[d](desemp[P ](d) + desemp[QS](dl ) + desemp[QS](dr )) d∈Dn X =n+ Pr[d](desemp[QS](dl ) + desemp[QS](dr )) d∈Dn X =n+ Pr[X = i](cm [QS](i − 1) + cm [QS](n − i)) 1≤i≤n 59 . Complexidade média • Seja X a variável aleatória que denota a posição (inglês: rank) do pivô am na sequência. Quicksort precisa Θ(n2 ) comparações. 2. • Vamos supor que todos elementos ai são diferentes (e. Complexidade pessimista • O máximo ocorre para i = 1 ou i = n/2 • Caso i = 1 cp [QS](n) = n + cp [QS](0) + cp [QS](n − 1) = n + cp [QS](n − 1) X = ··· = (i − 1) = Θ(n2 ) 1≤i≤n • Caso i = n/2 cp [QS](n) = n + 2cp [QS](n/2) = n − 1 + 2((n − 1)/2 + cp (n/4)) = · · · = Θ(n log2 n) • Logo. • No caso bem balanceado: Θ(n log2 n) comparações. porque a partição de uma permutação aleatória gera duas partições aleatórias. sem perda da generalidade.3 Complexidade média e o último passo é justificado.

2 Análise de complexidade Novamente. Temos Pr[X = i] = 2(i − 1)/(n(n − 1)). obtemos a recorrência X Tn = n + Pr[X = i] (Ti−1 + Tn−i ) 1≤i≤n com base Tn = 0 para n ≤ 1. respectivamente: toda permutação ocorre com a mesma probabilidade e o mesmo número de vezes (Knuth (1998. Escolhe o maior dos dois primeiros elementos2 . p. 1. Temos Pr[X = i] = 1/n. 72). o último passo é o mais difı́cil de justificar. Como Pr[X = i] não depende do i a equação acima vira X Tn = n − 1 + 2/n Ti 0≤i<n (com uma comparação a menos no particionamento). 2005. A probabilidade de escolher o i-gésimo elemento como pivô depende da estratégia da escolha. A mesma partição que aplicamos acima leva a X Pr[d](desemp[QS](dl ) + desemp[QS](dr )) d∈Dn X X = Pr[d](desemp[QS](dl ) + desemp[QS](dr )) i 1≤i≤n d∈Dn X 1 X = (desemp[QS](dl ) + desemp[QS](dr )) |D| i 1≤i≤n d∈Dn X |Di | n = (cm [QS](i − 1) + cm [QS](n − i)) |D| 1≤i≤n X = Pr[X = i](cm [QS](i − 1) + cm [QS](n − i)) 1≤i≤n é o penúltimo passo é correto. p. 60 . Vamos estudar dois casos. Um algoritmo prático tem que considerar o caso que um ou mais elementos são iguais (Toscani and Veloso. 2. porque a média do desempenho as permutações dl e dr é a mesma que sobre as permutações com i − 1 e n − i. 2 Supomos para análise que todos elementos são diferentes. Escolhe o primeiro elemento como pivô. 119) tem mais detalhes). Se denotamos o desempenho com Tn = cp [QS](n).

2. • Dois exemplos – Escolhe o primeiro elemento: Pr[X = i] = 1/n.19 Vamos determinar a probabilidade de escolher o pivô Pr[X = i] no caso n = 3 explicitamente: Permutação Pivô 123 2 132 3 213 2 231 3 312 3 321 3 61 . – Escolhe o maior dos primeiros dois elementos diferentes: Pr[X = i] = 2(i − 1)/(n(n − 1)).3 Complexidade média X Tn = n + 2/(n(n − 1)) (i − 1) (Ti−1 + Tn−i ) 1≤i≤n X = n + 2/(n(n − 1)) i (Ti + Tn−i−1 ) 0≤i<n X X = n + 2/(n(n − 1)) iTi + iTn−i−1 0≤i<n 0≤i<n X X = n + 2/(n(n − 1)) iTi + (n − i − 1)Ti 0≤i<n 0≤i<n X = n + 2/n Ti 0≤i<n Recorrência • A solução final depende da escolha do pivô. • Denota Tn = cm [QS](n) • Ambas soluções chegam (quase) na mesma equação recorrente X Tn = n + 2/n Ti 0≤i<n Exemplo 2.

X Tn = n + 1 + 2/n Ti para n > 0 0≤i<n multiplicando por n obtemos X nTn = n2 + n + 2 Ti 0≤i<n a mesmo equação para n − 1 é X (n − 1)Tn−1 = (n − 1)2 + n − 1 + 2 Ti para n > 1 0≤i<n−1 subtraindo a segunda da primeira obtemos nTn − (n − 1)Tn−1 = 2n + 2Tn−1 para n > 0. em ambos casos temos a complexidade média de Θ(n ln n). verificando n = 1 nTn = (n + 1)Tn−1 + 2n multiplicando por 2/(n(n + 1)) 2 2 4 Tn = Tn−1 + n+1 n n+1 62 .2 Análise de complexidade Logo temos as probabilidades Pivô i 1 2 3 ♦ Pr[X = i] 0 1/3 2/3 Resolver a equação • A solução da recorrência X Tn = n + 1 + 2/n Ti 0≤i<n é Tn = Θ(n ln n) • Logo.

14 (Alg2) Entrada Um problema de tamanho n. 63 .) Exercı́cio 2. .1 Qual a complexidade pessimista dos seguintes algoritmos? Algoritmo 2. 1 f o r i := 1 .4 Exercı́cios (Soluções a partir da página 238. . n do 2 f o r j := 1 .13 (Alg1) Entrada Um problema de tamanho n. .4 Exercı́cios substituindo An = 2Tn /(n + 1) 2 X 4 An = An−1 + = n+1 i+1 1≤i≤n e portanto X 1 Tn = 2(n + 1) i+1 1≤i≤n n = 2(n + 1)(Hn − ) n+1 = Θ(n ln n) ♦ 2. 2i 3 o p e r a ç õ e s c o n s t a n t e s 4 j := j + 1 // i t e r a ç õ e s com v a l o r e s ı́mpares de j 5 end f o r 6 end f o r Algoritmo 2. . 2.

17 (Alg5) Entrada Um problema de tamanho n. 1 f o r i := 1 . . n do 2 f o r j := i .16 (Alg4) Entrada Um problema de tamanho n. 2i 3 o p e r a ç õ e s com complexidade O(j 2 ) 4 j := j + 1 5 end f o r 6 end f o r Algoritmo 2. . . n do 64 . n 3 o p e r a ç õ e s com complexidade O(2i ) 4 end f o r 5 end f o r Algoritmo 2. .15 (Alg3) Entrada Um problema de tamanho n. n do 2 j := 1 3 while j ≤ i do 4 o p e r a ç õ e s com complexidade O(2j ) 5 j := j +1 6 end f o r 7 end f o r Algoritmo 2.2 Análise de complexidade 1 f o r i := 1 . 1 f o r i := 1 . . . . . n do 2 f o r j := 1 . . . 1 f o r i := 1 . . .

dado uma sequência a1 . an com ai ∈ N deter- mina um conjunto de ı́ndices C ⊆ [1. .4 Exercı́cios 2 j := i 3 while j ≤ n do 4 o p e r a ç õ e s com complexidade O(2j ) 5 j := j +1 6 end f o r 7 end f o r Exercı́cio 2. . Qual o problema? Exercı́cio 2. .4 Escreve um algoritmo que. . Rapidez chegou no seguinte resultado: Supomos que Tn = O(n) obtemos X Tn = n − 1 + 2/n O(i) 0≤i<n = n − 1 + 2/n O(n2 ) = n − 1 + O(n) = O(n) e logo. n] tal que . a complexidade média do Quicksort é O(n). . .2 Tentando resolver a recorrência X Tn = n − 1 + 2/n Ti 0≤i<n que ocorre na análise do Quicksort (veja exemplo 2. Qual a complexidade pessimista dele considerando uma com- paração como operação básica? Exercı́cio 2. 2. .18). an . o aluno J. .3 Escreve um algoritmo que determina o segundo maior elemento de uma sequência a1 .

.

.

X X .

.

.

.

.

ai − ai .

.

.

i∈C i6∈C .

é mı́nimo. Qual a complexidade pessimista dele? Exercı́cio 2.5 Qual o número médio de atualizações no algoritmo 65 .

. supondo que todo valor em cada posição da sequência tem a mesma probabilidade? Qual o número médio com a distribuição P [1] = 1/2. . n do 3 i f i > bn/2c then 4 s := s+i 5 end i f 6 end f o r Exercı́cio 2. .18 (Count6) Entrada Uma sequência a1 . . Tanto nós quanto folhas contém chaves. .8 Usando a técnica para resolver a recorrência (veja p. n do 3 i f ai = 6 then 4 k := k + 1 5 end i f 6 end f o r Qual o número médio de atualizações k := k + 1.).6 Algoritmo 2. . .7 Suponha um conjunto de chaves numa árvore binária completa de k nı́veis e suponha uma busca binária tal que cada chave da árvore está buscada com a mesma probabilidade (em particular não vamos considerar o caso que uma chave buscada não pertence à árvore. Saı́da O número de elementos tal que ai = 6. P [2] = P [3] = P [4] = P [5] = P [6] = 1/10? Exercı́cio 2. Qual o número médio de comparações numa busca? Exercı́cio 2. 6]. . . 2 Análise de complexidade 1 s := 0 2 fo r i = 1. . . an com ai ∈ [1. 62) X Tn = n + 1 + 2/n Ti 0≤i<n 66 . . 1 k := 0 2 f o r i = 1.

67 . 2.4 Exercı́cios resolve as recorrências X Tn = n + 2/n Ti 0≤i<n X Tn = n − 1 + 2/n Ti 0≤i<n explicitamente.

.

Parte II Projeto de algoritmos 69 .

.

3 Introdução Resolver problemas • Modelar o problema – Simplificar e abstrair – Comparar com problemas conhecidos • Inventar um novo algoritmo – Ganhar experiência com exemplos – Aplicar ou variar técnicas conhecidas (mais comum) Resolver problemas • Provar a corretude do algoritmo – Testar só não vale – Pode ser informal • Analisar a complexidade • Aplicar e validar – Implementar. testar e verificar – Adaptar ao problema real – Avaliar o desempenho 71 .

.

• Idéia principal: Decide localmente.3).) Algoritmos gulosos • Algoritmos gulosos se aplicam a problemas de otimização.4 Algoritmos gulosos Radix omnium malorum est cupiditas. 2005. (Seneca) 4. • Um algoritmo guloso constrói uma solução de um problema – Começa com uma solução inicial. . . P Solução Números c1 . • Por causa da localidade: Algoritmos gulosos freqüentemente são apro- priados para processamento online. – Melhora essa solução com uma decisão local (gulosamente!).1. 5. – Nunca revisa uma decisão. Trocar moedas Troca mı́nima Instância Valores (de moedas ou notas) v1 > v2 > · · · > vn = 1. . 73 .1 Introdução (Veja (Toscani and Veloso. cap. . uma soma s. cn tal que s = 1≤i≤n ci vi P Objetivo Minimizar o número de unidades 1≤i≤n ci .

4 Algoritmos gulosos A abordagem gulosa 1 fo r i:=1. Sejam os divisores vi = fi vi+1 com fi ≥ 2 para 1 ≤ i < n e define fn = vn = 1. . Logo cada valor tem a representação vi = fi fi+1 fi+2 · · · fn . v2 = 157. Prova. No primeiro exemplo. uma contradição com a minimalidade da solução (observe que isso somente é possı́vel porque os fi são números inteiros. v2 = 100.1 Se vi+1 |vi para 1 ≤ i < n a solução gulosa é mı́nima.1 A solução do algoritmo guloso é a única que satisfaz X ci vi < vm−1 i∈[m. obtemos c1 = 0.1 Com v1 = 500. n do 2 ci := bs/vi c 3 s := s − ci vi 4 end for Exemplo Exemplo 4. c2 = 3.) Proposição 4. parece que a abordagem gulosa acha a melhor solução. v3 = 0. v3 = 1.n] para m ∈ [2. (Ela é chamada a solução canônica. existe uma solução melhor: v1 = 0. senão o resto depois da substituição pode ser fracional e tem quer ser distribuı́do pelos valores menores 74 . . . por exemplo no primeiro sis- tema do exemplo acima. Lema 4. . c4 = 1. cn uma solução mı́nima. v3 = 25. . v2 = 0. v5 = 1 e s = 3. v2 = 2. porque o algoritmo guloso também acha soluções para outros sistemas de moedas. c3 = 0.14. . . . essa condição não é necessária. obtemos v1 = 1. Com v1 = 300. c5 = 4. Qual a diferença? ♦ Uma condição simples é que todos valores maiores são múltiplos inteiros dos menores. No segundo exemplo. n]. A contribuição de cada valor satisfaz ci vi < vi−1 senão seria possı́vel de substituir fi−1 unidades de vi para uma de vi−1 . v3 = 14. Seja c1 . v4 = 10.

. . para um grande número de problemas não tem algoritmo guloso ótimo.n] X X = vi−1 − vi i∈[m.n] = vm−1 − vn = vm−1 − 1 < vm−1 Agora aplique lema 4.1 (Subestrutura ótima) Um problema de otimização tem subestrutura ótima se uma solução ótima (mı́nima ou máxima) do problema consiste em soluções ótimas das subproble- mas. Definição 4. • Infelizmente.n] i∈[m. 75 .n] i∈[m. porque um subcaminho também é mais curto (senão seria possı́vel de obter um caminho ainda mais curto). Logo ci ≤ fi−1 − 1 e temos X X ci vi ≤ (fi−1 − 1)vi i∈[m.1. O caminho mais curto v1 v2 .  Otimalidade da abordagem gulosa • A pergunta pode ser generalizada: Em quais circunstâncias um algo- ritmo guloso produz uma solução ótima? • Se existe um solução gulosa: freqüentemente ela tem uma implementação simples e é eficiente. Exemplo 4. • A teoria de matroides e greedoides estuda as condições de otimalidade de algoritmos gulosos.n] i∈[m.1 Introdução que pode causar um aumento de unidades em total).n] X X = fi−1 vi − vi i∈[m.2 Considere caminhos (simples) em grafos. • Uma condição (que se aplica também para programação dinâmica) é a subestrutura ótima. vn entre dois vértices v1 e vn tem subestrutura ótima. 4.

por exemplo.1 (Solução genérica de problemas com subestrutura ótima Entrada Uma instância I de um problema. Se sabemos como esten- der uma solução de um subproblema para uma solução de todo problema. o algoritmo guloso evite resolver todos subproblemas. a subestrutura ótima fornece um algoritmo genérico da forma Algoritmo 4. ♦ Para aplicar a definição 4.1 temos que conhecer (i) o conjunto de subpro- blemas de um problema e (ii) provar. não precisa ser o caminho mais longo. Por exemplo no grafo i// 1 j //  //  //  / 1 //  1 //   //   k o caminho mais longo entre i e j é ikj. o caminho mais longo entre dois vértices v1 . um algoritmo guloso é caracterizado por uma subestrutura ótima e a caracterı́stica adicional. vn . mas o subcaminho kj não é o subca- minho mais longo entre k e j. 1 r e s o l v e ( I ):= 2 S ∗ := n i l { melhor solução } 3 f o r t o d o s subproblemas I 0 de I do 4 S 0 := r e s o l v e ( I 0 ) 5 e s t e n d e S 0 para uma s o l u ç ã o S de I 6 i f S 0 é a melhor s o l u ç ã o then 7 S ∗ := S 8 end i f 9 end f o r Informalmente. .4 Algoritmos gulosos Do outro lado. Saı́da Uma solução ótima S ∗ de I. . Portanto. que uma solução ótima contém uma (sub-)solução que é ótima para um subproblema. . vn não tem subestrutura ótima: o subcaminho v2 . 76 . que podemos escolher o subproblema que leva a solução ótima através de uma regra simples. .

2 Algoritmos em grafos 4. 4. P Objetivo Minimiza os custos e∈EH c(e). 77 .2 Algoritmos em grafos Uma subestrutura ótima é uma condição necessária para um algoritmo guloso ou de programação dinâmica ser ótima. • Um subgrafo conexo com custo mı́nimo deve ser uma árvore (por quê?). • Grafo não conexo: Busca uma árvore em todo componente (floresta mı́nima). pesos c : E → R+ . 4.1 Árvores espalhadas mı́nimas Motivação Pontes para Polinésia Francesa! Árvores espalhadas mı́nimas (AEM) Árvore espalhada mı́nima (AEM) Instância Grafo conexo não-direcionado G = (V. E). mas ela não é suficiente. Solução Um subgrafo H = (VH .2. EH ) conexo.

• Como achar uma solução ótima? • Observação importante Lema 4. Nossa afirmação: Podemos substituir e0 com e. V \ S 6= ∅). porque T é uma árvore. Na prova vamos supor. O único ciclo possı́vel é o caminho entre u e v em T com o arco e. Prova. porque ele não contém um ciclo. v} entre S e V \ S não faz parte de um AEM T . porque há um caminho entre u e v sem e. Isso sempre é possı́vel. Prova da afirmação: Se substituirmos e0 por e obtemos um grafo T 0 . ambos sem usar e0 .2 (Corte) Considere um corte V = S ∪ V \ S (com S 6= ∅. O novo grafo é conexo. O novo grafo também é uma árvore.  78 . em contradição com a minimalidade do T . com dois sub-caminhos de u para u0 e de v 0 para v.4 Algoritmos gulosos Aplicações • Redes elétricas • Sistemas de estradas • Pipelines • Caixeiro viajante • Linhas telefônicas alugadas Resolver AEM • O número de árvores espalhadas pode ser exponencial. O arco mı́nimo entre S e V \ S faz parte de qualquer AEM. Suponha um corte S tal que o arco mı́nimo e = {u. Como e é mı́nimo. a partir de um caminho em T que usa e0 um novo caminho que usa um desvio sobre e. porque para cada par de nós ou temos um caminho já em T que não faz uso de e0 ou podemos obter. ele custa menos. que todos pesos são diferentes. Em T existe um caminho de u para v que contém ao menos um arco e0 que cruza o corte.

2. Começa sem arcos. Começa com algum nó e repetidamente adicione o nó ainda não alcançável com o arco de custo mı́nimo de algum nó já alcançável: algoritmo de Prim. AEM: Algoritmo de Prim Algoritmo 4. 79 .2 Algoritmos em grafos Prova Resolver AEM • A caracterı́stica do corte possibilita dois algoritmos simples: 1. EG ) com pesos c : VG → R+ P Saı́da Uma árvore T = (V. ET ) com custo e∈ET c(e) mı́nimo.2 (AEM-Prim) Entrada Um grafo conexo não-orientado G = (V. e repetidamente adicione o arco com custo mı́nimo que não produz um ciclo: algoritmo de Kruskal. 4.

4 Algoritmos gulosos 1 V 0 := {v} para um v ∈ V 2 ET := ∅ 3 while V 0 6= V do 4 e s c o l h e e = {u.3 Resultado dos algoritmos de Prim e Kruskal para Polinésia Francesa: O mesmo! ♦ 80 .3 (AEM-Kruskal) Entrada Um grafo conexo não-orientado G = (V. v} com c u s t o mı́nimo 5 e n t r e V 0 e V \ V 0 ( com u ∈ V 0 ) 6 V := V 0 ∪ {v} 0 7 ET := ET ∪ {e} 8 end while AEM: Algoritmo de Kruskal Algoritmo 4. EG ) com pesos c : VG → R+ P Saı́da Uma árvore T = (V. ET ) não é conexo do 3 e s c o l h a e com c u s t o mı́nimo que não produz cı́ c l o 4 ET := ET ∪ {e} 5 end while Exemplo 4. ET ) com custo e∈ET c(e) mı́nimo. 1 ET := ∅ 2 while (V.

EG ) com pesos c : VG → R+ P Saı́da Uma árvore T = (V. w). w)) 8 end f o r 9 ET := ET ∪ {{u. ET ) com custo e∈ET c(e) mı́nimo. v) (chave e elemento). min() { (u. • Ambas operações podem ser implementadas com custo O(log n). c(v.atualiza(e. c(v. • Caso um novo nó seja selecionado: atualiza as distâncias. 4. v). 1 ET := ∅ 2 Q := {((v. c) := Q. u). c) com c mı́nimo. u)) | u ∈ N (v)} { nós alcancáveis } 3 Q := Q ∪ {((u. v) é arco mı́nimo } 6 f o r w ∈ N (v) do 7 Q.4 (AEM-Prim) Entrada Um grafo conexo não-orientado G = (V. • Nós que não são acessı́veis em um passo têm distância ∞. – Operação Q. – Operação Q.atualiza((v. ∞) | u ∈ V \ N (v) \ {v}} { nós restantes } 4 while Q 6= ∅ do 5 ((u. min() remove e retorna (e. AEM: Algoritmo de Prim Algoritmo 4. Implementação do algoritmo de Prim • Estrutura de dados adequada: – Fila de prioridade Q de pares (e. c0 ) modifica a chave de e para v 0 caso v 0 é menor que a chave atual. u).2 Algoritmos em grafos Implementação do algoritmo de Prim • Problema: Como manter a informação sobre a distância mı́nima de forma eficiente? • Mantenha uma distância do conjunto V 0 para cada nó em V \ V 0 . v}} 10 end while 81 .

• união(C1 . . vn }. • O laço 6–8 precisa no total menos que m iterações. Para esta implementação é necessário de manter conjuntos que representam nós conectados de maneira eficiente. 82 .2 Caminhos mais curtos Caminhos mais curtos • Problema freqüente: Encontra caminhos mais curtos em um grafo. • cp [AEM-Prim] = O(n log n + m log n) = O(m log n) Uma implementação do algoritmo de Kruskal em tempo O(m log n) também é possı́vel. . Solução Uma atribuição d : V → R+ da distância do caminho mais curto d(t) de s para t. • C := busca(e): retorna o conjunto do elemento e. – entre um nó e todos outros (inglês: single-source shortest paths. . O(1) e O(log n) (para n elementos) respectivamente. • Variações: Caminho mais curto – entre dois nós. C2 ): junta os conjuntos C1 e C2 . 4. Essas operações podem ser implementados em tempo O(1). Isso leva a uma estrutura de dados conhecida como Union-Find que tem as operações • C := cria(e): cria um conjunto com único elemento e. Caminhos mais curtos Caminhos mais curtos Instância Um grafo direcionado G = ({v1 .2. .4 Algoritmos gulosos Algoritmo de Prim • Complexidade do algoritmo com o refinamento acima: • O laço 4–9 precisa n − 1 iterações. E) com função de custos c : E → R+ e um nó inicial s ∈ V . – entre todas pares (inglês: all pairs shortest paths. APSP). SSSP).

2. Solução Um conjunto compatı́vel C ⊆ S de intervalos. 4). Grafos de intervalo são perfeitos.3 Algoritmos de seqüenciamento We follow closely (Kleinberg and Tardos. 4. i2 ∈ C temos i1 ∩ i2 = ∅. 2005. o problema do clique máxima também pode ser resolvida da forma acima. ch. Logo. • From Genes to Archaeological Digs and from Traffic Lights to Childhood Development: The Many Applications of Interval Graphs • Um grafo é perfeito se a cardinalidade da clique máxima é igual ao seu número cromático (número de cores em uma coloração mı́nima) e isso é verdade para todos sub-grafos. cada com começo ci e fim fi tal que ci < fi . Começa com uma estimativa viável: d(s) = 0 e d(t) = ∞ para todo nó em V \ {s}. Objetivo Maximiza a cardinalidade |C|. Repete até não ter mais arestas desse tipo. 4. Depois escolhe uma aresta e = (u. 3. cada par i1 . i.3 Algoritmos de seqüenciamento Aproximação: Uma idéia 1. 1 ≤ i ≤ n}.e. v) ∈ E tal que d(u) + c(e) ≤ d(v) e atualiza d(v) = d(u) + c(e). Seqüenciamento de intervalos Considere o seguinte problema Seqüenciamento de intervalos Instância Um conjunto de intervalos S = {[ci . (inglês: interval scheduling) 83 . fi ]. Esse algoritmo é correto? Qual a complexidade dele? • Greedy set cover (ver: Dasgupta+Kleinberg/Tardos).

cada com começo ci e fim fi tal que ci < fi . Saı́da Um conjunto máximo de intervalos compatı́veis C. [cn . Prova por indução. Prova. fi ] | 1 ≤ i ≤ n}. temos f1 ≤ f10 . . .2 Para todo 1 ≤ i ≤ n temos fi ≤ fi0 . Passo: Seja fi ≤ fi0 com i < n. . . [c0m . Como O é ótimo. . Proposição 4. 1 C := ∅ 2 while S 6= ∅ do 3 S e j a [c. . ambos em ordem crescente. f ] 6= ∅} 6 end while 7 return C Seja C = ([c1 . f ] 5 S := S \ {i ∈ S | i ∩ [c. O próximo intervalo 84 . Base: Como o algoritmo guloso escolhe o intervalo cujo terminação é mı́nima. .4 Algoritmos gulosos Como resolver? • Qual seria uma boa estratégia gulosa para resolver o problema? • Sempre selecionada o intervalo que – que começa mais cedo? – que termina mais cedo? – que começa mais tarde? – que termina mais tarde? – mais curto? – tem menos conflitos? Implementação Algoritmo 4. fn ]) o resultado do algoritmo Seqüenciamento de intervalos e O = ([c01 . temos n ≤ m. . f1 ]. fm 0 ]) seqüenciamento máximo. f10 ].5 (Seqüenciamento de intervalos) Entrada Um conjunto de intervalos S = {[ci . O algoritmo guloso vai escolher entre os inter- valos que começam depois fi o com terminação mı́nima. f ] ∈ S com f mı́nimo 4 C := C ∪ [c.

CIM Instância Um grafo não-direcionado G = (V. porque ele começa depois fi0 e fi0 ≥ fi . uma contradição com o fato.e. E). que o algoritmo somente termina se não sobram intervalos compatı́veis. Suponha que o algoritmo guloso retorna menos intervalos C que um seqüenciamento ótimo O. (inglês: maximum independent set. fi+1 ≤ fi+1 .3 O seqüenciamento do algoritmo guloso é ótimo.  Proposição 4.3 Algoritmos de seqüenciamento [c0i+1 . MIS) 85 .2. Como O tem mais intervalos.  Complexidade • Uma implementação detalhada pode – Ordenar os intervalos pelo fim deles em tempo O(n log n) – Começando com intervalo 1 sempre escolher o intervalo atual e depois ignorar todos intervalos que começam antes que o intervalo atual termina. Solução Um conjunto independente M ⊆ V . 4. i. m2 ∈ V temos {m1 . Pela proposição 4. – Portanto o complexidade pessimista é O(n log n). m2 } 6∈ E. Conjunto independente máximo Considere o problema Conjunto independente máximo. – Isso pode ser implementado em uma varredura de tempo O(n). Portanto. Objetivo Maximiza a cardinalidade |M |. existe mais um intervalo que poderia ser adicionado ao conjunto C pelo algoritmo guloso. o último (n-ésimo) intervalo do C termina antes do último intervalo de O. o próximo intervalo escolhido pelo algoritmo guloso 0 0 termina antes de fi+1 . Prova. i. todo m1 .e. m0i+1 ] do seqüenciamento ótimo está entre eles.

• Seja d o maior número de intervalos super-posicionados (a profundidade do problema). i2 } | i1 . Variação do problema Considere uma variação de Seqüenciamento de intervalos: Particionamento de intervalos Instância Um conjunto de intervalos S = {[ci . Observação • Uma superposição de k intervalos implica uma cota inferior de k rótulos. i1 ∩ i2 6= ∅} • Grafos que podem ser obtidos pelo intervalos são grafos de intervalo.4 Algoritmos gulosos Grafos de intervalo • Uma instância S de seqüenciamento de intervalos define um grafo não- direcionado G = (V. resolvemos CIM para grafos de intervalo! • Sem restrições. Objetivo Minimiza o número de rótulos diferentes. i2 ∈ S. fi ]. • Um conjunto compatı́vel de intervalos corresponde com um conjunto independente nesse grafo. • É possı́vel atingir o mı́nimo d? Algoritmo 86 . E) com V = S. 1 ≤ i ≤ n}. • Portanto. CIM é NP-completo. E = {{i1 . Solução Uma atribuição de rótulos para intervalos tal que cada conjunto de intervalos com a mesma rótula é compatı́vel. cada com começo ci e fim fi tal que ci < fi .

d] estão em uso pelo intervalos conflitantes. cada com começo ci e fim fi tal que ci < fi . • De fato ele precisa exatamente d rótulos. 1 ≤ i ≤ n}. . fi ]. Por qûe? • Qual a complexidade dele? Observações: (i) Suponha que o algoritmo precise mais que d rótulos. . E). 1 Ordene S em ordem de começo c r e s c e n t e .6 (Particionamento de intervalos) Instância Um conjunto de intervalos S = {[ci . Coloração de grafos Considere o problema Coloração mı́nima Instância Um grafo não-direcionado G = (V. n do 3 E x c l u i r ó t u l o s de i n t e r v a l o s 4 precedentes c on f li t an t es 5 A t r i b u i ao i n t e r v a l o i o número 6 i n t e i r o mı́nimo ≥ 1 que s o b r a Corretude • Com profundidade d o algoritmo precisa ao menos d rótulos. . Solução Uma atribuição de rótulos para os intervalos tal que cada con- junto de intervalos com a mesma rótula é compatı́vel. Portanto a complexidade é O(n log n). 4. . 87 . uma contradição com o fato que a profundidade é d. Então existe um intervalo tal que todos números em [1.3 Algoritmos de seqüenciamento Algoritmo 4. 2 f o r i := 1. (ii) Depois da ordenação em O(n log n) a varredura pode ser implementada em O(n) passos. Objetivo Minimiza o número de rótulos diferentes.

• Particionamento de intervalos resolve o problema Coloração mı́nima para grafos de intervalo. • Como comprimir? – Com código fixo: A = 00. • Coloração mı́nima para grafos sem restrições é NP-completo. use códigos de dife- rente comprimento A G T C . C = 11.e.16 . . Homo sapiens guanine nucleotide bin- ding protein) GAT CCCT CCGCT CT GGGGAGGCAGCGCT GGCGGCGG . uma atribuição de cores c : V → C tal que c(v1 ) 6= c(v2 ) para {v1 . Objetivo Minimiza o número de cores |C|. G = 01. T = 10.30 . i.18 . . v2 } ∈ E. 4.36 1 “bp” é a abreviação do inglês “base pair” (par de bases) 88 . com 1666bp1 .4 Algoritmos gulosos Solução Uma coloração de G. Resultado: 2b/bp e 3332b total. – Melhor abordagem: Considere as freqüências.4 Tópicos Compressão de dados • Sequência genética (NM 005273.2.

• Observação: Esses códigos correspondem a árvores binárias.16 × 3 = 1. A = 110. C = 10 • Desvantagem: Ambı́guo! 01 = T A ou 01 = G? • Tentativa 2 C = 0. Na seguinte imple- mentação.30 × 2 + 0. Códigos livre de prefixos • Os exemplos mostram – Dependendo das freqüências. Essas considerações levam diretamente a um algoritmo.36 × 1 + 0. 4. vamos representar árvores binárias como estrutura da dados abs- trata que satisfaz 89 . A = 1. a árvore termina nessa posição com uma folha para esse código. G = 01. Esse processo continua em cada sub-árvore considerando os demais bits. • 0 || BBB1 ~|| B • 0 ~~ >>>1 C ~~~ > G •> >>1 0  > A T Cada código livre de prefixo pode ser representado usando uma árvore binária: Começando com a raiz. – Para evitar ambigüedades. T = 111 • Custo: 0. 3299b total.98b/bp. o sub-árvore da esquerda representa os códigos que começam com 0 e a sub-árvore da direita representa os códigos que começam com 1. um código com comprimento variável pode custar menos.4 Tópicos Códigos: Exemplos • Tentativa 1 T = 0.18 × 3 + 0. Caso todos bits de um código foram considerados. G = 10. nenhum prefixo de um código pode ser outro código: ele é livre de prefixos (inglês: prefix-free).

temos também Proposição 4.Nil). P r e f i x T r e e ( C2 ) ) Contrariamente. Prova. 90 . • A quantidade de informação contido num sı́mbolo que ocorre com freqüência f é − log2 f .  Qual o melhor código? • A teoria de informação (Shannon) fornece um limite. Vamos usar a abreviação Leaf ::= Node(Nil. ne- nhum código pode ser prefixo de outro: senão ocorreria como nó interno.4 O conjunto das folhas de cada árvore binária corresponde com um código livre de prefixo.7 (PrefixTree) Entrada Um conjunto de códigos C livre de prefixos. Dado uma árvore binária com as folhas representando códigos. Algoritmo 4. Saı́da Uma árvore binária.Bintree) uma folha sendo um nó sem filhos. 1 i f |C |= 0 then 2 return N i l { não tem árvore } 3 end i f 4 i f C = {} then 5 return L e a f { único código vazio } 6 end i f 7 E s c r e v e C = 0C1 ∪ 1C2 8 return Node ( P r e f i x T r e e ( C1 ) .4 Algoritmos gulosos BinTree ::= Nil | Node(BinTree. representando os códigos. logo o número médio de bits transmitidos (para um número grande de sı́mbolos) é X H=− fi log2 fi .

8 (Huffman) Entrada Um alfabeto de sı́mbolos S com uma freqüência fs para cada s ∈ S. Logo: Podemos substituir eles com um nó cujo freqüência é a soma dos dois. H ≈ 0. •B1 ⇒ • II BBB II1 ! $ •? f i + fj 0 ??1   fi fj Algoritmo Algoritmo 4. B = 2/3. os dois sı́mbolos com menor freqüência ocorrem como irmãos no nı́vel mais alto.4 Tópicos • H é um limite inferior para qualquer código.92. Saı́da Uma árvore binária que representa o melhor código livre de prefixos para S. •@1 ⇒ •@1 @@ @@   • • 0 ~ @@1 ∗ ~~ @ •@ • • 0 ~ @@1 ~~  • • • Observação 2: Em uma solução ótima.92b mas o código ótimo precisa ao menos 1b por sı́mbolo. 91 . Com A = 1/3. • Nem sempre é possı́vel atingir esse limite. 4. Como achar o melhor código? • Observação 1: Uma solução ótima é uma árvore completa. • Nosso exemplo: H ≈ 1.

T. M. K.. min() com b1 = Node(fi .021 0. N. S.201 b/bp (compare com log2 20 ≈ 4. R. Nemhauser e Trot- ter (Magazine et al. Q. . E. L. b1 . C.add(Node(fi + fj . 1975) dão critérios necessários e suficientes para uma solução gulosa do problema de troca ser ótima. W. .010 0. com 2900352bp.059 0.061 0.4 Algoritmos gulosos 1 Q := {Leaf(fs ) | s ∈ S} { f i l a de prioridade } 2 while |Q| > 0 do 3 b1 := Q.050 0.096 M N P Q R S T V W Y 0. F. G.056 0.090 0. V. Y } que ocorrem com as freqüências A C D E F G H I K L 0.066 0.013 0.055 0. b2 )) 6 end while Exemplo 4. 92 .4 Saccharomyces cerevisiae Considere a sequência genética do Saccharomyces cerevisiae (inglês: baker’s yeast) M SIT N GT SRSV SAM GHP AV ERY T P GHIV CV GT HKV EV V . D. bj1 .039 0.034 Resultados O algoritmo Huffman resulta em A C D E F G H I K L 0010 100110 1110 0101 0000 1000 100111 1101 0011 100 M N P Q R S T V W Y 000111 1011 11011 01011 10111 1111 0001 1010 000110 10110 que precisa 4. O alfabeto nessa caso são os 20 amino-ácidos S = {A. bi2 ) 4 b2 := Q. ♦ 4. Dado um sistema de moedas. min() com b2 = Node(fj .043 0.045 0.073 0.5 Notas O algoritmo guloso para sistemas de moedas Magazine. bi1 . bj2 ) 5 Q := Q. I. P.065 0.32).022 0.045 0.058 0. H.

(Fonte: (Kleinberg and Tardos. Exercı́cio 4. O pro- blema: Dado uma outra sequência. prova a corretude e analise a complexidade dele. 2008) estudam sistemas de moedas totalmente gulosos.. decida o mais rápido possı́vel se ela é uma subsequência da primeira. . por exemplo. Cowen et al. O problema: Posiciona o número mı́nimo de bases de comunicação ao longo da estrada.6 Exercı́cios (Soluções a partir da página 241. com a restriçaõ que cada casa tem quer ser ao máximo 4 quilômetros distante de uma base.2 (Comunicação) Imagine uma estrada comprida (pensa em uma linha) com casas ao longo dela. Um sistema de moedas tal que todo su- fixo é guloso se chama totalmente guloso. Suponha que todas casas querem acesso ao comunicação com celular. 4. 2005)). Uma certa ação pode acontecer mais que uma vez nessa sequência. se o sistema é guloso. prova a corretude a analise a complexidade dele. . 2005) apresentou um algoritmo que descobre em tempo O(n3 log2 c1 ).6 Exercı́cios Pearson (Pearson. 93 .) Exercı́cio 4. Inventa um algoritmo eficiente. . as transações feitos na bolsa de forma compra Dell. 4. Achar um algoritmo eficiente (de complexidade O(m + n) com sequência de tamanho n e m). (Cowen et al. 2005)). (Fonte: (Kleinberg and Tardos. vende HP.1 (Análise de series) Suponha uma série de eventos. compra Google.

.

temos Fn = Fn−1 + Fn−2 | {z } | {z } população antiga descendentes com a recorrência completa ( Fn−1 + Fn−2 caso n ≥ 2 Fn = 1 caso n ∈ {0. Uma implementação recursiva simples para calcular um número de Fibonacci é 1 f i b ( n ) := 2 i f n ≤ 1 then 3 return 1 4 else 5 return f i b ( n − 1)+ f i b ( n − 2 ) 6 end i f 7 end Qual a complexidade dessa implementação? Temos a recorrência de tempo ( T (n − 1) + T (n − 2) + Θ(1) caso n ≥ 2 T (n) = Θ(1) caso contrário. Depois ele gera um outro par a cada mês seguinte. quantos pares temos depois de n meses? n 0 1 2 3 4 5 6 ··· # 1 1 2 3 5 8 13 ··· Como os pares somente produzem filhos depois de dois meses. 5 Programação dinâmica 5.1 Introdução Temos um par de coelhos recém-nascidos. 1} Os números definidos por essa recorrência são conhecidos como so números Fibonacci. Supondo que os coelhos nunca morrem. Um par recém-nascido se torna fértil depois um mês. 95 . Logo. os primeiros descendentes nascem em dois meses.

e sabemos que Fn = Ω(2n ) (outra indução). 5 Programação dinâmica É simples de ver (indução!) que T (n) ≥ Fn .) Qual o problema dessa solução? De um lado temos um número exponencial de caminhos das chamadas recursivas  %  %  ! Fn Fn−1 Fn−2 B Fn−3 9 Fn−4 B :· · · mas somente um número polinomial de valores diferentes! Idéia: usar uma cache! 1 f0 := 1 2 f1 := 1 3 fi := ⊥ para i ≥ 2 4 5 f i b ( n ) := 6 i f fn = ⊥ then 7 fn := f i b ( n − 1)+ f i b ( n − 2 ) 8 end i f 9 return fn 10 end Exemplo de uma execução: 4 : f5D vvv DD DD vvv DD zv " 3 : f4H f3 vv HH v HH vv HH zvv H$ 2 : f3H f2 vv HH v HHH vv HH zvv $ 1 : f2H f1 zz HH z HHH zz HH |zz $ f1 f0 96 . portanto a complexidade é exponencial. (A fórmula exata é  √ n  √ n   √ n  1+ 5 2 − 1−2 5  1+ 5  2 1  Fn = √ = √ +  5 5 2 e foi publicado por Binet em 1843.

5. evitando total- mente a cache 1 f i b ( n ) := 2 f := 1 3 g := 1 4 for i ∈ [2.1 Introdução f5 f4 f3 f2 f1 f0 Inicial ⊥ ⊥ ⊥ ⊥ 1 1 1 ⊥ ⊥ ⊥ 2 1 1 2 ⊥ ⊥ 3 2 1 1 3 ⊥ 5 3 2 1 1 4 8 5 3 2 1 1 O trabalho agora é O(n). bottom-up). podemos otimizar essa computação ainda mais. Tipicamente usa-se implementações ascendentes (ingl. n] do 5 fi := fi−1 + fi−2 6 end f o r 7 return fn 8 end Finalmente. linear! Essa abordagem se chama memoização: usamos uma cache para evitar recalcular resultados intermediários utilizados frequentemente. Uma implementação (ligeiramente) mais eficiente que preenche a “cache” de forma bottom-up é 1 f i b ( n ) := 2 f0 := 1 3 f1 := 1 4 for i ∈ [2. Essa implementação é top-down e corresponde exatamente à recorrência acima. inclusive o último para reduzir a complexidade de espaço. A sequência de imple- mentações no nosso exemplo dos números Fibonacci é tı́pico para algoritmos de programação dinâmica. Programação Dinâmica (PD) 1.e. Para aplicar PD o problema deve apresentar substrutura ótima (uma 97 . i. n] do 5 { invariante : f = Fi−2 ∧ g = Fi−1 } 6 g := f + g 7 f := g − f 8 { invariante : f = Fi−1 ∧ g = Fi } 9 end f o r A idéia de armazenar valores intermediários usados freqüentemente numa com- putação recursiva é uma das idéias principais da programação dinâmica (a outra senda o princı́pio de otimalidade. veja abaixo).

5. 2. Definir recursivamente o valor de uma solução ótima 3. Reduz o número total de sequências viáveis. Passos do desenvolvimento de um algoritmo de PD 1. 4.5 Programação dinâmica solução ótima para um problema contém soluções ótimas de seus sub- problemas) e superposição de subproblemas (reutiliza soluções de sub- problemas). Caracterizar a estrutura de uma solução ótima 2. Em alguns casos o algoritmo direto tem complexidade exponencial. en- quanto que o algoritmo desenvolvido por PD é polinomial. 6. descartando aquelas que sabidamente não podem resultar em sequências ótimas. Às vezes a complexidade continua exponencial. ao contrário dos métodos recursivos que são métodos descendentes. mas de ordem mais baixa. Idéias básicas da PD • Objetiva construir uma resposta ótima através da combinação das res- postas obtidas para subproblemas • Inicialmente a entrada é decomposta em partes mı́nimas e resolvidas de forma ascendente (bottom-up) • A cada passo os resultados parciais são combinados resultando respos- tas para subproblemas maiores. Construir uma solução ótima a partir de informações calculadas 98 . É útil quando não é fácil chegar a uma sequência ótima de decisões sem testar todas as sequências possı́veis para então escolher a melhor. 3. Calcular o valor de uma solução ótima em um processo ascendente 4. Pode ser aplicada a problemas NP-completos e polinomiais. até obter a resposta para o problema original • A decomposição é feita uma única vez. e os casos menores são tratados antes dos maiores • Este método é chamado ascendente.

. ik i de ı́ndices de X tais que. xm i e Y = hy1 . yn i. 5. C. B. . . . Bi é uma subsequência de X = hA. • Exemplo: Z = hB. y2 . temos xij = zj . D. A. . z2 . B. x2 . . zk i. C. . Ai Subsequência Comum Mais Longa • Definição do Problema da SCML SCML Instância Duas seqüencias X = hx1 . . D. A. Bi e Y = hB. para todo j = 1. . • Dadas duas sequências X e Y . A. C. Bi. é uma subsequência de X se existe uma sequência es- tritamente crescente hi1 . . xm i. k. Objetivo Maximizar o comprimento de Z.2. D. mas não precisam ser necessariamente consecutivos. • Exemplo: Z = hB. i2 . . . . .2 Comparação de sequências 5. . . D. C.2 Comparação de sequências 5. uma outra sequência Z = hz1 . . x2 . 99 . Y . . Bi é uma subsequência comum mais longa de X = hA. 2. A. B. . B. . . dizemos que uma sequência Z é uma subsequência comum de X e Y se Z é uma subsequência tanto de X quanto de Y . Solução Uma subsequência comum Z de X. . . • Exemplo de Aplicação: comparar dois DNAs X = ACCGGT CGAGT G Y = GT CGT T CGGAAT GCCGT T GCT CT GT AAA • Os caracteres devem aparecer na mesma ordem. . C.1 Subsequência Comum Mais Longa Subsequência Comum Mais Longa • Dada uma sequência X = hx1 .

Y ) = max{S(X. então zk = xm = yn e Zk−1 é uma SCML de Xm−1 e Yn−1 • Se xm 6= yn . Y ) a subsequências mais longa entre X e Y . m − 1) + Θ(1) operações. xm i e Y = hy1 . exponential no pior caso. . . . x2 . . z2 . então zk 6= xm implica que Z é uma SCML de Xm−1 e Y • Se xm 6= yn .1 (SCML) Entrada Dois strings X e Y e seus respectivos tamanhos m e n medidos em número de caracteres. . m) até (0. e seja Z = hz1 . . 1 m := comprimento (X) 2 n := comprimento (Y) 3 f o r i := 0 t o m do c [ i .e. y2 . . Saı́da O tamanho da maior subsequência comum entre X e Y . . Y = Y 0 c S(X. . zn i. . . zk i Denotando com S(X. Y 0 ). . Y )} se X = X 0 c1 . z2 . m) = T (n − 1. j ] := 0 . yn i. para 0 ≤ k ≤ n. 0 ] := 0 . Y ) + 1 > se X = X 0 c. z2 . podemos re- duzir o tempo e espaço para O(nm): SCML Algoritmo 5. . Zk = hz1 . . m) + T (n. . . S(X 0 . . 4 f o r j := 1 t o n do c [ 0 . que é maior que m+n n . . .5 Programação dinâmica Teorema: Subestrutura Ótima de uma SCML Sejam as sequências X = hx1 . . então zk 6= ym implica que Z é uma SCML de X e Yn−1 Notação: Se Z = hz1 . Com memoização ou armazenamento de valores intermediários. isso leva ao definição recursiva 8 0 0 <S(X . i. 5 f o r i := 1 t o m do 6 f o r j := 1 t o n do 7 i f xi = yj then 100 . Isso com certeza é mais que o número de caminhos de (n. 0). Y = Y 0 c2 e c1 6= c2 > 0 se X =  ou Y =  : Qual a complexidade de implementação recursiva (naiva)? No pior caso executamos T (n. zk i qualquer SCML de X e Y • Se xm = yn .

j − 1]. j] := c[i − 1. Caso queiramos recuperar a própria subsequência. Caso as colunas são menores. we store only 27 (and the image is nice). n] Give an example of ABCBDAB. podemos manter duas linhas e calcular os valores linha por linha.2 Comparação de sequências 8 c[i. podemos determinar o comprimento da maior subsequência em comum em tempo O(nm) e espaço O(min{n. Exemplo . m}). B D C A B A . j]) 11 end i f 12 end f o r 13 return c[m. 0 0 0 0 0 0 0 A 0 0 0 0 1 1 1 B 0 1 1 1 1 2 2 C 0 1 1 2 2 2 2 B 0 1 1 2 2 3 3 D 0 1 2 2 2 3 3 A 0 1 2 2 3 3 4 B 0 1 2 2 3 4 4 Caso só o comprimento da maior subsequência em comum importa. Com isso. j] := max(c[i. Os valores de cada linha ou coluna dependem só dos valores da linha ou coluna anterior. There. BDCABA with memoization. procede- mos das mesmo forma coluna por coluna. Supondo. 5. of the 42 places. que o comprimento de uma li- nha e menor que o comprimento de uma coluna. podemos reduzir o espaço usado. c[i − 1. temos que manter essa informação adicionalmente: SCML que permite mostrar a subsequência 101 . j − 1] + 1 9 else 10 c[i.

j] := c[i − 1. Saı́da O tamanho da maior subsequência comum entre X e Y e o vetor b para recuperar uma SCML. j] 12 b[i. 1 m := comprimento [X] 2 n := comprimento [Y] 3 f o r i := 0 t o m do c [ i . Mantendo duas li- nhas ou colunas de c. j] := - 10 e l s e i f c[i − 1. 4 f o r j := 1 t o n do c [ 0 . j] := ← 16 return c e b Exemplo . j − 1] 15 b[i. j] := c[i. 0 ] := 0 . j] := c[i − 1. j − 1] + 1 9 b[i. temos que manter O(nm) elementos em b. gasta menos recursos. j] := ↑ 13 else 14 c[i. 0 0 0 0 0 0 0 A 0 ↑0 ↑0 ↑0 -1 ←1 -1 B 0 -1 ←1 ←1 ↑1 -2 ←2 C 0 ↑1 ↑1 -2 ←2 ↑2 ↑2 B 0 -1 ↑1 ↑2 ↑2 -3 ←3 D 0 ↑1 -2 ↑2 ↑2 ↑3 ↑3 A 0 ↑1 ↑2 ↑2 -3 ↑3 -4 B 0 -1 ↑2 ↑2 ↑3 -4 ↑4 Nesse caso. j] ≥ c[i.5 Programação dinâmica Algoritmo 5. não tem método simples para reduzir o espaço de O(nm) (veja os comentários sobre o algoritmo de Hirschberg abaixo). B D C A B A . 5 f o r i := 1 t o m do 6 f o r j := 1 t o n do 7 i f xi = yj then 8 c[i. mas para recupar a subsequência comum. 102 . j − 1] then 11 c[i.2 (SCML-2) Entrada Dois strings X e Y e seus respectivos tamanhos m e n medidos em número de caracteres. j ] := 0 .

1975). -. visto que a solução não passa por eles. Após. −) corresponde à uma deleção no primeiro 103 . 1 i f i = 0 o r j = 0 then return 2 i f b[i. re- solve o problema da subsequência comum mais longa em tempo O(mn).2. j ) 7 else 8 P r i n t −SCML( b .2 Comparação de sequências O algoritmo de Hirschberg (Hirschberg. j 1 ) 4 p r i n t xi 5 e l s e i f b[i. Saı́da A maior subsequência Z comum entre X e Y obtida a partir de b. Em cada chamada recursiva é criada uma lista com as operações executadas. e tal lista é concatenada ao final das duas chamadas recursivas. ↑}m×n . se as operações permitidas são a inserção de um caracter. i 1 . j] =↑ then 6 P r i n t −SCML( b . via Divisão e Conquista. a deleção de um caracter ou a substituição de um caracter para um outro. O problema pode ser visto como um alinhamento de dois strings da forma sonhar vo--ar em que cada coluna com um caracter diferente (inclusive a “falta” de um carac- ter -) tem custo 1 (uma coluna (a. X . A recuperação da sequências de operações pode ser feita percorrendo-se linearmente esta lista. X . 5. j 1 ) 5. i . Print-SCML Algoritmo 5. X . i 1 . j] =. O algoritmo recursivamente divide a tabela em quatro quadrantes e ignora os quadrantes superior-direito e inferior-esquerdo.then 3 P r i n t −SCML( b . o algoritmo é chamado recursivamente nos quadrantes superior-esquerdo e inferior-direito. mas com complexidade de espaço linear O(m + n).3 (Print-SCML) Entrada Matriz b ∈ {←.2 Similaridade entre strings Considere o problema de determinar o número mı́nimo de operações que trans- formam um string s em um string t.

n − 1 . b diferentes.5 Programação dinâmica ou uma inserção no segundo string. b) somente. d(s0 . Existem quatro casos possı́veis para a última coluna:     h i h i a − a a . considerando todos casos possı́veis fornece uma solução ótima: ( max(|s|. n . O caso (a. senão podemos obter uma solução de menor custo. 1 d i s t â n c i a ( s . t . se os últimos caracteres são iguais. Com programação dinâmica. t . etc. t . m − 1 ) + 1 8 end i f 9 sol1 = d i s t â n c i a ( s . Saı́da A distância mı́nima entre s e t. se eles são diferentes. t e seus respectivos tamanhos n e m medidos em número de caracteres. t .4 (Distância) Entrada Dois strings s. Esse problema tem subestrutura ótima: Uma solução ótima contém uma solução ótima do subproblema sem a última coluna. t) + 1. Uma implementação direta é Distância de Edição Algoritmo 5. t0 ) + [c1 6= c2 ]) se s = s0 c1 e t = t0 c2 Essa distância está conhecida como distância de Levenshtein (Levenshtein. n . sol1 . − a a b com caracteres a. 1966). m ) + 1 11 return min(sol0 . m − 1 ) + 1 10 sol2 = d i s t â n c i a ( s . m − 1 ) 6 else 7 sol0 = d i s t â n c i a ( s . d(s. o caso (a. obtemos 104 . |t|) se |s |= 0 ou |t |= 0 d(s. . sol2 ) Essa implementação tem complexidade exponencial. Portanto. . armazenando os valores intermediários de d em uma matriz m.). t0 ) + 1. n − 1 .m):= 2 i f ( n=0) return m 3 i f ( m=0) return n 4 i f ( sn = tm ) then 5 sol0 = d i s t â n c i a ( s . a) somente se aplica. t . t) = min(d(s0 . n − 1 .

n do 5 f o r j := 1. . m do m0. . . t . . .j−1 + 1 12 sol2 := mi−1. n do mi. . sol2 ) .j := min(sol0 . 14 end f o r 15 return mi. j].j−1 + 1 10 end i f 11 sol1 := mi. .0 := i 3 f o r i := 1.j−1 8 else 9 sol0 := mi−1. e n e m. . 1 PD− d i s t â n c i a ( s . sol1 . . seus respectivos tamanhos medidos em número de caracteres. . . . .j + 1 13 mi. .2 Comparação de sequências Distância de Edição Algoritmo 5. n . . i] e t[1 . . . Comentário O algoritmo usa uma matriz M = (mi. m do 6 i f ( si = tj ) then 7 sol0 := mi−1.i := i 4 f o r i := 1.j entre os prefixos s[1 . . 5. . Saı́da A distância mı́nima entre s e t.5 (PD-distância) Entrada Dois strings s e t.m):= 2 f o r i := 0.j Distância entre textos Valores armazenados na matriz M para o cálculo da distância entre ALTO e LOIROS · L O I R O S · 0 1 2 3 4 5 6 A 1 1 2 3 4 5 6 L 2 1 2 3 4 5 6 T 3 2 2 3 4 5 6 O 4 3 2 3 4 4 5 105 .j ) ∈ N(n+1)×(m+1) que armazena as distâncias mı́nimas mi. .

. t . . . m do 6 i f ( si = tj ) then 7 sol0 = mi−1. . . .0 := −1 3 f o r i := 1. i] e t[1 . e n e m. . m do m0.j + 1 13 mi. Comentário O algoritmo usa uma matriz M = (mi.j ) que arma- zena a sequência de operações. n do mi.j := min(sol0 . n do 5 f o r j := 1. .0 = i.j Reconstrução da Sequência de Operações 106 . p0.5 Programação dinâmica -ALTO- LOIROS Distância entre textos Algoritmo 5.j−1 + 1 10 end i f 11 sol1 := mi. .i := −1 4 f o r i := 1.j−1 8 else 9 sol0 = mi−1.j := min{i | soli = mij } 15 end f o r 16 return mi. . . .j ) ∈ N(n+1)×(m+1) que armazena as distâncias mı́nimas mi. . pi.m):= 2 f o r i := 0. j].j entre os prefixos s[1 . . . .6 (PD-distância) Entrada Dois strings s e t. n . 1 PD− d i s t â n c i a ( s . . .i = i. . .j−1 + 1 12 sol2 := mi−1. sol2 ) . Saı́da A distância mı́nima entre s e t e uma matriz P = (pi. seus respectivos tamanhos medidos em número de caracteres. sol1 . 14 pi.

5.3 Problema da Mochila

Algoritmo 5.7 (PD-operações)
Entrada Uma matriz P = (pij ) de tamanho n × m com marcação de
operações, strings s, t, posições i e j.
Saı́da Uma sequência a1 , a2 , ax de operações executadas.
1 PD− o p e r a ç õ e s (P , s , t , i , j ):=
2 case
3 pi,j = −1 :
4 return
5 pi,j = 0 :
6 PD− o p e r a ç õ e s ( s , t , i − 1 , j − 1 )
7 p r i n t ( ’M’ )
8 pi,j = 1 :
9 PD− o p e r a ç õ e s ( s , t , i , j − 1 )
10 print ( ’ I ’)
11 pi,j = 2 :
12 PD− o p e r a ç õ e s ( s , t , i − 1 , j )
13 p r i n t ( ’D’ )
14 end case

O algoritmo possui complexidade de tempo e espaço O(mn), sendo que o
espaço são duas matrizes P e M . O espaço pode ser reduzido para O(min{n, m})
usando uma adaptação do algoritmo de Hirschberg.

5.3 Problema da Mochila

Mochila (ingl. Knapsack)

Instância Um conjunto de n itens com valores vi e peso wi , 1 ≤ i ≤ n, e
um limite de peso da mochila W .
P
Solução Um subconjunto S ⊆ [1, n] que cabe na mochila, i.e. i∈S wi ≤
W.
P
Objetivo Maximizar o valor total i∈S vi dos itens selecionados.

Idéia: Ou item i faz parte da solução ótima com itens i . . . n ou não.

107

5 Programação dinâmica

• Caso sim: temos uma solução com valor vi a mais do que a solução ótima
para itens i + 1, . . . , n com capacidade restante W − wi .
• Caso não: temos um valor correspondente à solução ótima para itens
i + 1, . . . , n com capacidade W .
Seja M (i, w) o valor da solução máxima para itens em [i, n] e capacidade W .
A idéia acima define uma recorrência


0
 se i > n ou w = 0
M (i, w) = M (i + 1, w) se wi > w não cabe

max{M (i + 1, w), M (i + 1, w − wi ) + vi } se wi ≤ w

A solução desejada é M (n, W ). Para determinar a seleção de itens:

Mochila máxima (Knapsack)

• Seja S ∗ (k, v) a solução de tamanho menor entre todas soluções que
– usam somente itens S ⊆ [1, k] e
– tem valor exatamente v.
• Temos

S ∗ (k, 0) = ∅
S ∗ (1, v1 ) = {1}
S ∗ (1, v) = undef para v 6= v1

Mochila máxima (Knapsack)
• S ∗ obedece a recorrência
(
∗ S ∗ (k − 1, v − vk ) ∪ {k} se vk ≤ v e S ∗ (k − 1, v − vk ) definido
S (k, v) = min
tamanho S ∗ (k − 1, v)

• Menor tamanho entre os dois
X X
ti + tk ≤ ti .
i∈S ∗ (k−1,v−vk ) i∈S ∗ (k−1,v)

• Melhor valor: Escolhe S ∗ (n, v) com o valor máximo de v definido.
P
• Tempo e espaço: O(n i vi ).

108

5.4 Multiplicação de Cadeias de Matrizes

5.4 Multiplicação de Cadeias de Matrizes
Qual é a melhor ordem para multiplicar n matrizes M = M1 ×· · ·×Mn ? Como
o produto de matrizes é associativo, temos várias possibilidades de chegar em
M . Por exemplo, com quatro matrizes temos as cinco possibilidades

Possı́veis multiplicações
Dadas (M1 , M2 , M3 , M4 ) pode-se obter M1 × M2 × M3 × M4 de 5 modos
distintos, mas resultando no mesmo produto

M1 (M2 (M3 M4 ))
M1 ((M2 M3 )M4 )
(M1 M2 )(M3 M4 )
(M1 (M2 M3 ))M4
((M1 M2 )M3 )M4

• Podemos multiplicar duas matrizes somente se N col(A) = N lin(B)

• Sejam duas matrizes com dimensões p · q e q · r respectivamente. O
número de multiplicações resultantes é p · q · r.

Dependendo do tamanho dos matrizes, um desses produtos tem o menor
número de adições é multiplicações. O produto de duas matrizes p × q e
q × r precisa prq multiplicações e pr(q − 1) adições. No exemplo acima, caso
temos matrizes do tamanho 3 × 1, 1 × 4, 4 × 1 e 1 × 5 as ordens diferentes
resultam em

Número de multiplicações para cada sequência

20 + 20 + 15 = 55
4 + 5 + 15 = 24
12 + 20 + 60 = 92
4 + 5 + 15 = 24
12 + 12 + 15 = 39

operações, respectivamente. Logo, antes de multiplicar as matrizes vale a pena
determinar a ordem ótima (caso o tempo para determinar ela não é proibitivo).
Dada uma ordem, podemos computar o número de adições e multiplicações

109

5 Programação dinâmica

em tempo linear. Mas quantas ordens tem? O produto final consiste em duas
matrizes que são os resultados dos produtos de i e n − i matrizes; o ponto de
separação i pode ser depois qualquer matriz 1 ≤ i < n. Por isso o número de
possibilidades Cn satisfaz a recorrência
X
Cn = Ci Cn−i
1≤i<n

para n ≥ 1 e as condições C1 = 1 e C2 = 1. A solução dessa recorrência é
Cn = 2nn /(2(2n−1)) = O(4 /n
n 3/2
) e temos Cn ≥ 2n−2 , logo têm um número
exponencial de ordens de multiplicação possı́veis1 .

Solução por Recorrência
O número de possibilidades Tn satisfaz a recorrência
X
T (n) = T (i)T (n − i)
1≤i<n−1

para n ≥ 1 e as condições T (1) = 1.
A solução dessa recorrência é T (n) = 2n
 n 3/2
n (2(2n − 1)) = O(4 /n ) e temos
n−2
Cn ≥ 2 .
Então não vale a pena avaliar o melhor ordem de multiplicação, enfrentando
um número exponencial de possibilidades? Não, existe uma solução com
programação dinâmica, baseada na mesma observação que levou à nossa re-
corrência.
(
mini≤j<k mij + m(j+1)k + bi−1 bj bk caso i < k
mik =
0 caso i = kx

Multiplicação de Cadeias de Matrizes

• Dada uma cadeia (A1 , A2 , . . . , An ) de n matrizes, coloque o produto
A1 A2 . . . An entre parênteses de forma a minimizar o número de multi-
plicações.

Algoritmo Multi-Mat-1
Retorna o número mı́nimo de multiplicações necessárias para multiplicar a cadeia de matrizes
passada como parâmetro.

1 Podemos obter uma solução usando funções geratrizes. (Cn−1 )n≥1 são os números Ca-
talan, que têm diversas aplicações na combinatórica.

110

5.4 Multiplicação de Cadeias de Matrizes

Algoritmo 5.8 (Multi-Mat-1)
Entrada Cadeia de matrizes (A1 , A2 , . . . , An ) e suas respectivas dimensões bi , 0 ≤ i ≤ n. A
matrix Ai tem dimensão bi−1 × bi .

Saı́da Número mı́nimo de multiplicações.

1 f o r i:=1 t o n do mi,j := 0
2 f o r u:=1 t o n − 1 do { diagonais s u p e r i o r e s }
3 f o r i:=1 t o n − u do { posição na diagonal}
4 j :=i + u {u = j − i}
5 mi,j := ∞
6 f o r k:=i t o j − 1 do
7 c:= mi,k + mk+1,j + bi−1 · bk · bj
8 i f c < mi,j then mi,j :=c
9 end f o r
10 end f o r
11 end f o r
12 return m1,n

Considerações para a Análise

• O tamanho da entrada se refere ao número de matrizes a serem multi-
plicadas

• As operações aritméticas sobre os naturais são consideradas operações
fundamentais

Análise de Complexidade do Algoritmo

n−1
X n−u
X j−1
X n−1
X n−u
X
Cp = (1 + 4) = (1 + 4u)
u=1 i=1 k−i u=1 i=1
n−1 n−1
˙ + 4u) =
X X
= (n − u)(1 n + 4nu − u − 4u2 = O(n3 )
u=1 u=1

Análise de Complexidade do Algoritmo

111

ı́ndices i e j . A2 . 1 f o r i:=1 t o n do mi.j := 0 { i n i c i a l i z a diagonal p r i n c i p a l } 2 f o r d:=1 t o n − 1 do { para todas diagonais s u p e r i o r e s } 3 f o r i:=1 t o n − u do { para cada posição na diagonal} 4 j :=i + u {u=j i } 5 mi. 1 i f i = j then 2 p r i n t ”Ai ” 112 . .5 Programação dinâmica Cp [Inicialização] = O(n) Cp [Iteração] = O(n3 ) Cp [Finalização] = O(1) Cp [Algoritmo] = O(n) + O(n3 ) + O(1) = O(n3 ) Algoritmo Multi-Mat-2 Retorna o número mı́nimo de multiplicações e a parentização respectiva para multiplicar a cadeia de matrizes passada como parâmetro.k + mk+1. .n .9 (Multi-Mat-1) Entrada Cadeia de matrizes (A1 .j + bi−1 · bk · bj 8 i f c < mi.j :=c 10 Pi. Saı́da Número mı́nimo de multiplicações. . An ) e suas respectivas dimensões armazenadas no vetor b. p Algoritmo Print-Parentização Algoritmo 5.10 (Print-Parentização) Entrada Matriz P . Saı́da Impressão da parentização entre os ı́ndices i e j. .j = k 11 end f o r 12 end f o r 13 end f o r 14 return m1. Algoritmo 5.j then 9 mi.j := ∞ 6 f o r k:=i t o j do 7 c:= mi.

i. • Calcula o caminho mı́nimo entre cada par de vértices de um grafo. . Pi. para quaisquer i e j tais que 1 ≤ i ≤ j ≤ k.1 Algoritmo de Floyd-Warshall O algoritmo de Floyd-Warshall calcula o caminho mı́nimo entre todos os pares de vértices de um grafo.1 (Cormen): Dado um grafo orientado ponderado G = (V. . vk ) um caminho mais curto do vértice v1 até o vértice vk e.2 do Cormen. . Pi.5 Tópicos 5. . E). . Então.j ) 6 P r i n t − P a r e n t i z a ç ã o ( P. .5 Tópicos 3 else 4 p r i n t ”(” 5 P r i n t − P a r e n t i z a ç ã o ( P. .4 (Laira&Veloso.5. 5.j + 1. e Exemplo 5. . j ) 7 p r i n t ”)” 8 end i f 5. vj ) o subcaminho p desde o vértice vi até o vértice vj . v2 . 2a edição). embora possa conter arcos de custo negativo. Subestrutura ótima Subcaminhos de caminhos mais curtos são caminhos mais curtos. Algoritmo de Floyd-Warshall • Conteúdo disponı́vel na seção 25. com função peso w : E → R. seja p = (v1 . • Lema 24. pij é um caminho mais curto de vi até vj . vi+1 . • Considera que o grafo não tenha ciclos negativos. seja pij = (vi . Algoritmo de Floyd-Warshall 113 .2.

5 Programação dinâmica Algoritmo 5. Sobre o semi-anel (R. representado por uma matriz quadrada D = (dij ) ∈ Rn×n com distância dij entre ij ∈ E ou dij = ∞. +) a matriz Dk representa o menor caminho com no máximo k hops entre todos pares de vértices. dik + dkj ) 6 return Dn Observe que não é necessário armazenar as matrizes Dk explicitamente. É uma observação importante que o algoritmo de Strassen (e algoritmos mais avançados como o algoritmo de Coppersmith-Winograd) só funcionam sobre aneis. usando a mesma matrix D para todas operações e portanto possui complexidade de espaço Θ(n2 ). caso ij 6∈ E. Excurso 5. all pairs bottleneck paths problem). o algoritmo resolve o problema do cami- nho gargalho entre todos pares (ingl. max. 1 D0 := D 2 f o r k := 1 t o n 3 f o r i := 1 t o n 4 f o r j := 1 t o n 5 dkij := min(dk−1 k−1 k−1 ij . podemos calcular Dn = Ddlog2 ne mais rápido quadrando D dlog2 ne vezes (ver os algoritmos de potênciação).) Portanto. min). e portanto Dn é a matriz calculada pelo algoritmo de Floyd-Warshall. uma abordagem que possui complexidade O(n3 log n). porque eles precisam um inverso para a adição. Por exem- plo: • Sobre o semi-anel (R. (Observe que a matriz Dk no algoritmo do Floyd-Warshall não é D elevado a k. Saı́da Uma matriz quadrada com cada célula contendo a distância mı́nima entre i e j. O algoritmo de Floyd-Warshall continua conrreto. Como Di = Dn para i ≥ n. E) com n = |V | vértices. Um algoritmo sub- cúbico para a multiplicação de matrizes em semi-aneis implicaria em um al- goritmo sub-cúbico para o problema do caminho mı́nimo entre todos pares de 114 .11 (Algoritmo de Floyd-Warshall) Entrada Um grafo G = (V. +) no algoritmo de Floyd- Warshall por outras operações. podemos aplicar n vezes uma multiplicação de matrizes para ob- ter Dn em O(n × n3 ). min. para resolver problemas similares.1 Podemos substituir as operações sobre (R. min.

uma solução ótima. P Objetivo Minimizar o custo da rota 1≤i<n d{i. i. Para determinar os caminhos mais curtos. v4 . Essa soluções têm sub-estrutura ótima. V \ {v}) V 6= ∅ T (i. v2 e volta. V ) = di1 caso V = ∅ 115 . Solução Uma rota que visita todos vértices exatamente uma vez. v3 . . n]). Outra observação é que o algoritmo de Floyd-Warshall somento calcula as distâncias entre todos pares de vértices. Essa solução tem como sub-solução ótima o caminho v2 . .5. Para mais informações ver por exemplo Chan (2007). Isso leva à recorrência ( minv∈V div + T (v. Para determinar o valor de T (i.E) com pesos d (distâncias) atribuı́dos aos links. porque qualquer outro caminho menor pode ser substituı́do para o caminho atual.. Williams and Williams (2010). 1992). .e. Da mesmo forma a última sub- solução tem o caminho v3 . . ♦ Exemplo 5. Problema do Caixeiro Viajante Instância Um grafo G=(V. mas significadamente menor. V ) temos que minizar sobre todas continuações possı́veis. . Logo. que passa por todos vértices exceto v1 e volta. que passa por todos vértices exceto v1 . Seja v1 . Sem perda de generalidade. . O algoritmo é baseado na seguinte idéia (proposta por Bellman (1962)). o algoritmo final ainda é exponencial (o problema é NP-completo). [2. podemos definir T (i. V ) como menor rota começando no vértice i e passando por todos vértices em V exatamente uma vez e volta para vértice 1. A solução desejada então é T (1. n]. 5. V = [1. veja por exemplo (Alon et al. como sub-solução. . . n] sem perda de generalidade. v2 .2 Caixeiro viajante O problema de caixeiro viajante é um exemplo em que a programação dinâmica ajuda reduzir um trabalho exponencial. .1} .i+1} + d{n.5 Tópicos vértices e problemas similares. Esperadamente. podemos supor que v1 = 1. uma permutação de [1.

Portanto. vamos investigar como construir a árvore binária ótima.3 Árvore de busca binária ótima Motivação para o Problema • Suponha que temos um conjunto de chaves com probabilidades de busca conhecidas. n] como número entre 0 e 2n − 1. Nessa caso.com/399). .0 := di1 { base } 2 f o r j ∈ [1. queremos minimizar o número médio de comparações (nossa medida de custos). n] do 4 Ti. vela a pena construir uma estru- tura de dados que minimiza o tempo médio para encontrar uma chave. a ordem natural já respeita a ordem ⊆ entre os conjuntos. • Uma estrutura de busca eficiente é uma árvore binária. 5 Programação dinâmica Se ordenamos todos os sub-conjuntos dos vértices [1. Uma implementação pode representar uma subconjunto de [1. Essa é atualmente o melhor algoritmo exato conhecido para o problema do caixeiro viajante (veja também xkcd. A complexidade do espação é O(n2n ).j := min2k &j=2k dik + Ti.1 Considere a sequência ordenada a < b < c < d e as probabilidades 116 . • Caso a busca é repetida muitas vezes..j−2k { tempo O(n) ! } 5 end f o r 6 end f o r A complexidade de tempo desse algoritmo é n2 2n porque a minimzação na linha 4 precisa O(n) operações. Para um conjunto de chaves com distribuição de busca conhecida. n] do Ti. n em que qualquer elemento depende somente de elementos em colunas mais para esquerda.5. n] em ordem de ⊆. Exemplo 5. e podemos substituir um teste v ∈ Vj com 2v &j = 2v e a operação Vj \ {v} com j − 2v . 5. 1 f o r i ∈ [1. 2n − 1] do 3 f o r i ∈ [1. ob- temos uma matrix de dependências V1 V2 · · · V2n 1 2 .

1×4 = 2. x1 [ ]x1 .6×3+0. Um exemplo de uma árvore com chaves artificiais (representadas pelos intervalos correspondentes) é hhh x2 VVVVVVVV s hh hhhhh VV+ o x1 L x3 L woo o LL % yrrr LL% ] − ∞. .6 0.6×3+0.5 Tópicos Exemplo Elemento a b c d Pr 0. . mas também as probabilidades que uma chave procurada não pertence à árvore. Em uma dada árvore.1 qual seria uma árvore ótima? Alguns exemplos '&%$ !"# '&%$ !"# /. probabilidades Pr[c < a1 ].0. x2 [ ]x2 . podemos observar que o número de com- parações para achar uma chave existente é igual a profundidade dela na árvore (começando com profundidade 1 na raiz). . Logo supomos que temos 1. ()*+ Árvore correspondente '&%$ !"# '&%$ !"# '&%$ !"# '&%$ !"# a ==   b <<  d '&%$ !"# /. respectivamente.2×3+0. podemos imaginar chaves artificiais que representam os intervalos entre as cha- ves. ♦ Árvore de Busca Binária Ótima Em geral. uma sequência ordenada a1 < a2 < · · · < an de n chaves e 2. ()*+ c == d a c d que têm um número médio de comparações 0.1×1 = 2. Pr[c = a1 ]. A partir dessas informações queremos minimizar a complexidade média da busca. 0.2×2+0. .-.1×2+0.6.1 0.2×1+0. 5. Pr[a1 < c < a2 ]. 0. Pr[an−1 < c < an ].1×2+0. .6×2+0. temos que considerar não somente as probabilidades que procure-se uma dada chave.7. . Pr[an < c] que a chave procurada c é uma das chaves da sequência ou cai num intervalo entre elas. Caso a chave não pertence à árvore.1×1+0.-. . ∞[ 117 . ()*+ '&%$ !"# '&%$ !"# b << a c ==   b == /.-. x3 [ ]x3 .1×3 = 2.2 0. Pr[c = an ]. e o número de comparações necessárias é um menos que a profundidade de uma chave artificial.

d. . definido acima. ai+1 [)−1) e≤i≤d e−1≤i≤d Wichtig: Die Wahrscheinlichkeiten werden nicht erneut normalisiert. r − 1) + cM (r + 1. d) = Pr[c = ar ] X X + Pr[c = ai ]prof(ai ) + Pr[ai < c < ai+1 ](prof(]ai . Com isso. ai+1 [) − 1).5 Programação dinâmica Para facilitar a notação. d) 118 . wenn die Wahrscheinlichkeit an den Rändern bis ∞ ausgedehnt wird. ai+1 [) − 1) r<i≤d r≤i≤d   X X = Pr[ai < c < ai+1 ] + Pr[c = ai ] e−1≤i≤d e≤i≤d + cM (e. d) a complexidade média de uma busca numa sub-árvore ótima para os elementos ae . 1≤i≤n 0≤i≤n ela depende da árvore concreta. Weitere Subtilität bei Teilbäumen: der obige Ausdruck Pr[ai < c < ai+1 ] stellt keine Kosten dar. Como achar a árvore ótima? A observação crucial é a seguinte: Uma das chaves deve ser a raiz e as duas sub-árvores da esquerda e da direita devem ser árvores ótimas pelas sub-sequências correspondentes. r − 1) + cM (r + 1. obtemos a complexidade média de busca X X cM = Pr[c = ai ]prof(ai ) + Pr[ai < c < ai+1 ](prof(]ai . . . d) = Pr[c = ai ]prof(ai )+ Pr[ai < c < ai+1 ](prof(]ai . essa complexidade pode ser escrito como cM (e. d) = Pr[ae−1 < c < ad+1 ] + cM (e. ad . Da mesmo forma. Para expressar essa observação numa equação. cM (e.h. n). Árvore de Busca Binária Ótima Supondo que ar é a raiz desse sub-árvore. d) wird mit den originalen Wahrscheinlichkeiten berechnet. ai+1 [) − 1) e≤i<r e−1≤i<r X X + Pr[c = ai ]prof(ai ) + Pr[ai < c < ai+1 ](prof(]ai . vamos denotar com cM (e. Para a complexidade da árvore inteira. vamos introduzir chaves adicionais a0 = −∞ e an+1 = ∞. obtemos X X cM (e. temos cM = cM (1. .

12 (ABB-ÓTIMA) Entrada Probabilidades pi = Pr[c = ai ] e qi = Pr[ai < c < ai+1 ].1) Árvore de Busca Binária Ótima Ao invés de calcular o valor cM recursivamente. d) caso e ≤ d 0 caso e > d (5. • pij : Pr[ai−1 < c < aj+1 ] Árvore de Busca Binária Ótima Algoritmo 5. 1 f o r i:=1 t o n+1 do 2 pi(i−1) :=qi−1 3 ci(i−1) :=0 4 end f o r 5 6 f o r d:=0 t o n − 1 do { para todas diagonais } 7 f o r i:=1 t o n − d do { da chave i } 8 j :=d + i { até chave j } 9 pij :=pi(j−1) + pj + qj 10 cij :=∞ 11 f o r r:=i t o j do 12 c:= pij + ci(r−1) + c(r+1)j 13 i f c < cij then 14 cij :=c 119 . vamos usar a programação (tabelação) dinâmica com três tabelas: • cij : complexidade média da árvore ótima para as chaves ai até aj . r − 1) + cM (r + 1.5 Tópicos Árvore de Busca Binária Ótima (O penúltimo passo é justificado porque. 5. d) = ( mine≤r≤d Pr[ae−1 < c < ad+1 ] + cM (e. • rij : raiz da árvore ótima para as chaves ai até aj .) Essa equação define uma recorrência para a complexidade média ótima: Escolhe sempre a raiz que minimiza essa soma. passando para uma sub-árvore a profundidade e um a menos. Como base temos complexidade cM (e. Saı́da Vetores c e r como descrita acima. d) = 0 se d > e: cM (e. para 1 ≤ i ≤ n e i − 1 ≤ j ≤ n. para 1 ≤ i ≤ j ≤ n.

5.04 0. b[ b ]b. Show the diagonal axis etc.1 0.04 0.1 Da três exemplos de problemas que não possuem uma subestrutura ótima. a solução ótima de um problema não contém soluções ótimas de subpro- blemas. Logo a complexidade pessimista é O(n3 ).5 Programação dinâmica 15 rij := r 16 end f o r 17 end f o r 18 end f o r TBD: Illustrate the dependencies and the initial values for c and p.1 0.04 a0 a1 a2 a3 a4 a5 i/j 1 2 3 ··· n 1 2 · · n Finalmente.2 0.04 0. −∞ ] − ∞.6 Exercı́cios Exercı́cio 5. 120 . i. c[ c ]c.04 0. we need an example to illustrate the algorithm. d[ d ]d. São três laços. queremos analisar a complexidade desse algoritmo. The dependencies are like in the matrix multiplication case. cada com não mais que n iterações e com trabalho constante no corpo. a[ a ]a. ∞[ ∞ 0.e.4 0. Also.

. 6 R e s o l v e r e c u r s i v a m e n t e : I1 . 8 end i f 121 . Recorrências • O tempo de execução dos algoritmos recursivos pode ser descrito por uma recorrência. . • Combinar as soluções dadas aos subproblemas. . .6 Divisão e conquista 6. k > 0 5 com tamanhos ni < n . Ik . . 1 i f n = 1 then 2 return S o l u ç ã o d i r e t a 3 else 4 D i v i d e I em sub i n s t â n c i a s I1 .1 Introdução Método de Divisão e Conquista • Dividir o problema original em um determinado número de subproble- mas independentes • Conquistar os subproblemas. . 7 R e s o l v e I usando sub s o l u ç õ e s DC(I1 ). . .1 (DC) Entrada Uma instância I de tamanho n. Divisão e conquista Algoritmo 6. . a fim de formar a solução do problema original. Ik . . resolvendo-os recursivamente até obter o caso base. . DC(Ik ) . • Uma recorrência é uma equação ou desigualdade que descreve uma função em termos de seu valor em entradas menores. .

q . a equação de recorrência do Mergesort é ( Θ(1) se n = 1 T (n) = T ( n2 ) + T ( n2 ) + Θ(n) se n > 1     122 . i.6 Divisão e conquista Recursão natural • Seja d(n) o tempo para a divisão. • Seja s(n) o tempo para computar a solução final. Recursão natural: caso balanceado ( Θ(1) para n < n0 T (n) = kT (dn/me) + f (n) caso contrário. 1 i f p < r then 2 q = b(p + r)/2c 3 MergeSort (A. r e um vetor A com elementos Ap . . . 5 Merge (A.e. • Podemos somar: f (n) = d(n) + s(n) e obtemos ( Θ(1) para n < n0 T (n) = P 1≤i≤k T (ni ) + f (n) caso contrário. p . Ar Saı́da A com elementos em ordem não-decrescente. . r ) 6 end i f Recorrências simplificadas Formalmente. p . r ) . para i < j temos Ai ≤ Aj . Mergesort Algoritmo 6.2 (Mergesort) Entrada Índices p. 4 MergeSort (A. . q ) . q+1.

em geral: • supõe-se argumentos inteiros para funções (omitindo pisos e tetos) • omite-se a condição limite da recorrência Recorrências: caso do Mergesort A equação de recorrência do Mergesort é T (n) = 2T (n/2) + Θ(n) Sendo que: • T(n) representa o tempo da chamada recursiva da função para um pro- blema de tamanho n.2 Resolver recorrências Métodos para resolver recorrências Existem vários métodos para resolver recorrências: • Método da substituição • Método de árvore de recursão • Método mestre 123 . • 2T ( n2 ) indica que.2 Resolver recorrências Em vez de T (n) = 2T (n/2) + Θ(n) Para simplificar a equação. sem afetar a análise de complexidade correspon- dente. duas chamadas recursivas (2T) serão executadas para entradas de tamanho n2 . 6. a cada iteração. 6. • Os resultados das duas chamadas recursivas serão combinados (merged ) com um algoritmo com complexidade de pior caso Θ(n).

até obter T (n) = Θ(n log n). que o resı́duo é negativo. pressupõe-se um limite hipotético.6 Divisão e conquista 6. • Pode ser usado para estabelecer limites superiores ou inferiores. usa-se indução matemática para provar que a suposição está cor- reta. O objetivo na prova é mostrar. Como fazer um bom palpite • Usar o resultado de recorrências semelhantes. A expressão na equação c · n log n −c · n + n | {z } residuo se chama resı́duo. Devemos provar que T (n) ≤ cn log n para uma escolha apropriada da constante c > 0. T (n) = O(n log n). 124 . 2.1 Método da substituição Método da substituição • O método da substituição envolve duas etapas: 1. • Aplica-se este método em casos que é fácil pressupor a forma de resposta. Podemos gradualmente diminuir o limite superior e elevar o inferior. jnk j n k T (n) ≤ 2 c log( + n) 2 2 ≤ cn log n/2 + n = cn log n − cn + n ≤ cn log n para c ≥ 1. para equação do Mergesort podemos provar que T (n) = Ω(n) e T (n) = O(n2 ).2. • Provar limites superiores (ou inferiores) e reduzir o intervalo de incerteza. Por exemplo. tem-se que T (n) ∈ O(n log n). conside- rando a recorrência T (n) = 2T (bn/2c + 17) + n. ou seja. Por exemplo. Mergesort usando o método da substituição Supõe-se que a recorrência j n k T (n) = 2T +n 2 tem limite superior igual a n log n.

l. Saı́da maxl≤i<r ai 1 m1 := M (a. Exemplo 6. .3 (Máximo) Entrada Uma sequência a e dois ı́ndices l. Prove que T (n) = O(log n log log n) Proposta de exercı́cios: 4.1-6 do Cormen (pág. . ar−1 é definido.1-2. Prove que T (n) = O(n) • Considere a recorrência T (n) = 2T (bn/2c) + n. 6. É possı́vel provar que T (n) = O(n)? √ • Considere a recorrência T (n) = 2T (b nc) + log n.2 Resolver recorrências • Usa-se o resultado do método de árvore de recursão como limite hi- potético para o método da substituição.1-1. 4. rc Isso leva a recorrência T (n) = T (bn/2c) + T (dn/2e) + 1 ♦ Algumas sutilezas nas resoluções • Considere a recorrência T (n) = T (bn/2c) + T (dn/2e) + 1. Substituição direta • Supomos que a recorrência tem a forma ( f (1) caso n = 1 T (n) = T (n − 1) + f (n) caso contrário 125 . 54 da edição traduzida).1 Vamos procurar o máximo de uma sequência por divisão é conquista: Algoritmo 6. 4. b(l + r)/2. . . r tal que al .1-5 e 4. b(l + r)/2c 2 m2 := M (a.

3 Ainda na aula sobre a complexidade média do algoritmo Quicksort (veja página 59). encontramos outra recorrência da forma T (n) = n + 2T (n/2).) É simples de generalizar isso para T (n) = T (n/c) + f (n) = f (n) + f (n/c) + f (n/c2 ) + · · · X = f (n/ci ) 0≤i≤logc n Exemplo 6. encontramos uma recorrência da forma T (n) = n + T (n − 1) P cuja solução é 1≤i≤n i = n(n − 1)/2.6 Divisão e conquista • Para resolver ele podemos substituir T (n) = f (n) + T (n − 1) = f (n) + f (n − 1) + T (n − 1) + f (n − 2) X = ··· = f (i) 1≤i≤n (Os · · · substituem uma prova por indução.2 Na aula sobre a complexidade média do algoritmo Quicksort (veja página 59). ♦ Substituição direta • Da mesma forma podemos resolver recorrências como ( f (1) caso n = 1 T (n) = T (n/2) + f (n) caso contrário • substituindo T (n) = f (n) + T (n/2) = f (n) + f (n/2) + T (n/4) X = ··· = f (n/2i ) 0≤i≤log2 n Exemplo 6. 126 .

que leva à recorrência A(n) = 1 + A(n/2) P cuja solução é 0≤i≤log2 n 1 = log2 n.2 Resolver recorrências Para colocá-la na forma acima. ♦ Também podemos generalizar isso. 6. Para f (n) = 2f (n/2) é simples de ver que f (n) = 2f (n/2) = 22 f (n/4) = · · · = 2log2 n n = n (observe que toda função f (n) = cn satisfaz a recorrência). Se dividimos por c1 obtemos T (n) T (n/c2 ) f (n) log n = log n/c2 + log n c1 c2 c1 c2 c1 c2 logc2 n e substituindo A(n) = T (n)/c1 temos f (n) A(n) = A(n/c2 ) + log n c1 c2 127 . uma alternativa é concluir que T (n) = Θ(n log2 n). Portanto temos a solução T (n) = n log2 n. vamos dividir primeiro por n para obter T (n)/n = 1 + T (n/2)/(n/2) e depois substituir A(n) = T (n)/n. Observe que a análise não considera constantes: qualquer função cn log2 n também satisfaz a recorrência. A solução exata é determinada pela base. Generalizando obtemos f (n) = cf (n/2) = · · · = clog2 n = nlog2 c logc2 n f (n) = c1 f (n/c2 ) = · · · = c1 = nlogc2 c1 O caso mais complicado é o caso combinado T (n) = c1 T (n/c2 ) + f (n). logc2 n O nosso objetivo é nos livrar da constante c1 .

58 ) ♦ 6. • Numa árvore de recursão cada nó representa o custo de um único sub- problema da respectiva chamada recursiva 128 .2. podemos re-substituir para obter a solução de T (n).6 Divisão e conquista uma forma que sabemos resolver: X f (n/ci2 ) 1 X A(n) = logc2 n/ci2 = log n f (n/ci2 )ci1 0≤i≤logc2 n c1 c1 c2 0≤i≤logc2 n Após de resolver essa recorrência.2 Método da árvore de recursão O método da árvore de recursão Uma árvore de recursão apresenta uma forma bem intuitiva para a análise de complexidade de algoritmos recursivos. Exemplo 6.4 (Multiplicação de números inteiros) A multiplicação de números binários (veja exercı́cio 6.3) gera a recorrência T (n) = 3T (n/2) + cn Dividindo por 3log2 n obtemos T (n) T (n/2) cn log n = log n/2 + log n 3 2 3 2 3 2 e substituindo A(n) = T (n)/3log2 n temos cn A(n) = A(n/2) + 3log2 n X n/2i =c 0≤i≤log2 n 3 2 n/2i log cn X  3 i = log n 3 2 2 0≤i≤log2 n cn (3/2)log2 n+1 = = 3c 3log2 n 1/2 e portanto T (n) = A(n)3log2 n = 3cnlog2 3 = Θ(n1.

para obter o custo daquele nı́vel • Somam-se os custos de todos os nı́veis para obter o custo da árvore Exemplo Dada a recorrência T (n) = 3T (bn/4c) + Θ(n2 ) • Em que nı́vel da árvore o tamanho do problema é 1? No nı́vel i = log4 n = log22 n .. pois a primeira chamada recursiva é Θ(n2 ). .. 1. 2. 3. • Quantos nı́veis tem a árvore? A árvore tem log4 n + 1 nı́veis (0. • Qual o custo de cada nı́vel i da árvore? 3i c( 4ni )2 . Plog4 (n) • Qual o custo da árvore? i=0 n2 · (3/16)i = O(n2 ). log4 n). n • Qual o tamanho do problema em cada nı́vel? 4i . Exemplo nı́vel nós 2 0 k Θ(n ) SSSSS 30 ukkkk  ) 1 Θ((n/4)2 ) Θ((n/4)2 ) Θ((n/4)2 ) 31 ukkk  SSS) 2 Θ((n/42 )2 ) Θ((n/42 )2 ) Θ((n/42 )2 ) 32 ··· h = dlog4 ne ··· Θ((n/4h )2 ) ··· 3h Prova por substituição usando o resultado da árvore de recorrência • O limite de O(n2 ) deve ser um limite restrito. 129 . • Quantos nós têm cada nı́vel? 3i . 6.2 Resolver recorrências • Somam-se os custos de todos os nós de um mesmo nı́vel.. • Quantos nós tem o último nı́vel? Θ(nlog4 3 ).

Soma os custos dos nı́veis e o custo das folhas 4. Desenha a árvore de recursão 2. ou seja. ♦ Resumindo o método 1. para valores de d tais que d ≥ 16 13 c Exemplo 6. trabalho cn/2i por nó e portanto (3/2)i n trabalho total por nı́vel. O número de folhas é 3log2 n e portanto temos X T (n) = (3/2)i n + Θ(3log2 n ) 0≤i<log2 n (3/2)log2 n − 1   =n + Θ(3log2 n ) 3/2 − 1 = 2(nlog2 3 − 1) + Θ(nlog2 3 ) = Θ(nlog2 3 ) Observe que a recorrência T (n) = 3T (n/2) + c tem a mesma solução. Determina • o número de nı́veis • o número de nós e o custo por nı́vel • o número de folhas 3. (Eventualmente) Verifica por substituição 130 . o nı́vel i com 3i nós. Temos log2 n nı́veis na árvore.6 Divisão e conquista • Prove por indução que T (n) = Θ(n2 ) T (n) ≤ 3T (bn/4c) + cn2 2 ≤ 3d bn/4c + cn2 ≤ 3d(n/4)2 + cn2 3 2 = dn + cn2 ≤ dn2 16 para ( 3d 16 + c) ≤ d. tamanho do problema n/2i .5 Outro exemplo é a recorrência T (n) = 3T (n/2) + cn da multiplicação de números binários.

f (n) difere assintoticamente por um fator n para um  > 0. Se f (n) = O(nlogb a− ) para algum  > 0..3 Método Mestre Método Mestre Para aplicar o método mestre deve ter a recorrência na seguinte forma: n T (n) = aT + f (n) b onde a ≥ 1. e se af (n/b) ≤ cf (n) para c < 1 e para todo n suficientemente grande. Se f (n) = Ω(nlogb a+ ) para algum  > 0.2. resp. Se a recorrência estiver no formato acima.1 e 6. 131 . • Os três casos não abrangem todas as possibilidades Proposta de exercı́cios: 6.2. então T (n) = Θ(nlogb a ) 2.2-2 e 4. maior que nlogb a . 6. então T (n) = Θ(nlogb a log n) 3.2-3 do Cormen (Cormen et al. Algoritmo Potenciação Algoritmo 6. 2001).4 (Potenciação-Trivial (PT)) Entrada Uma base a ∈ R e um exponente n ∈ N.2 Resolver recorrências Árvore de recorrência: ramos desiguais Calcule a complexidade de um algoritmo com a seguinte equação de recorrência T (n) = T (n/3) + T (2n/3) + O(n) Proposta de exercı́cios: 4. 6. então T (n) = Θ(f (n)) Considerações • Nos casos 1 e 3 f (n) deve ser polinomialmente menor. b > 1 e f (n) é uma função assintoticamente positiva. Se f (n) = Θ(nlogb a ).2-1. então T (n) é limitada assintoticamente como: 1. ou seja. 4.

n ÷ 2 ) 5 return x × x 6 end i f Complexidade da potenciação-Npotência2 ( Θ(1) se n = 0 T (n) = T ( n2 ) + c se n > 0   A complexidade dessa recorrência é logarı́tmica. T (n) ∈ O(n) Algoritmo Potenciação para n = 2i Algoritmo 6. 1 if n = 0 2 return 1 3 else 4 return PT(a. Saı́da A potência an .5 (Potenciação-Npotência2 (P2)) Entrada Uma base a ∈ R e um exponente n ∈ N. 1 i f n = 1 then 2 return a 3 else 4 x := P2 ( a . ou seja. ou seja. n − 1) × a 5 end i f Complexidade da potenciação ( Θ(1) se n = 0 T (n) = T (n − 1) + 1 se n > 0 A complexidade dessa recorrência é linear. T (n) ∈ O(log n) 132 .6 Divisão e conquista Saı́da A potência an .

Saı́da a com os elementos em ordem não-decrescente. f ) 10 end i f Complexidade da Busca-Binária ( Θ(1) se n = 1 T (n) = n T ( 2 ) + c se n > 1 A complexidade dessa recorrência é logarı́tmica.S)) Entrada Um inteiro x.x. r e um vetor a com elementos al . . para i < j temos ai ≤ aj .f. T (n) ∈ O(log n) Quicksort Algoritmo 6. a2 . 133 . 1 i f i = f then 2 i f ai = x return i 3 e l s e return ∞ 4 end ji f k 5 m := f −i 2 +i 6 i f x < am then 7 return Busca B i n á r i a ( i . . ou seja.6 (Busca-Binária(i. . 1 i f l < r then 2 m := P a r t i t i o n ( l . an de números ordenados.2 Resolver recorrências Busca Binária Algoritmo 6.7 (Quicksort) Entrada Índices l.e. i. . . r . Saı́da Posição i em que x se encontra na sequência S ou ∞ caso x ∈ / S. ar . a ) . m − 1 ) 8 else 9 return Busca B i n á r i a ( m + 1 . . . 6. ı́ndices i e f e uma sequência S = a1 .

T (n) ∈ O(n2 ) Complexidade do Quicksort no melhor caso ( Θ(1) se n = 1 T (n) = 2˙T ( n2 ) + Θ(n) se n > 1 A complexidade dessa recorrência é T (n) ∈ O(n log n) Complexidade do Quicksort com Particionamento Balanceado ( Θ(1) se n = 1 T (n) = T ( 9n n 10 ) + T ( 10 ) + Θ(n) se n > 1 A complexidade dessa recorrência é T (n) ∈ O(n log n) Agora.6 (Contra-exemplo 1) Considere a recorrência T (n) = 2T (n/2)+n log n. Nesse caso. vamos estudar dois exemplos. 5 end i f Complexidade do Quicksort no pior caso ( Θ(1) se n = 1 T (n) = T (n − 1) + Θ(n) se n > 1 A complexidade dessa recorrência é quadrática. a função f (n) = n log n não satisfaz nenhum dos critérios do teorema Mestre (ela fica “entre” casos 2 e 3). 4 Quicksort (m + 1 . ou seja. em que o método mestre não se aplica. Exemplo 6.6 Divisão e conquista 3 Quicksort (l .a ) . portanto temos que analisar com árvore de recorrência que resulta em X T (n) = (n log n − in) + Θ(n) = Θ(n log2 n) 0≤i<log2 n ♦ 134 .m − 1 .r .a ) .

e seja f (n) uma função não negativa definida sobre potências exatas de b. a função f (n) = n/ log n não satisfaz nenhum dos critérios do teorema Mestre (ela fica “entre” casos 1 e 2). De novo. b2 .4: Sejam a ≥ 1 e b > 1 constantes. b.2 Resolver recorrências Exemplo 6. Uma análise da árvore de recorrência resulta em X T (n) = (n/(log n − i)) + Θ(n) 0≤i<log2 n X = n/j + Θ(n) = nHn + Θ(n) = Θ(n log log n) 1≤j≤log n ♦ Prova do Teorema Master • Consideremos o caso simplificado em que n = 1.. ou seja... Então logb (n−1) X T (n) = Θ(nlogb a ) + aj · f (n/bj ) j=0 Prova do Teorema Master Lema 4. Defina T (n) sobre potências exatas de b pela recorrência: ( T (n) = Θ(1) se n = 1 n T (n) = aT ( b ) + f (n) se n = bi onde i é um inteiro positivo. .7 (Contra-exemplo 2) Considere a recorrência T (n) = 2T (n/2) + n/ log n.2: Sejam a ≥ 1 e b > 1 constantes. n é uma potência exata de dois e assim não precisamos nos preocupar com tetos e pisos. Prova do Teorema Master Lema 4. Uma função g(n) definida sobre potências exatas de b por logb (n−1) X g(n) = aj · f (n/bj ) j=0 135 . e seja f (n) uma função não negativa definida sobre potências exatas de b. 6.

2001). 0 < bi < 1 e funções g.1 (Método Akra-Bazzi e Leighton) Dado a recorrência ( Θ(1) se x ≤ x0 T (x) = P 1≤i≤k ai T (bi x + hi (x)) + g(x) caso contrário com constantes ai > 0. Se a·f (n/b) ≤ c·f (n) para c < 1 e para todo n ≥ b. O que segue é uma versão generalizada de Leighton (1996). |hi (x)| ≤ x/ log1+ x 1 Uma abordagem similar foi proposta por (Roura. O método de Akra-Bazzi (Akra and Bazzi. Então T (n) pode ser limitado assintoticamente para potências exatas de b como a seguir: Prova do Método Mestre 1. então T (n) = Θ(nlogb a · lgn) 3.6 Divisão e conquista 1. Teorema 6. então g(n) = Θ(f (n)) Prova do Teorema Master Lema 4.2. h. que satisfazem |g 0 (x)| ∈ O(xc ). então T (n) = Θ(nlogb a · lgn) 3. Se f (n) = Θ(nlogb a ). e se a · f (n/b) ≤ c · f (n) para c < 1 e para todo n suficientemente grande. Se f (n) = Ω(nlogb a+ ) para algum  > 0 ∈ R+ . e seja f (n) uma função não negativa definida sobre potências exatas de b. Defina T (n) sobre potências exatas de b pela recorrência ( T (n) = Θ(1) se n = 1 T (n) = aT ( nb ) + f (n) se n = bi onde i é um inteiro positivo. Se f (n) = Θ(nlogb a ). então T (n) = Θ(nlogb a ) 2. 1998) é uma genera- lização do método Master.4 Um novo método Mestre O método Master se aplica somente no caso que a árvore de recursão está balanceado. então T (n) = Θ(nlogb a ) 2.4: Sejam a ≥ 1 e b > 1 constantes. então T (n) = Θ(f (n)) 6. Se f (n) = O(nlogb a− ) para algum  > 0 ∈ R+ . Se f (n) = O(nlogb a− ) para algum  > 0 ∈ R+ . que serve também em casos não balanceados1 . 136 .

9 Considere T (n) = 2T (n/2)+n log n do exemplo 6. Exemplo 6. porque hi (x) ∈ O(1)) obtemos a recorrência ( Θ(1) se x ≤ x0 T (x) = P a 1≤i≤k i T (dbi xe) + g(x) caso contrário demonstrando que obtemos a mesmo solução aplicando tetos.1) afirma que Z n Z n T (n) ∈ Θ(np + (1 + c1 u/up+1 du)) = Θ(np (1 + c1 u−p du)) 1 1 p c1 1−p = Θ(n (1 + n )) 1−p c1 = Θ(np + n) = Θ(n) 1−p ♦ Exemplo 6. 6.84. Primeiro temos que achar um p tal que (1/5)p + (7/10)p = 1 que é o caso para p ≈ 0. 137 . P Observação 6.6 (que não pode ser resolvido pelo teorema Master).8 Considere a recorrência T (n) = T (n/5) + T (7n/10 + 6) + O(n) (que ocorre no algoritmo da seleção do k-ésimo elemento). teorema (6. 2(1/2)p = 1 define p = 1 e temos Z n T (n) ∈ Θ(n + (1 + log u/u du)) = Θ(n(1 + [log2 (u)/2]n1 ) 1 = Θ(n(1 + log2 (n)/2)) = Θ(n log2 (n)) 2 As condições exatas são definidas em Leighton (1996).1 As funções hi (x) servem particularmente para aplicar o teorema para com pisos e tetos. Com isso. Com hi (x) = dbi xe − bi x (que satisfaz a condição de h.2 Resolver recorrências para um  > 0 e a constante x0 e suficientemente grande2 temos que   Z x  p g(u) T (x) ∈ Θ x 1 + p+1 du 1 u com p tal que 1≤i≤k ai bpi = 1.

Novamente p = 1 e temos Z n T (n) ∈ Θ(n + (1 + 1/(u log u) du)) = Θ(n(1 + [log log u]n1 ) 1 = Θ(n(1 + log log n)) = Θ(n log(log n)) ♦ 6.10 Considere T (n) = 2T (n/2) + n/ log n do exemplo 6. portanto. A recorrência correspondente.7 (que não pode ser resol- vido pelo teorema Master). A21 A22 B21 B22 C21 C22 Com essa subdivisão. considerando somente multiplicações é T (n) = 8T (n/2) + O(1) 138 . o produto AB obtem-se pelas equações C11 = A11 B11 + A12 B21 C12 = A11 B12 + A12 B22 C21 = A21 B11 + A22 B21 C22 = A21 B12 + A22 B22 e precisa-se de oito multiplicações de matrizes de tamanho n/2 ao invés de uma multiplicação de matrizes de tamanho n. Mencionamos que existem algoritmos mais eficientes. A idéia do algoritmo de Strassen (1969) é: subdivide os matrizes num produto A × B = C em quatro sub-matrizes com a metade do tamanho (e.2 analisamos um algoritmo para multiplicar matrizes qua- dradas de tamanho (número de linhas e colunas) n com complexidade de O(n3 ) multiplicações.3 Tópicos O algoritmo de Strassen No capı́tulo 2.6 Divisão e conquista ♦ Exemplo 6.2. um quarto de elementos):       A11 A12 B11 B12 C11 C12 × = .

que leva à recorrência T (n) = 7T (n/2) + O(1) para o número de multiplicações. T (n) = 2T (n/2) + n log n 5.4 Exercı́cios (Soluções a partir da página 242. T (n) = T (2n/3) + 1 3. 6.) Exercı́cio 6. T (n) = T (n − 1) + log n 7. cuja solução é T (n) = O(nlog2 7 ) = O(n2. 6. Strassen inventou as equações M1 = (A11 + A22 )(B11 + B22 ) M2 = (A21 + A22 )B11 M3 = A11 (B12 − B22 ) M4 = A22 (B21 − B11 ) M5 = (A11 + A12 )B22 M6 = (A21 − A11 )(B11 + B12 ) M7 = (A12 − A22 )(B21 + B22 ) C11 = M1 + M4 − M5 + M7 C12 = M3 + M5 C21 = M2 + M4 C22 = M1 − M2 + M3 + M6 (cuja verificação é simples). T (n) = 4T (n/2) + n2 lg n 6.1 Resolva os seguintes recorrências 1. que demonstra que essa abordagem não é melhor que algoritmo simples.4 Exercı́cios e possui solução T (n) = O(n3 ). T (n) = 2T (n/2) + n/ log n 139 .81 ). T (n) = 9T (n/3) + n 2. Essas equações contém somente sete multi- plicações de matrizes de tamanho n/2. T (n) = 3T (n/4) + n log n 4.

Exercı́cio 6.3).4 A recorrência na análise do algoritmo de Strassen leva em conta somente multiplicações. Encontrar o k-ésimo elemento de uma lista não ordenada (Cormen 9. 2.2 e capı́tulo 6.8 de Toscani and Veloso (2005)). T (n) = 2T (n/2) + n log n Exercı́cio 6. Produto de número binários (Exemplo 5. T (n) = 3T (n/2) + n log n Exercı́cio 6. 140 .2 Aplique o teorema mestre nas seguintes recorrências: 1. analise a complexidade pelos três métodos vistos em aula.3 Descreva o funcionamento dos problemas abaixo. extraia as recorrências dos algoritmos. Algoritmo de Strassen para multiplicação de matrizes (Cormen 28. 1. T (n) = T (2n/3) + 1 3. T (n) = 3T (n/4) + n log n 4.3. T (n) = 9T (n/3) + n 2.6 Divisão e conquista 8.3). 3. Determina e resolve a recorrência das multiplicações e adições.

. . si )} A = {(v1 . . si ) | Pi (s1 . s2 . . . . v2 = (s1 . A. • O que fazer se eles não permitem uma solução eficiente? • Para resolver um problema: pode ser necessário buscar em todo espaço de solução. . . Backtracking: Árvore de busca • Seja uma solução dado por um vetor (s1 . . . • Idéia: Refinar as busca de força bruta. – limites conhecidos: Branch-and-bound (ramifique-e-limite). sn ). . . . . si ) tal que Pi+1 (s1 . . . . . • Mesmo nesse caso. si ). aproveitando restriçoes cedo • Define propriedades Pi (s1 .7 Backtracking Motivação • Conhecemos diversas técnicas para resolver problemas. . • Queremos somente soluçoes que satisfazem uma propriedade Pn (s1 . a busca pode ser mais ou menos eficiente. . . . . si ) Backtracking: Árvore de busca • A árvore de busca T = (V. si+1 )} r = () • Backtracking busca nessa árvore em profundidade. . . • Podemos aproveitar – restrições conhecidas: Backtracking (retrocedimento). . 141 . . . . . . r) é definido por V = {(s1 . . . si+1 ) ⇒ Pi (s1 . v2 ) ∈ V | v1 = (s1 . . . sn ) com si ∈ Si . .

e n rainhas. Solução Todas as formas de posicionar as n rainhas no tablado sem que duas rainhas estejam na mesma coluna. linha ou diagonal.7 Backtracking • Observe que é suficiente manter o caminho da raiz até o nodo atual na memória. O problema das n-rainhas Problema das n-rainhas Instância Um tablado de xadrez de dimensão n*n. O problema das n-rainhas (simplificado: sem restrição da diagonal) O que representam as folhas da árvore de busca para este problema? 142 .

O problema das n-rainhas • A melhor solução conhecida para este problema é via Backtracking. • Restringe uma rainha por linha: nn .1) e O problema das n-rainhas Se considerarmos também a restrição de diagonal podemos reduzir ainda mais o espaço de busca (neste caso. n2  • Existem n formas de posicionar n rainhas no tablado. • Pela aproximação de Stirling √  n n n! ≈ 2πn (1 + O(1/n)) (7. • Restringe ainda uma rainha por coluna problema: n!. nenhuma solução é factı́vel) 143 .

Problema do Caixeiro Viajante 144 . alguns ramos podem ser evitados de ser explorados 1. o algoritmo retorna para a alternativa anterior (backtracks) e tenta um novo ramo • Quando não há mais elementos para testar. retornando à cidade de partida ao final. O ramo pode ser infactı́vel de acordo com restrições do problema 2. visita todas as outras cidades uma única vez. partindo de uma cidade inicial. a busca termina • É apresentado como um algoritmo recursivo • O algoritmo mantém somente uma solução por vez Backtracking • Durante o processo de busca. se a inserção de um novo elemento “não funciona”. Se garantidamente o ramo não vai gerar uma solução ótima O problema do caixeiro viajante Encontrar uma rota de menor distância tal que.7 Backtracking Backtracking • Testa soluções sistematicamente até que a solução esperada seja encon- trada • Durante a busca.

Instância Um grafo G=(V. P Objetivo Minimizar o custo da rota 1≤i<n p{i.1 = n!) • Este problema têm solução n2 2n usando programação dinâmica.i+1} + p{n.E) com pesos p (distâncias) atribuı́dos aos links.e. O problema do caixeiro viajante O problema do caixeiro viajante • Para cada chamada recursiva existem diversos vértices que podem ser selecionados • Vértices ainda não selecionados são os candidatos possı́veis • A busca exaustiva é gerada caso nenhuma restrição for imposta • Todas as permutações de cidades geram as soluções factı́veis (Pn = n(n− 1)(n − 2).1} ... n] sem perda de generalidade. • Mas: para resolver em PD é necessário n2n de memória! 145 . n]. i. V = [1. uma permutação de [1. Solução Uma rota que visita todos vértices exatamente uma vez.

A busca exaustiva pode ser evitada com o teste de restrições. 146 .7 Backtracking O problema do caixeiro viajante • Alguma idéia de como diminuir ainda mais o espaço de busca? Vantagens x Desvantagens e Caracterı́sticas Marcantes Vantagens • Fácil implementação • Linguagens da área de programação lógica (prolog. mas o resultado final sempre é combinatório Caracterı́stica Marcante • Backtracking = “retornar pelo caminho”: constroem o conjunto de soluções ao retornarem das chamadas recursivas. ops5) trazem meca- nismos embutidos para a implementação de backtracking Desvantagens • Tem natureza combinatória.

an e valores de importância vi e peso wi referentes a cada elemento i do conjunto. a2 . a2 .Problema de Enumeração de conjuntos Enumeração de conjuntos Instância Um conjunto de n itens S=a1 .A) e um conjunto infinito de cores. um valor K referente ao limite de peso da mochila... Solução Enumeração de todos os subconjuntos de S. Solução Quais elementos selecionar de forma a maximizar o valor total de “importância” dos objetos da mochila e satisfazendo o limite de peso da mochila? • O problema da Mochila fracionário é polinomial • O problema da Mochila 0/1 é NP-Completo – A enumeração de todos os conjuntos gera uma solução de custo exponencial 2n – Solução via PD possui complexidade de tempo O(Kn) (pseudo- polinomial) e de espaço O(K) Problema de coloração em grafos Problema de Coloração em Grafos Instância Um grafo G=(V.an . a3 . Problema da Mochila Problema da Mochila Instância Um conjunto de n itens a1 .. 147 . . • A enumeração de todos os conjuntos gera uma solução de custo expo- nencial 2n . ..

uma atribuição c : V → C de cores tal que vértices vizinhos não têm a mesma cor: c(u) 6= c(v) para (u. v) ∈ E. • Para um grafo qualquer este problema é NP-completo.3 . • Algoritmo O(nn ). se χ(H) = ω(H) para todos sub-grafos H. i. – O número cromático χ(G): O número mı́nimo de cores necessárias para colorir G. Objetivo Minimizar o número de cores |C|. • Um grafo k-partido é um grafo cujos vértices podem ser particionados em k conjuntos disjuntos. • Dois números são interessantes nesse contexto: – O número de clique ω(G): O tamanho máximo de uma clique que se encontra como sub-grafo de G. 148 . Coloração de Grafos • A coloração de mapas é uma abstração do problema de colorir vértices.e. supondo o caso em que cada área necessite uma cor diferente • Teorema de Kuratowski: um grafo é planar se e somente se não possuir minor K5 ou K3. • Coloração de grafos de intervalo é um problema polinomial. • Verificar se o grafo permite uma 2-coloração é polinomial (grafo bipar- tido). • Obviamente: χ(V ) ≥ ω(G) • Um grafo G é perfeito. • Projete um algoritmo de backtracking para colorir um grafo planar (mapa). • Um grafo planar é aquele que pode ser representado em um plano sem qualquer intersecção entre arestas.7 Backtracking Solução Uma coloração do grafo. nos quais não há arestas entre vértices de um mesmo conjunto. Um grafo 2-partido é o mesmo que grafo bipartido.

Kenneth Appel e Wolfgang Haken. supondo todas combinações de área com quatro cores. • Teorema das Quatro Cores: Todo grafo planar pode ser colorido com até quatro cores (1976.A). University of Illinois) • Qual o tamanho máximo de um clique de um grafo planar? • Algoritmo O(4n ).1 (bt-coloring) Entrada Grafo não-direcionado G=(V. com vértices V = [1. 149 . n]. De quantas cores precisamos? b f a c e d De quantas cores precisamos? b b f f a c a c e e d d (Precisamos de 4 cores!) Backtracking Algoritmo 7. • Existem 3n−1 soluções possı́veis (algoritmo O(3n )) supondo que duas áreas vizinhas nunca tenham a mesma cor.

cu ) 11 return t r u e 12 end f o r 13 else 14 return f a l s e 15 end i f 16 end De quantas cores precisamos? c a d b e De quantas cores precisamos? 150 . cv ) := 4 if v > n 5 return t r u e 6 7 i f c 6∈ C(v) then { v c o l o rı́ v e l com cv ? } 8 c(v) := cv 9 f o r cu ∈ [1. v} ∈ A}. 1 return bt − coloring(1. 4] do 10 i f bt − coloring(v + 1.7 Backtracking Saı́da Uma coloração c : V → [1. Para um vértice v ∈ V . vamos definir o conjunto de cores adjacentes C(v) := {c(u) | {u. 4] do grafo. 1) 2 3 b o o l e a n bt − coloring(v. Objetivo Minimiza o número de cores utilizadas.

Neil Robertson. De quantas cores precisamos? a d b e c Roteamento de Veı́culos Roteamento de Veı́culos 151 . Paul Seymour). c c a a d d b e b e Precisamos de 3 cores! Coloração de Grafos • Existe um algoritmo O(n2 ) para colorir um grafo com 4 cores (1997. • Mas talvez sejam necessárias menos que 4 cores para colorir um grafo! • Decidir se para colorir um grafo planar são necessárias 3 ou 4 cores é um problema NP-completo. Sanders. Daniel P.

. • A demanda total de qualquer rota não deve superar a capacidade do caminhão. • Cada cidade V \ v0 é visitada uma única vez e por somente um veı́culo (que atende sua demanda total). distância di > 0 associada a cada aresta Solução Rotas dos veı́culos. Backtracking versus Branch & Bound • Backtracking: enumera todas as possı́veis soluções com exploração de busca em profundidade. Roteamento de Veı́culos • Mais de um depósito • veı́culos com capacidades diferentes • Entrega com janela de tempo (perı́odo em que a entrega pode ser reali- zada • Periodicidade de entrega (entrega com restrições de data) • Entrega em partes (uma entrega pode ser realizada por partes) • Entrega com recebimento: o veı́culo entrega e recebe carga na mesma viagem • Entrega com recebimento posterior: o veı́culo recebe carga após todas entregas • .. • Cada rota começa e termina no depósito. um depósito v0 . 152 . demanda qi > 0 de cada nó (q0 = 0. frota de veı́culos com ca- pacidade Q (finita ou infinita). Objetivo Minimizar a distância total.7 Backtracking Instância Um grafo G=(V.A).

• Enumeração: Backtracking e Branch&Bound. • Branch&Bound: usa a estratégia de backtracking – usa limitantes inferior (relaxações) e superior (heurı́sticas e propri- edades) para efetuar cortes – explora a árvore da forma que convier – aplicado apenas a problemas de otimização. etc. Métodos Exatos • Problemas de Otimização Combinatória: visam minimizar ou maximizar um objetivo num conjunto finito de soluções. busca locais. • Uso de cortes do espaço de busca: Planos de Corte e Branch&Cut. – Exemplo do Problema da Mochila: enumerar os 2n subconjuntos e retornar aquele com melhor resultado. – Ex: algoritmos gulosos não ótimos. GRASP (greedy randomized adaptive search procedure). Simulated annealing. 153 . Busca Tabu. • Heurı́sticas: algoritmos aproximados sem garantia de qualidade de solução. Métodos não exatos • Algoritmos de aproximação: algoritmos com garantia de aproximação S = αS ∗ . – Ex: Algoritmos genéticos. etc. • Geração de Colunas e Branch&Price. • Metaheurı́sticas: heurı́sticas guiadas por heurı́sticas (meta=além + heu- riskein = encontrar).

.

1 Introdução Vertex cover Considere Cobertura por vértices (ingl. vertex cover) Instância Grafo não-direcionado G = (V. O que fazer? 2 1 6 4 3 5 23 7 10 20 21 9 22 25 8 19 14 18 24 15 12 17 16 13 11 155 . Solução Uma cobertura C ⊆ V . Objetivo Minimiza |C|. i.e. E).8 Algoritmos de aproximação 8. ∀e ∈ E : e ∩ C 6= ∅. A versão de decisão de Cobertura por vértices é NP-completo.

1 (Redução de cobertura por vértices) Entrada Grafo não-direcionado G = (V. Algoritmo 8.2 (Árvore de busca) Entrada Grafo não-direcionado G = (V. Saı́da Um conjunto C ⊆ V e um grafo G0 . v. v}. w} 15 end i f 16 end while 17 return (C. 1 Reduz ( G ) := 2 while ( alguma r e g r a em b a i x o s e a p l i c a ) do 3 Regra 1 : 4 i f ∃u ∈ V : deg(u) = 1 then 5 s e j a {u. G) Uma solução exata com busca exhaustiva: Árvore de busca Algoritmo 8. v} ∈ E 6 C := C ∪ {v} 7 G := G − {u.8 Algoritmos de aproximação Simplificando o problema • Vértice de grau 1: Usa o vizinho. w} ∈ E 12 i f {v. tal que cada cobertura de vértices contém C. • Vértice de grau 2 num triângulo: Usa os dois vizinhos. E). 156 . w} 14 G := G − {u. {u. E). v} 8 end i f 9 Regra 2 : 10 i f ∃u ∈ V : deg(u) = 2 then 11 s e j a {u. e a união de C com a cobertura mı́nima de G0 é uma cobertura mı́nima de G. w} ∈ E then 13 C := C ∪ {v.

y) ∈ P e com • uma função de otimização (função de objetivo) ϕ : P → N (ou Q). 157 . 8. 1 minVertexCover (G):= 2 i f E = ∅ return ∅ 3 e s c o l h e {u.1 Um problema de otimização é uma relação binária P ⊆ I × S com instâncias x ∈ I e soluções y ∈ S. v} ∈ E 4 C1 := minVertexCover(G − u) ∪ {u} 5 C2 := minVertexCover(G − v) ∪ {v} 6 i f ( |C1 | < |C2 | ) then 7 return C1 8 else 9 return C2 10 end i f Solução ótima? 2 1 6 4 3 5 23 7 10 20 21 9 22 25 8 19 14 18 24 15 12 17 16 13 11 Problemas de otimização Definição 8.1 Introdução Saı́da Cobertura por vértices S ⊆ V mı́nima. tal que (x.

• Avaliação: Dado x. encontra solução ótima y e o valor ϕ∗ (x). 158 . se para soluções (x. 2. y) ∈ P temos |y| ≤ p(|x|). que satisfazem critérios mı́nimos de tratabilidade. para um polinômio p. • NPO contém todos problemas de otimização. encontra valor ótimo OPT(x). • Decisão: Dado x. 3.8 Algoritmos de aproximação • um objetivo: Encontrar mı́nimo ou máximo OPT(x) = opt{φ(x. y). A relação P é polinomialmente limita. polinomialmente limitado: (x. Tipo de problemas • Construção: Dado x. Classes de complexidade • PO: Problemas de otimização com algoritmo polinomial. Instâncias reconhecı́veis em tempo polinomial. y) ∈ P decidı́vel em tempo polinomial. Convenção Escrevemos um problema de otimização na forma Nome Instância x Solução y Objetivo Minimiza ou maximiza φ(x. k ∈ N.1): P é polinomialmente limitada. y) ∈ P}. Lembrança (veja definição 11. Para y arbitrário. decide se OPT(x) ≥ k (maximização) ou OPT(x) ≤ k (minimização). ϕ é computável em tempo polinomial. y) | (x. • NPO: Problemas de otimização tal que 1. 4.

4-colorability in O(n2 ). • Erro relativo: E(x. não busca o ótimo. • Erro absoluto: D(x. • O quer fazer? • Idéia: Para problemas da otimização. Fürer and Raghavachari (1994) show how to get MSTs or Steiner trees whose minimal (maximum) degree is within one of the optimal. árvore geradora e árvore Steiner de grau mı́nimo (Fürer and Raghavachari. y) = |OPT(x) − ϕ(x. • Uma solução “quase” ótimo também ajuda. y) ≤ k. y)}.1 Introdução Motivação • Para vários problemas não conhecemos um algoritmo eficiente. Singh and Lau (2007) extend this result for weighted case of MSTs. y)/ max{OPT(x). O que é “quase”? Aproximação relativa • A solução encontrada difere da solução ótima ao máximo um fator cons- tante. and whose maximum degree is at most k + 1. 159 . y) ≤  para todo x. 1]): Fornece solução y tal que E(x. • Exemplos: Coloração de grafos. • Algoritmo -aproximativo ( ∈ [0. O que é “quase”? Aproximação absoluta • A solução encontrada difere da solução ótima ao máximo um valor cons- tante. decision 3 or 4 colors in NP-complete. y)| • Aproximação absoluta: Algoritmo garante um y tal que D(x. • No caso dos problemas NP-completos: solução eficiente é pouco provável. 1994) • Contra-exemplo: Knapsack. y) = D(x. 8. They show that it is possible to get a MST whose weight is at most the weight of an optimal MST of degree less than k. ϕ(x.

Ela tem a vantagem. (1999).. Aproximação relativa Maximização Minimização 160 . • Contra-exemplo: Caixeiro viajante (Vazirani. Um algoritmo de mini- mização que garante no máximo um fator 3 da solução ótima ou um algo- ritmo de maximização que garante no mı́nimo um terço da solução ótima é 2/3-aproximativo ou 3-aproximativo. Aproximação relativa: Taxa de aproximação • Definição alternativa • Taxa de aproximação R(x. usando simplesmente a taxa de aproximação r = ϕ(x. 2001). porque r ∈ [1. A definição tem a desvantagem que ela é pouco intuitivo: seria mais claro. y) = 1/(1 − E(x. o algoritmo é r-aproximativo. ∞]. Caixeiro viajante métrico. Aproximação relativa: Exemplos • Exemplo: Knapsack. y)/OP T (x).. • (Não tem perigo de confusão com o erro relativo. • Com taxa r.8 Algoritmos de aproximação • Soluções com  ≈ 0 são ótimas. • Classe correspondente APX: r-aproximativo em tempo polinomial. • Soluções com  ≈ 1 são péssimas. de ser não-ambı́gua entre o erro relativo e o erro absoluto. y)) ≥ 1. chamar o primeiro algoritmo 3-aproximativo.) Nossa definição segue Ausiello et al. e o segundo 1/3-aproximativo. Hromkovič (2001) usa .

i. Saı́da Cobertura por vértices C ⊆ V .3 (Cobertura por vértices) Entrada Grafo não-direcionado G = (V. A cobertura ótima C ∗ é uma cobertura para Gi também. Logo. Seja Gi o grafo depois da iteração i e C ∗ uma cobertura ótima.e.. |C ∗ | = OPT(G). 8. G) := Reduz ( G ) 3 i f V = ∅ then 4 return C 5 else 6 e s c o l h e v ∈ V : deg(v) = ∆(G) { grau máximo } 7 return C ∪ {v} ∪ VC-GV(G − v) 8 end i f Proposição 8. 1 VC GV( G ) := 2 (C. |C | |C ∗ | OPT(G) Como o grau máximo é maior que o grau médio temos também kGi k ∆(Gi ) ≥ . OPT(G) Com isso podemos estimar X X kGi k X kGOPT k ∆(Gi ) ≥ ≥ |OPT(G)| |OPT(G)| 0≤i<OPT 0≤i<OPT 0≤i<OPT X = kGOPT k = kGk − ∆(Gi ) 0≤i<OPT 161 .1 O algoritmo VC-GV é uma O(log |V |)-aproximação. E).1 Introdução Exemplo: Cobertura por vértices gulosa Algoritmo 8. Prova. a soma dos graus dos vértices em C ∗ (contando somente arestas em Gi !) ultrapassa o número de arestas em Gi X δGi (v) ≥ kGi k v∈C ∗ e o grau médio dos vértices em Gi satisfaz P ∗ δG (v) kGi k kGi k δ̄Gi (Gi ) = v∈C ∗ i ≥ = .

a metade das arestas foi removido em OPT iterações.4 (Cobertura por vértices) Entrada Grafo não-direcionado G = (V. Saı́da Cobertura por vértices C ⊆ V .e. G) := Reduz ( G ) 3 i f V = ∅ then 4 return C 5 else 6 e s c o l h e v ∈ V : deg(v) = ∆(G) { grau máximo } 7 C1 := C ∪ {v} ∪ VC-B(G − v) 8 C2 := C ∪ N (v) ∪ VC-B(G − v − N (v)) 9 i f |C1 | < |C2 | then 10 return C1 11 else 12 return C2 13 end i f 14 end i f Aproximação: Motivação • Queremos uma aproximação • Quais soluções são aproximações boas? • Problemas: 162 . Como em cada iteração foi escolhido um vértice. 1 VC B( G ) := 2 (C.8 Algoritmos de aproximação ou X ∆(Gi ) ≥ kGk/2 0≤i<OPT i. a taxa de aproximação é log |G|. E). logo depois OP T dlg kGke ≤ OP T d2 log |G|e = O(OP T log |G|) iterações não tem mais arestas.  Exemplo: Buscar uma Cobertura por vértices Algoritmo 8. Essa estimativa continua a ser válido.

v} ∈ E 7 return C ∪ {u. |C| ≥ φVC-GE (G)/2 ⇒ 2OPT(G) ≥ φVC-GE (G)  Técnicas de aproximação • Aproximações gulosas • Randomização • Busca local • Programação linear 163 . 8. Saı́da Cobertura por vértices C ⊆ V .5 (Cobertura por vértices) Entrada Grafo não-direcionado G = (V. v}) 8 end i f Proposição 8. i. – Difı́cil verificar a minimalidade. Prova.1 Introdução – Tempo polinomial desejada – Aproximação desejada (“heurı́stica com garantia”) – Freqüentemente: a análise e o problema. v} ∪ VC-GE(G − {u. G) := Reduz ( G ) 3 i f E = ∅ then 4 return C 5 else 6 e s c o l h e e = {u. Exemplo: Outra abordagem Algoritmo 8. Cada cobertura contém ao menos um dos dois vértices escolhidos.e. E).2 Algoritmo VC-GE é uma 2-aproximação para VC. 1 VC GE( G ) := 2 (C. Intuição: – Simples verificar se um conjunto é uma cobertura.

Proposição 8. Seja h ∈ [m] a máquina que define o makespan da solução gulosa. Uma classe de algoritmos gulosos para este problema são os algoritmos de sequenciamento em lista (inglês: list scheduling). e alocam a tarefa atual sempre à máquina com menor tempo final. 1 ≤ i ≤ n. para particionamento.e.8 Algoritmos de aproximação • Programação dinâmica • Algoritmos seqüenciais (“online”). Eles processam as tarefas em alguma ordem.3 Sequenciamento em lista com ordem arbitrária é uma 2 − 1/m-aproximação.ex. portanto   X m li − lk  + lk ≤ W i:S(i)=h X li ≤ (W + (p − 1)lk )/p i:S(i)=h ≤ OPT + p/(p − 1)OPT = (2 − 1/p)OPT  ♦ 164 . todas as outras máquinas estavam com tempo ao menos i:S(i)=h li − lk . P O problema é NP-completo. Seja W = i∈n li o tempo total (workload). Sabemos que S ∗ ≥ W/m e também que S ∗ ≥ li .. uma alocação das tarefas às máquinas. Exemplo 8. i. No momento em que essa tarefa P foi alocada.1 Sequenciamento em processores paralelos Entrada m processadores. Objetivo Minimizar P o makespan (tempo terminal) maxj∈[m] i∈n|S(i)=j li . Solução Um sequenciamento S : [n] → [m]. 1 ≤ i ≤ n. Prova. e k ∈ [n] a última tarefa alocada à essa máquina. p. n tarefas com tempo de execução li .

Por análise de casos. 8. Maximum SAT Instância Fórmula ϕ ∈ L(V ). . Solução Uma atribuição de valores de verdade a : V → B. Objetivo Maximiza o número de cláusulas satisfeitas |{Ci | [[Ci ]]a = v}| . . TBD.  8. .2 Aproximações com randomização O que podemos ganhar com algoritmos off-line? Uma abordagem é ordenar as tarefas por tempo execução não-crescente e aplicar o algoritmo guloso. vk ) 3 for a l l i ∈ [1. Proposição 8. • Minimização: E[ϕA (x)] ≤ 2OPT(x) • Maximização: 2E[ϕA (x)] ≥ OPT(x) Randomização: Exemplo Satisfatibilidade máxima. Essa abordagem é chamada LPT (largest process first).2 Aproximações com randomização Randomização • Idéia: Permite escolhas randômicas (“joga uma moeda”) • Objetivo: Algoritmos que decidem correta com probabilidade alta. k] do 4 e s c o l h e vi = v com p r o b a b i l i d a d e 1/2 5 end f o r 165 . . • Objetivo: Aproximações com valor esperado garantido. Nossa solução 1 SAT−R( ϕ ) := 2 s e j a ϕ = ϕ(v1 . Prova.4 LPT é uma 4/3 − 1/3p-aproximação. ϕ = C1 ∧ C2 ∧ · · · ∧ Cn em FNC.

n] com valores vi ∈ N e tamanhos ti ∈ N . com l ≥ 1. Observação: Knapsack é NP-completo. 8 Algoritmos de aproximação Aproximação? • Surpresa: Algoritmo é 2-aproximação. um limite M . 1≤i≤k 1≤i≤k  Outro exemplo Cobertura por vértices guloso e randomizado. temos E[X] ≥ n/2.3 Aproximações gulosas Problema de mochila (Knapsack) Knapsack Instância Itens X = [1. para i ∈ X. Afirmação: E[X] ≥ (1 − 2−l )n com l o número mı́nimo de literais por claúsula. tal que ti ≤ M (todo item cabe na mochila). 166 . Seja X a variável aleatória que denota o número de claúsulas satis- feitas. 8. 1 VC−RG( G ) :=P 2 s e j a w̄ := v∈V deg(v) 3 C := ∅ 4 while E = 6 ∅ do 5 e s c o l h e v ∈ V com p r o b a b i l i d a d e deg(v)/w̄ 6 C := C ∪ {v} 7 G := G − v 8 end while 9 return C ∪ V Resultado: E[φVC-RG (x)] ≤ 2OPT(x). Prova da afirmação: P [[[Ci ]] = f ] ≤ 2−l e logo P [[[Ci ]] = v] ≥ (1 − 2−l ) e X X E[X] = E[[[Ci ]] = v] = P [[[Ci ]] = v] = (1 − 2−l )n. Prova. P Solução Uma seleção S ⊆ X tal que i∈S ti ≤ M . P Objetivo Maximizar o valor total i∈S vi . Portanto.

Abordagem 1 K−G( vi .3 Aproximações gulosas Como aproximar? • Idéia: Ordene por vi /ti (“valor médio”) em ordem decrescente e enche o mochila o mais possı́vel nessa ordem. . . . . ti ) := 2 o r d e n e o s i t e n s t a l que vi /ti ≥ vj /tj . tn−1 = 1. . 8. • Taxa de aproximação: M −1 kn − 1 kn − k OPT(x)/ϕ(x) = = ≥ =k n−1 n−1 n−1 • K-G não possui taxa de aproximação fixa! • Problema: Não escolhemos o item com o maior valor. . . . . . vn−1 = 1. 3 for i ∈ X do 4 i f ti < M then 5 S := S ∪ {i} 6 M := M − ti 7 end i f 8 end f o r 9 return S Aproximação boa? • Considere v1 = 1. . vn−1 /tn−1 = 1. vn = M − 1 t1 = 1. tn = M = kn k ∈ N arbitrário • Então: v1 /t1 = 1. vn /tn = (M − 1)/M < 1 • K-G acha uma solução com valor ϕ(x) = n−1. 167 . . ∀i < j . mas o ótimo é OPT(x) = M − 1.

2) 1≤i<j Afirmação: OPT(x) < v¯j + vj . OPT(x) < v¯j + vj ≤ 2v¯j ≤ 2ϕK-G (x) ≤ 2ϕK-G0 2. 8 Algoritmos de aproximação Tentativa 2: Modificação 1 K−G’ ( vi . i. Prova. temos espaço M − t¯j < tj sobrando.1) 1≤i<j X t¯j = ti ≤ M (8. OPT(x) < 2ϕK-G0 (x). Seja vj > v¯j OPT(x) < v¯j + vj < 2vj ≤ 2vmax ≤ 2ϕK-G0 Prova da afirmação: No momento em que item j não cabe. ti ) := 2 S1 := P K−G( vi . Como os itens são ordenados em ordem de densidade 168 . Seja vj ≤ v¯j . Nesse caso 1. Seja j o primeiro item que K-G não coloca na mochila. Nesse ponto temos valor e tamanho X v¯j = vi ≤ ϕK-G (x) (8.e.5 K-G’ é uma 2-aproximação. ti ) 3 v1 := i∈S1 vi 4 S2 := P {argmaxi vi } 5 v2 := i∈S2 vi 6 i f v1 > v2 then 7 return S1 8 else 9 return S2 10 end i f Aproximação boa? • O algoritmo melhorou? • Surpresa Proposição 8.

169 . vi ∈ Q+ S P Solução Partição 1≤i≤k Pi = [1. 7. Bin packing Instância Seqüencia de itens v1 . obtemos um limite superior para a solução ótima preenchendo esse espaço com a densidade vj /tj : vj OPT(x) ≤ v¯j + (M − t¯j ) < v¯j + vj . vn . . . . n] tal que j∈P i vj ≤ 1 para todos i ∈ [1. 8. 6. tj  Problemas de particionamento • Empacotamento unidimensional (ingl. 1]. n]. Abordagem? • Idéia simples: Próximo que cabe (PrC).3 Aproximações gulosas decrescente. bin packing). 5. Objetivo Minimiza o número de partições (“containeres”) k. 10 com limite 12. • Por exemplo: Itens 6. . 2. vi ∈]0.

Seja B o número de containeres usadas. . ϕPrC (x) ≤ 2 dV e ≤ 2OPT(x).8 Algoritmos de aproximação Aproximação? • Interessante: PrC é 2-aproximação. 1/2. 1/(2n). . B ≤ 2 dV e porque duas containeres consecutivas contém uma soma > 1. 1/2. logo OPT(x) ≥ dV e.  Aproximação melhor? • Isso é o melhor possı́vel! • Considere os 4n itens 1/2. Mas precisamos ao menos B ≥ dV e containeres. . 1/(2n) | {z } 2n vezes 170 . Portanto. . • Observação: PrC é um algoritmo on-line. V = 1≤i≤n vi . 1/(2n). P Prova.

• Portanto: Assintoticamente a taxa de aproximação 2 é estrito. com “estoque” na memória • Primeiro que cabe em ordem decrescente: PiCD. 8. on-line.3 Aproximações gulosas • O que faz PrC? ϕPrC (x) = 2n: containeres com • Ótimo: n containeres com dois elementos de 1/2 + um com 2n elementos de 1/(2n). 171 . OPT(x) = n = 1. Melhores estratégias • Primeiro que cabe (PiC). off-line.

nesse caso   V B≤ ≤ 3/2V + 1 ≤ 3/2OPT(x) + 1.5OPT(x) + 1 Prova. Portanto. . . (Da segunda taxa de aproximação.  172 . Supondo que um container contém somente itens do tipo D. Temos que analisar o que acontece com os itens em C e D. Isso pode ser justificado pelos seguintes observações: 1. PiCD en- contra a solução ótima. . .8 Algoritmos de aproximação • Taxa de aproximação? ϕPiC (x) ≤ d1. O melhor caso para os restantes itens são pares de elementos em B e C: Nesse situação. nenhum outro item cabe junto com um item do tipo A.) Considere a partição A ∪ B ∪ C ∪ D = {v1 . Logo é suficiente mos- trar ϕPiCD (x \ D) = OP T (x \ D).7OPT(x)e ϕPiCD (x) ≤ 1. os outros contai- neres tem espaço livre menos que 1/3. senão seria possı́vel distribuir os itens do tipo D para outros containeres. PiCD acha a solução ótima. O número de containeres sem itens tipo D é o mesmo (eles são os últimos distribuı́dos em não abrem um novo container). Os itens tipo A não importam: Sem itens D. 3. 2. vn } com A = {vi | vi > 2/3} B = {vi | 2/3 ≥ vi > 1/2} C = {vi | 1/2 ≥ vi > 1/3} D = {vi | 1/3 ≥ vi } PiCD primeiro vai abrir |A| containeres com os itens do tipo A e depois |B| containeres com os itens do tipo B. 2/3 Caso contrário (nenhum container contém somente itens tipo D). Logo: ϕPiCD (x \ D) = |A| + ϕPiCD (x \ (A ∪ D)).

173 . polynomial time approximation scheme (PTAS) – Para cada entrada e taxa de aproximação r: – Retorne r-aproximação em tempo polinomial. Denotamos uma instância do problema do mochila com I = ({vi }. • Desvantagem: Pseudo-polinomial.4 Esquemas de aproximação Aproximação melhor? • Tese doutorado D. 8. r = 2: 100% de erro! • Existem aproximações melhores? p. 1985 11 ϕPiCD (x) ≤ OPT(x) + 3 9 • Give all the examples mentioned on the slides and some extra examples which illustrate the underlying techniques. 108): tempo O(n i vi ). {ti }). S. Um exemplo: Mochila máxima (Knapsack) • Problema de mochila (veja página 166): P • Algoritmo MM-PD com programação dinâmica (pág. • Jeffrey John Hollis and John Kenneth Montague Moody? • Incorporate some of the stuff in Johnson’s “The many limits of appro- ximation” column. 70 pág 11 ϕPiCD (x) ≤ OPT(x) + 4 9 • Baker.4 Esquemas de aproximação Novas considerações • Freqüentemente uma r-aproximação não é suficiente. 8. Johnson. 1973. para SAT? problema do mochila? • Desejável: Esquema de aproximação em tempo polinomial (EATP).ex.

n 5 D e f i n e nova i n s t â n c i a I 0 = ({vi0 }. {ti }) 6 return MM PD( I 0 ) Teorema 8. r ) := 2 vmax := max{vi } vmax t := log r−1   3 r n 4 vi0 := bvi /2t c para i = 1. .1 MM-PTAS é uma r-aproximação em tempo O(rn3 /(r − 1)). y) pmax − ((r − 1)/r)pmax 174 . Prova. y) ≤ 2t n e pmax OPT(x) − pmax ϕMM-PTAS (x. A complexidade da preparação nas linhas 1–3 é O(n). S) = vi ≥ definição de b·c i∈S i∈S X 2t vi /2t otimalidade de MM-PD sobre vi0   ≥ i∈S ∗ X ≥ vi − 2t (A.10) i∈S ∗ X  = vi − 2t |S ∗ | i∈S ∗ ≥ OPT(x) − 2t n Portanto D(x. X X  2t vi /2t  ϕMM-PTAS (I. . . Com isso obtemos pmax ϕMM-PTAS (x. y) = rϕMM-PTAS (x. A chamada para MM-PD custa ! ! X 0 X vi O n vi = O n i i ((r − 1)/r)(tmax /n) !   r 2 X r 3 =O n vi /tmax = O n . 8 Algoritmos de aproximação 1 MM−PTAS( I . y) ≤ pmax 2t n ≤ OPT(x)2t n. r−1 i r−1 Seja S = MM-PTAS(I) a solução obtida pelo algoritmo e S ∗ uma solução ótima. y) OPT(x) ≤ pmax − 2t n pmax ≤ ϕMM-PTAS (x. y) = OPT(x) − ϕMM-PTAS (x. .

por quê? Exercı́cio 8.5 Exercı́cios  Considerações finais Um EATP frequentemente não é suficiente para resol- ver um problema adequadamente.2 Prof. • o problema do conjunto independente máximo em grafos com complexi- 2 2 2 2 dade O(n(4/π)(1/ +1) (1/ +2) ) (Erlebach. definir uma atribuição parcial que satisfazê-la. c o l o c a vM . 1996). Por exemplo temos um EATP para • o problema do caixeiro viajante euclidiano com complexidade O(n3000/ ) (Arora.5 Exercı́cios Exercı́cio 8. 2000).e. i. 8. qual a taxa de aproximação dele? Caso não. e eliminar a variável correspondente.1 Um aluno propõe a seguinte heurı́stica para Binpacking: Ordene os itens em ordem crescente. vamos escolher uma delas. Kanna. obtemos uma instância cujas claúsulas tem 2 ou mais literais. M := n 3 while ( m < M ) do 4 a b r e novo c o n t a i n e r . até todos itens foram colocados em bins. Para obter uma aproximação com 20% de erro. 8 • o problema do mochila múltiplo com complexidade O(n12(log 1/)/e ) (Chekuri. 175 . Temos o algoritmo 1 o r d e n e i t e n s em ordem c r e s c e n t e 2 m := 1 . Rapidez propõe o seguinte pré-processamento para o algoritmo SAT-R de aproximação para MAX-SAT (página 165): Caso a instância contém claúsulas com um único literal. Assim. M := M − 1 5 while ( vm cabe e m < M ) do 6 c o l o c a vm no c o n t a i n e r a t u a l 7 m := m + 1 8 end while 9 end while Qual a qualidade desse algoritmo? É um algoritmo de aproximação? Caso sim.  = 0. O(n375000 ) e O(n523804 ). e depois continua com o segundo maior item. 2001). Repetindo esse procedi- mento. respectivamente! 8.2 obtemos algoritmos com complexidade O(n15000 ). coloca o item com peso máximo junto com quantas itens de peso mı́nimo que é possı́vel.

o podemos garantir que E[X] ≥ 3n/4. i.8 Algoritmos de aproximação obtemos l ≥ 2 na análise do algoritmo.e. obtemos uma 4/3-aproximação. Este análise é correto ou não? 176 .

Parte III Teoria de complexidade 177 .

.

9 Do algoritmo ao problema

9.1 Introdução
Motivação

• Análise e projeto: Foca em algoritmos.
• Teoria de complexidade: Foca em problemas.
• Qual a complexidade intrı́nsica de problemas?
• Classes de complexidade agrupam problemas.
• Interesse particular: Relação entre as classes.

Abstrações: Alfabetos, linguagens

• Seja Σ um alfabeto finito de sı́mbolos.
• Codificação: Entradas e saı́das de um algoritmo são palavras sobre o
alfabeto ω ∈ Σ∗ .
• Tipos de problemas:
– Problema construtivo: Função Σ∗ → Σ∗ Alternativa permitindo
várias soluções: relação R ⊆ Σ∗ × Σ∗ .
– Problema de decisão: Função Σ∗ → {S, N } Equivalente: conjunto
L ⊆ Σ∗ (uma linguagem).
– Problema de otimização: Tratado como problema de decisão com
a pergunta “Existe solução ≥ k?” ou “Existe solução ≤ k?”.
• Freqüentemente: Alfabeto Σ = {0, 1} com codificação adequada.

Convenção 9.1
Sem perda de generalidade suporemos Σ = {0, 1}.

Definição 9.1
Uma linguagem é um conjunto de palavras sobre um alfabeto: L ⊆ Σ∗ .

179

9 Do algoritmo ao problema

Modelo de computação: Máquina de Turing

• Foco: Estudar as limitações da complexidade, não os
algoritmos.
• Portanto: Modelo que facilite o estudo teórica, não a
implementação.
• Solução: Máquina de Turing.
Alan Mathison
But I was completely convinced only by Tu- Turing (*1912,
ring’s paper. +1954)
(Gödel em uma carta para Kreisel, em maio
de 1968, falando sobre uma definição da com-
putação.).

Computing is normally done by writing certain symbols on paper.
”We may suppose this paper is divided into squares like a child’s
arithmetic book. In elementary arithmetic the two-dimensional
character of the paper is sometimes used. But such a use is
always avoidable, and I think that it will be agreed that the two-
dimensional character of paper is no essential of computation. I as-
sume then that the computation is carried out on one-dimensional
paper, i.e. on a tape divided into squares. I shall also suppose that
the number of symbols which may be printed is finite. If we were
to allow an infinity of symbols, then there would be symbols diffe-
ring to an arbitrarily small extent. The effect of this restriction of
the number of symbols is not very serious. It is always possible to
use sequences of symbols in the place of single symbols. Thus an
Arabic numeral such as 17 or 999999999999999 is normally treated
as a single symbol. Similarly in any European language words are
treated as single symbols (Chinese, however, attempts to have an
enumerable infinity of symbols). The differences from our point of
view between the single and compound symbols is that the com-
pound symbols, if they are too lengthy, cannot be observed at one
glance. This is in accordance with experience. We cannot tell at
a glance whether 9999999999999999 and 999999999999999 are the
same. (Turing, 1936).

Máquina de Turing

180

9.1 Introdução

Cabeça de leitura
e escritura

...
Fita infinita

Máquina de Turing (MT)

M = (Q, Σ, Γ, δ)

• Alfabeto de entrada Σ (sem branco )

• Conjunto de estados Q entre eles três estados particulares:
– Um estado inicial q0 ∈ Q, um que aceita qa ∈ Q e um que rejeita
qr ∈ Q.

• Alfabeto de fita Γ ⊇ Σ (inclusive ∈ Γ)

• Regras δ : Q × Γ → Q × Γ × {L, R}, escritas da forma

q, a → q 0 a0 D

(com q, q 0 ∈ Q, a, a0 ∈ Σ e D ∈ {L, R}).

Máquina de Turing: Operação

• Inı́cio da computação:
– No estado inicial q0 com cabeça na posição mais esquerda,
– com entrada w ∈ Σ∗ escrita na esquerda da fita, resto da fita em
branco.

• Computação: No estado q lendo um sı́mbolo a aplica uma regra qa →
q 0 a0 D (um L na primeira posição não tem efeito) até
– não encontrar uma regra: a computação termina, ou

181

9 Do algoritmo ao problema

– entrar no estado qa : a computação termina e aceita, ou
– entrar no estado qr : a computação termina e rejeita.
– Outra possibilidade: a computação não termina.

Exemplo 9.1 (Decidir wwR )

Tabela da transição
Seja Σ = {0, 1}. Uma máquina de Turing que reconhece a linguagem {wwR |
w ∈ Σ∗ } é

Notação gráfica

182

9.1 Introdução

(convenções e abreviações do Turing machine simulator; veja página da disci-
plina). ♦

Máquinas não-determinı́sticas

• Observe: Num estado q lendo sı́mbolo a temos exatamente uma regra
da forma qa → q 0 a0 D.

• Portanto a máquina de Turing é determinı́stica (MTD).

• Caso mais que uma regra que se aplica em cada estado q e sı́mbolo a a
máquina é não-determinı́stica (MTND).

• A função de transição nesse caso é

δ : Q × Γ → P(Q × Γ × {L, R})

Linguagem de uma MTD

• O conjunto de palavras que uma MTD M aceita é a linguagem reconhe-
cida de M .
L(M ) = {w ∈ Σ∗ | M aceita w}

• Uma linguagem tal que existe um MTD M que reconhece ela é Turing-
reconhecı́vel por M .

L Turing-reconhecı́vel ⇐⇒ ∃M : L = L(M )

• Observe que uma MTD não precisa parar sempre. Se uma MTD sempre
para, ela decide a sua linguagem.

• Uma linguagem Turing-reconhecı́vel por uma MTD M que sempre para
é Turing-decidı́vel.

L Turing-decidı́vel ⇐⇒ ∃M : L = L(M ) e M sempre para

Observação 9.1
Para representar problemas sobre números inteiros, ou estruturas de dados
mais avançados como grafos, temo que codificar a entrada como palavara em
Σ∗ . Escrevemos hxi para codificação do objeto x.

183

autômato celular): Tese de Church-Turing. máquina RAM. • Conjunto de linguagens Turing-decidı́veis: linguagens recursivas ou com- putáveis. 2. Uma MT com k > 1 fitas (cada uma com cabeça própria). uma MT com fita de duas ou mais dimensões. uma MTND e 5. uma MT com fita duplamente infinita. 3. 184 . 1}.9 Do algoritmo ao problema Linguagem de uma MTND • Conjunto de linguagens Turing-reconhecı́veis: linguagens recursivamente enumeráveis ou computavelmente enumeráveis. cálculo lambda. 4. • Para uma máquina não-determinı́stica temos que modificar a definição: ela precisa somente um estado que aceita e – ela reconhece a linguagem L(M ) = {w ∈ Σ∗ | existe uma computação tal que M aceita w} – ela decide uma linguagem se todas computações sempre param. Máquina de Turing não-determinı́stica • Resposta sim. Robustez da definição • A definição de uma MTD é computacionalmente robusto: as seguintes definições alternatives decidem as mesmas linguagens: 1. uma MT com alfabeto restrito Σ = {0. se existe uma computação que responde sim. • O poder computacional também é equivalente com vários outros modelos de computação (p.ex.

. . uma outra fita das k − 1 restantes e usado como fita da saı́da caso a MT calcula uma função. 1}w de compri- mento w = dlog |Σ|e. 5. A simulação possui dois conjuntos de regras para transições em estados (q. A máquina com uma xúnica fita meia-infinita representa essa fita por a0 ha−1 a1 iha−2 a2 i . se o simulação traba- lho no parte superior ou inferior. Seja aij o sı́mbolo na posição j da fita i e li o ı́ndice do último sı́mbolo usado na fita i. similar com o caso 1.) 1. .2 Uma modelo conveniente com k > 1 fitas é usar a primeira fita como fita de entrada e permitir somente leitura. #ak1 . com sı́mbolos novos em Σ ∪ Σ2 . . 3. (ii) executa as operações da k cabeças. copiando todos sı́mbolos da direita mais uma para direita.  Observação 9. . S) e estados (q. Seja ai o sı́mbolo na posição i da fita. Uma MTD simula a máquina com k > 1 fitas em dois passos: (i) Determina os sı́mbolos abaixo das cabeças em um passo. Cada sı́mbolo é representado por uma sequência em {0. com i ∈ Z. a1l1 # . por exemplo linha por linha no caso de duas dimensões. registrando além da estado da máquina simulada. a MTD estende-la. A MTD simula uma MTN listando todas as execuções possı́veis siste- maticamente. calcula e escreve a representação do novo sı́mbolo e depois se movimenta w posições para esquerda ou direita. . . a máquina pode ser simulado calculando o novo ı́ndice da cabeça. I}. 2. (Rascunho. Para representar as posições das cabeças. I) e um conjunto de regras para passar de cima para baixo e vice versa. usamos sı́mbolos com uma marca ȧ. Na simulação a MTD primeiro leia os w sı́mbolos atuais.1 Introdução Prova. Usando uma representação linear da fita. 185 . Caso uma cabeça ultrapassa a direita da representação. . 4. . 9. Os estados da máquina são Q × {S. A máquina com uma única fita representa os k fitas da forma #a11 . aklk .

Isso é possı́vel com O(Q × |Γ|2 ) estados e em menos que 4 log |Γ|t(n) passos (ler. É conveniente usar uma codificação com duas caracterı́sticas: (i) Cada string em {0. Prova.  Proposição 9. Γ. Prova. 1. Σ. e o movimento da cabeça. Como a maior posição visitada por M é t(n).2 Se uma MTD M = (Q. } que decide L em tempo 4 log |Γ|t(n). Portanto. Para representar as posições das cabeças.9 Do algoritmo ao problema Proposição 9. escreve os novos log |Γ| sı́mbolos. Para construir uma MT que trabalha com Γ0 vamos codificar cada sı́mbolo em Γ por um string de log |Γ| bits. 1} e com k > 1 fitas decide uma linguagem L em tempo t(n) ≥ n. M 0 armazeno o conteúdo das k fitas de M de forma intercalada nas posições 1 + ki.  Máquinas universais Uma fato importante é que existem máquinas de Tu- ring universais. a nova máquina precisa armazenar o estado Q e no máximo log |Γ| sı́mbolos na cabeça. M 0 precisa no máximo 5kt(n) passos (4kt(n) para escanear. então existe uma MT com alfabeto Γ0 = {0. δ) com Σ = {0. M 0 escaneia a fita de esquerda para direita para determinar as posições das cabeças e os sı́mbolos correspondentes. 1}∗ representa alguma MT. Vamos construir uma MT M 0 que simula M com uma única fita. então existe uma MT com única fita que decide L em tempo 5kt(n)2 . movimentar e talvez alguns passos para o controle). Depois M 0 usa as regras de transição de M para determinar o novo sı́mbolo. escrever. 1} decide uma linguagem L em tempo t(n). M 0 produz as mesma sáida que M . e ainda precisa um contador de 1 até log |Γ|. com t(n) tempo-construtı́vel. estado. Em cada passo.1 Se uma MTD M = (Q. 186 . e movimenta a cabeção log |Γ| posições para direita ou esquerda. para 1 ≤ i ≤ k. Para simular um passo de M . dado uma representação hM. mas copia-las para a posição n + 1 na codificação acima. Uma máquina universal é capaz simular a execução de qual- quer outra máquina de Turing M . xi de M e da entrada x. Σ. M 0 não altera as primeiras n posições da sua fita que contém a entrada. usamos sı́mbolos com uma marca ȧ. calcula o novo sı́mbolo e estado usanda as regras de M . para cada passo de M . Um segunda scan da direita para esquerda atualiza a fita de acordo. A codificação de M consiste em uma lista de todas entradas é saı́das da função de transição de M . a simulação lê log |Γ| na posição atual. Para essa simulação. com t(n) tempo-construtı́vel. Γ. a maior posição visitada por M 0 é no máximo kt(n) + 2n ≤ (k + 2)t(n) ≤ 2kt(n). δ) com Σ = {0. e alguns para o controle).

da → u R. 9. para achar a regra de transição a ser aplicada. 1}∗ temos U (i.3 Uma simulação de MTND é possı́vel com os mesmos limites. Essa máquina é universal? Ver http://www. u → dbR. o problema de parada. Aparentemente o problema foi resolvido em outubro de 2007. e depois executa essa regra. Para achar uma MTD U com uma única fita. Caso Mi para com entrada x em T passos. o número de fitas a número de estados de Mi . O número de passos de U então é limite por c T 2 com c = 25c0 . etc.9)) Existe uma MTD U .2. • Exemplo: O “Entscheidungsproblem” de Hilbert. ub → uaL. Th. podemos aplicar proposição 9. O trabalho para fazer isso é constante c0 por passo de M .1 (Arora and Barak (2009. Primeira vamos construir uma MT U 0 com 5 fitas. x) para em cT log T passos. {a. uma fita representa a fita de da máquina de Turing M simulada. uma fita contém o estado atual de M . ele representa uma MT default. Provaremos uma versão simplificada com tempo de simulação c T 2 . b}. 1. Teorema 9. com C uma constante que é independente de |x|. x) = Mi (x) com Mi a MTD representada por i. d}. 187 . Para simular um passo de M . Isso é possı́vel permitindo uma sequência de 1’s no final da representação de M . uma fita contém a descrição de M . e a última fita é a fita de saı́da.wolframscience.1 Introdução Caso a codificação é inválida. x ∈ {0. δ) com δ = {ua → ubL. tal que para cada i. (ii) Cada MT possui um número infinito de representações. db → daR. b. ♦ Computabilidade e complexidade Decibilidade versus complexidade • Qual é o poder computacional? • Surpreendentemente (?). Uma fita é a fita de entrada. }.  Observação 9. d → uaL}. e depende somente do tamanho do alfabeto. Exemplo 9. {a. U (i. Prova. U 0 escaneia a fita com as regras de transição e o estado atual de M .2 (Máquina universal) Considere a máquina M = ({u.com/prizes/ tm23. vários problemas não são decidı́veis.

transferência inclusive endereçamento indireto.aritmética). e com apontador de ins- truções. A máquina RAM Existem RAMs com diferentes tipos de instruções aritméticas • SRAM : somente sucessor • RAM : adição e subtração • MRAM : multiplicação e divisão e com diferentes tipos de custos • Custo uniforme: cada operação em O(1) • Custo logarı́tmico: proporcional ao número de bits dos operandos Exemplos de simulação 188 .9 Do algoritmo ao problema • A equivalência dos modelos significa que o modelo concreto não importa? • Sim para computabilidade. não para complexidade! Exemplo de um modelo diferente: A máquina de RAM. A máquina RAM A máquina RAM (random access machine) é o modelo padrão para análise de algoritmos. • uma memória infinita de números inteiros e • instruções elementares (controle. Ela possui • um processador com um ou mais registros.

ou • a fı́sica quântica atual é errada. 189 . autômatos celulares (Conway). máquina RAM. • Computador quântico? Consequência: Shor’s trilemma Ou • a tese estendida de Church-Turing é errada.2 (van Leeuwen (1990)) m − tapes ≤ 1 − tape(time kn2 & space Lin) m − tapes ≤ 2 − tape(time kn log n & space Lin) SRAM − UTIME ≤ T (time n2 log n) RAM − UTIME ≤ T (time n3 ) MRAM − UTIME ≤ T (time Exp) SRAM − LTIME ≤ T (time n2 ) RAM − LTIME ≤ T (time n2 ) MRAM − LTIME ≤ T (time Poly) Robustez da complexidade Tese estendida de Church-Turing Qualquer modelo de computação universal é equivalente à máquina de Turing com • custo adicional de tempo no máximo polinomial • custo adicional de espaço no máximo constante • Equivalência definido por simulação mutual. máquina pontador. circuitos lógicos. ava- liação de templates em C++.. computador billiard. . • Verdadeiro para quase todos modelos conhecidos: Maquina de Turing. 9. cálculo lambda.1 Introdução Teorema 9. ou • existe um algoritmo de fatoração clássico rápido..

.

se es- sas funções são limites superiores para todas computações possı́veis de tamanho n. Funções construtı́veis • No que segue.1 Definições básicas Complexidade pessimista • Recursos básicos: tempo e espaço. • A complexidade de tempo (pessimista) é uma função t:N→N tal que t(n) é o número máximo de passos para entradas de tamanho n. For any machine with. consideraremos somente funções t e s que são tempo- construtı́veis e espaço-construtı́veis.10 Classes de complexidade 10. if s(n) ≥ log n. which always halts. there exists an equivalent machine. we do not require that the TM always halts. Uma função s(n) é espaço-construtı́vel caso existe uma MTD com complexidade de espaço s(n) que precisa s(n) posições para alguma entrada de tamanho n. • A complexidade de espaço (pessimista) é uma função s:N→N tal que s(n) é o número máximo de posições usadas para entradas de tamanho n. • Uma MTND tem complexidades de tempo t(n) ou espaço s(n). Definição 10. The proof essentially uses a counter. 191 .1). For space complexity.1 Uma função t(n) é tempo-construtı́vel caso existe uma MTD com com- plexidade de tempo t(n) que precisa t(n) passos para alguma entrada de tamanho n. which stops the machine after entering in a cycle (Hopcroft 12.

if all computations halt. Our definition uses accepts. – L ∈ NSPACE[s(n)] se existe uma máquina Turing não-determinı́stica que aceita L com complexidade de espaço s(n). For time complexity: Time is defined for deciders. i.). .150). s : N → N e um problema L ⊆ Σ∗ – L ∈ DTIME[t(n)] se existe uma máquina Turing determinı́stica tal que aceita L com complexidade de tempo t(n). • Classes fundamentais: Para t. NDTM is a decider. for any word of a given input size. n!. log n.10 Classes de complexidade • Exemplos: nk .. Sipser: NDTM accepts a word. See also the comment above that for space complexity.e. um exemplo simples é uma função que não é computável. – L ∈ DSPACE[s(n)] se existe uma máquina Turing determinı́stica que aceita L com complexidade de espaço s(n). Existem funções que não são espaço-construtı́veis. DTM time is the longest time for any word of a given input size. such that for every machine an equivalent decider exists. This is the same definiton that Hopcroft (12. . they anticipate the speedup theorem. . – L ∈ NTIME[t(n)] se existe uma máquina Turing não-determinı́stica que aceita L com complexidade de tempo t(n). in most cases (s(n) ≥ log n) the definition also is equivalent for deciders.. Observação 10. if some computation accepts it (p.ou espaço-construtı́veis exclui funções não- computáveis ou difı́ceis de computar e assim permite uma simulação eficiente por outras MT. Classes de complexidade fundamentais • Uma classe de complexidade é um conjunto de linguagens. um outro exemplo é dlog log ne. 2n . but the time complexities require all computati- ons to terminate after t(n) steps. Atallah (1999) has two different definitions in the same book. Hierarquia básica 192 . NDTM time is the time of the longest computation. Arora/Barak use “decide” in time cT (n).1 A restrição para funções tempo. and does not comment on this.1) and Sipser use (TBD: Check some of our proofs below that the simulations always termi- nate.

A inclusão NTIME[F (n)] ⊆ DSPACE[F (n)] segue. temos obviamente DTIME[F (n)] ⊆ NTIME[F (n)] e DSPACE[F (n)] ⊆ NSPACE[F (n)].2 Hierarquias básicas Aceleração 193 . NSPACE = NSPACE[nk ] k≥0 k≥0 • Com a observação acima. • Obviamente: Tempo logarı́tmico tem menos interesse. temos P ⊆ NP ⊆ DSPACE ⊆ NSPACE . porque não é possı́vel ler toda entrada.) Como uma máquina não-determinı́stica é uma ex- tensão da uma máquina determinı́stica. Prova. (Busca binária não tem tempo log n numa máquina de Turing!) 10. (Da observação. porque todas computações que precisam menos que F (n) passos. 10.  Classes de complexidade Zoológico de complexidade • Classes com espaço logarı́tmico: Interessante no contexto de memôria secundária.2 Hierarquias básicas • Observação DTIME[F (n)] ⊆ NTIME[F (n)] ⊆ DSPACE[F (n)] ⊆ NSPACE[F (n)] • Definições conhecidas: [ [ P= DTIME[nk ]. precisam menos que F (n) espaço também. NP = NTIME[nk ] k≥0 k≥0 • Definições similares para espaço: [ [ PSPACE = DSPACE[nk ].

1 Podemos comprimir ou acelerar computações por um fator constante. codificando cada m sı́mbolos em um sı́mbolo em tempo n + dn/me.10 Classes de complexidade Teorema 10. cada m passos podem ser simulados em 8 passos em tempo n + dn/me + d8t(n)/me ≤ n + n/m + 8t(n)/m + 2 ≤ 3n + 8t(n)/n que para cm ≥ 16 ⇔ 8/m ≤ c/2 e n suficientemente grande não ultrapassa ct(n). • O limite inferior de t(n) = ω(n) é devido a cópia necessária: temos que ler a entrada e uma aceleração somente é possı́vel se o tempo original é estritamente mais que n. para máquinas de Turing com k > 1 fitas e t(n) = ω(n) L ∈ DTIME[s(n)] ⇒ L ∈ DTIME[cs(n)] L ∈ NTIME[s(n)] ⇒ L ∈ NTIME[cs(n)] Prova.  • Com essas teoremas: A classes de complexidade são “compatı́veis” com a notação O. M 0 leia os sı́mbolos na esquerda e direta e na posição atual em tempo 4. M 0 começa de copiar a entrada para uma outra fita. Teorema 10. e escreve os três sı́mbolos novos em tempo 4.) A idéia é construir uma MT M 0 que simula uma MT M executando m passos em um passo. (Rascunho. existe um linguagem L tal que L 6∈ DTIME[t(n)] ou L 6∈ DSPACE[s(n)]. O número finito de palavras que não satisfazem esse limite superior é reconhecido diretamente no controle finito. Depois a simulação começa. 194 . Logo. • Para fitas k = 1 o teorema da compressão é válida se t(n) = ω(n2 ) (porque a cópia precisa tempo O(n2 ) agora. Para todos c > 0 no caso de espaço temos L ∈ DSPACE[s(n)] ⇒ L ∈ DSPACE[cs(n)] L ∈ NSPACE[s(n)] ⇒ L ∈ NSPACE[cs(n)] e no caso do tempo. respectivamente. Hierarquia de tempo (1) • É possı́vel que a decisão de todos problemas tem um limite superior (em termos de tempo ou espaço)? Não. Depois ela calcula os novos estados no controle finito. Em cada passo.2 Para t(n) e s(n) total recursivo.

). ela determina i e a máquina Mi correspondente e simula Mi para t(n) passos. Vamos construir uma MT M sobre alfabeto de entrada Σ = {0. Se Mi aceita. Define L = {xi | Mi naõ aceita xi em tempo t(|xi |)}.3 (Hartmanis.) Para provar o segundo parte (que é mais fácil) temos que mostrar que existe uma linguagem L ⊆ Σ∗ tal que L ∈ DSPACE[g] mas L 6∈ DSPACE[f ]. g. x2 . com g(n) ≥ log2 n espaço-construtı́vel e f = o(g) temos DSPACE(f ) ( DSPACE(g). Essa linguagem é decidı́vel: Uma MT primeira computa t(n) (que é possı́vel porque t(n) é recursivo e total. Caso a simulação ultrapassa o espaço marcado. ela rejeita. . M2 . 195 . uma enumeração deles e seja x1 . (Rascunho. . mas a máquina simulada pode ter mais sı́mbolos de fita. uma con- tradição. .  Hierarquia de tempo (2) Além disso. 1} cuja linguagem tem essa caracterı́stica. Prova por contradição: Seja L = L(Mi ). M começa de marcar g(|w|) espaço no começo (isso é possı́vel porque g é espaço-construtı́vel). Por diagonalização. uma enu- meração das palavras em Σ∗ . Essa linguagem não pertence a DTIME[t(n)]. 2. (Rascunho). Para funções f. As máquinas de Turing são enu- meráveis: seja M1 . Mi não aceita em tempo t(n).Stearns) Para f. A idéia básica é diagonalização: com entrada w simula a máquina Mw com entrada w e garante de nunca reconhecer a mesma linguagem que Mw caso ela é limitada por f . Prova. . Portanto. 10. . . Caso não.2 Hierarquias básicas Prova. Nos temos que garantir que M pode simular todas máquinas que tem limite de espaço f (n). Temos que garantir que M precisa não mais que g(n) espaço. as hierarquias de tempo são “razoavelmente densos”: Teorema 10. Depois com entrada xi . M rejeita. Então xi ∈ L? Caso sim. uma contradição também. g com g tempo-construtı́vel e f log f = o(g) temos DTIME(f ) ( DTIME(g). Isso tem duas problemas (a) M tem um alfabeto de fita fixo. Considerações: 1. Mi não aceita em tempo t(n). senão ela aceita.

Com essas preparações. c2 depende das caracterı́sticas da máquina simulada (número de estados. A construção do Savitch procura deterministicamente uma transição do estado inicial para um estado final com menos que cS(n) passos. porque para simular um MT um dado número de passos por uma outra. (b) Por definição. é necessário contar o número de passos até f (n) em log f (n) bits. em espaço f (n) reconhece L(M ). Savitch (*1943) Prova. A abordagem 196 . verifica que Mw é uma codificação de uma MT e depois simula Mw com entrada w. temos que garantir que a simulação para.  Espaço polinomial Teorema 10. 3. Com uma simulação mais eficiente (que não é conhecida) seria possı́vel de obter um teorema mais forte. caso M 0 seria uma máquina desses. com entrada w. (Rascunho. M rejeita se Mw aceita e aceita se Mw rejeita. e rejeita caso a simulação ultra- f (n) passa c2 passos. etc. M construa Mw .) Se X ∈ NSPACE[T (n)]. Esses assuntos podem ser resolvidos usando uma enumeração de MT (com alfabeto Σ) tal que cada máquina tem codificações de comprimento arbitrário (por exemplo permitindo hM i10n ). Senão.). Além disso.10 Classes de complexidade Portanto. A fator de log f surge. para f ∈ o(g) é suficiente de ter f ≤ cg a partir de um n > n0 . a simulação precisa um fator c1 de espaço a mais. uma contradição. A idéia da prova do primeiro parte é essencialmente a mesma.4 (Savitch) Para cada função S(n) ≥ log2 n (espaço-construtı́vel) 2 NSPACE[S(n)] ⊆ DSPACE[S(n) ] • Corolário: DSPACE = NSPACE • Não-determinismo ajuda pouco para espaço! Walter J. se w ∈ M 0 então w 6∈ M e se w 6∈ M 0 então w ∈ M . com entrada w = hM 0 i01n para n suficientemente grande M consegue de simular M 0 e portanto. o tempo é limitado por um cS(n) . Logo para entrada |w| ≤ n0 o espaço g(n) pode ser insuficiente para simular qualquer máquina que precisa espaço f (n). Portanto M usa um contador com O(log n) espaço. Não tem máquina que.

10. A função tem que ter S(n) ≥ log2 n. que precisa log2 n bits. é possı́vel calcular a função do “castor ocupado” (ingl.3 Exercı́cios e divisão e conquista: Para ver.3 Exercı́cios Exercı́cio 10. por que para a simulação precisamos também gravar a posição de cabeça de entrada em cada nı́vel. resultando 2 em O(S(n) ) para tudo. tenta se tem um caminho A ⇒ I e I ⇒ B. se tem uma transição A ⇒ B com menos de 2i passos. busy beaver)? 197 .  Espaço polinomial (2) 10. cada um com 2i−1 passos para todas configurações I com menos que S(n) lugares. A altura do árvore de procura é O(S(n)) e o espaço da cada nı́vel também e O(S(n)).1 Dado uma máquina de Turing com oráculo para o problema de parada.

.

• Definição alternativa: Uma computação é uma relação R ⊆ Σ∗ × Σ∗ . (Atallah. Livre de con- determinı́stico) texto Sensitiva ao con. Regular minı́stico) Livre de contexto CFL 2 Autômato de pilha (não. referências em (complexity zoo). CSL 1 MT linearmente limitada Sensitiva ao texto (não-determinı́stico) contexto Recursivamente RE 0 MT Sistema semi- enumerável Thue (sem res- trição) O seguinte teorema relaciona a hierarquia de Chomsky com as classes de complexidade (sem prova. 199 .11 Teoria de NP-completude 11. 25. 2006. Teorema 11. Th. nosso interesse são soluções.1 (Complexidade das linguagens da hierarquia de Chomsky) REG = DSPACE[O(1)] = DSPACE[o(log log n)] REG ⊆ DTIME[n] CFL ⊆ DSPACE[n3 ] CSL = NSPACE[n] Normalmente. 7. P e NP em termos de busca • A computação de uma solução pode ser vista como função Σ∗ → Σ∗ • Exemplo: Problema SAT construtivo: Uma solução é uma atribuição. Th. As perguntas centrais como P 6= NP acabam de ter respostas equivalentes.6) e (Sipser.16)). não decisões: Ao seguir vamos definir P e NP em termos de soluções.1 Caracterizações e problemas em NP A hierarquia de Chomsky classifica linguagens em termos de autômatos e gramáticas que aceitam ou produzem elas: Linguagem Nome Tipo Autômato Gramática Regular REG 3 Autômato finito (deter. 1999.

Supõe que temos um algoritmo A que resolve este problema em tempo t(n). y) ∈ R} • A classe P: Linguagens LR tal que existe uma MTD que. para entrada x. y). • Essa definição do P às vezes é chamado FP ou PF. Então podemos construir o seguinte algoritmo.(Arora and Barak. mas é importante para a tratabilidade de problemas.2 ((Trevisan. Teorema 11. y) ∈ R : |y| ≤ p(|x|) P e NP em termos de busca • A definição de P e NP é como classes de problemas de decisão. • Nosso interesse são soluções que podem ser “escritas” em tempo polino- mial: Definição 11. 2010. 2. existe um problema de decisão tal que. • A classe NP: Linguagens LR tal que existe MTD que. com entrada (x. Em particular. que não tem. se existe um z tal que (x.11 Teoria de NP-completude • Vantagem: Permite mais que uma solução para cada entrada. • Intuição: Uma relação é a especificação de um problema de busca: para entrada x queremos achar alguma solução y tal que (x.1 Uma relação binária R é polinomialmente limitada se ∃p ∈ poly : ∀(x. considera o problema de decidir. A restrição para problemas de decisão simplifica o tratamento teórico.18)) Para cada problema de busca definido por uma relação polinomialmente limi- tada R. w ◦ z) ∈ R. w. para entrada x 200 . Para a relação R. caso o problema de decisão pode ser resolvido em tempo t(n). y) ∈ R em tempo polinomial. com entrada x ∈ LR . y se chama certificado. P = NP sse cada problema de busca possui solução em tempo polinomial Prova. y) ∈ R ou responda. decida se (x. y) ∈ R. busque (x. Th. 2009. em tempo polinomial. 2). o problema de busca pode ser resolvido em tempo nO(1) t(n). • A linguagem correspondente a uma relação R é LR = {x | ∃y : (x. Th.

w) 6∈ R do 6 i f A(x. construindo-a sı́mbolo por sı́mbolo. w ◦ 0) = sim then 7 w := w ◦ 0 8 else 9 w := w ◦ 1 10 end i f 11 end while 12 return w É simples de ver que este algoritmo acha uma solução para o problema de busca. para preparar a discussão sobre provas interativas.2 (Redução em tempo polinomial) Uma (many-one) redução entre duas linguagens L. 201 . ) = não then 2 return ‘ ‘ não e x i s t e s o l u ç ã o ’ ’ 3 end i f 4 w :=  5 while (x.  • TBD: Enfatiza mais a ideı́a da verificação polinomial. L0 com alfabetos Σ e Σ0 é ∗ um função total f : Σ∗ → Σ0 tal que x ∈ L ⇐⇒ f (x) ∈ L0 . caso existe uma.. Se f é com- putável em tempo polinomial.2 Reduções 1 i f A(x. Como R é poli- nomialmente limitado. Por exemplo. se chama uma redução em tempo polinomial . uma solução possui no máximo um número polinomial de sı́mbolos. bi | Matriz simétrica de distâncias M que tem TSP-cı́clo ≤ b} COMPOSITE = {hni | n = m1 m2 com m1 .2 Reduções Reduções Definição 11. 11. e por isso o algoritmo o número de chamadas de A é não mais que polinomial no tamanho da entrada. Exemplos de problemas em NP CLIQUE = {hG. ki | Grafo não-direcionado G com clique de tamanho k} SAT = {hφi | φ fórmula satisfatı́vel da lógica proposicional em FNC} TSP = {hM. 1985). escrevemos L ≤P L0 . mostra a arquitetura do sistema de provas NP (Goldwasser et al. m2 > 1} 11.

Um problema L que é C-≤-difı́cil é completo.1 (Fecho para baixo) Se A ≤P B e B ∈ P então A ∈ P. se A ≤P B e B ≤P C então A ≤P C. Prova. se L ∈ C.) Com o mesmo argumento podemos reduzir w ∈ A primeiro para w0 ∈ B e depois para w00 ∈ C. (Transitividade. • Do interesse particular: A separação de P e NP. achar problemas “difı́ceis” para separar classes.2 (Transitividade) ≤P é transitivo.3 (Problemas difı́ceis e completos) Dado uma classe de problemas C e um tipo de redução ≤. • Motivo: Estudar a complexidade relativa de problemas.  O problema de parada • O problema da parada HALT = {hM.11 Teoria de NP-completude Definição 11. Caracterı́sticas de ≤P Proposição 11. Depois podemos simular B com entrada w0 em tempo polinomial. i. se L0 ≤ L para todos L0 ∈ C. Denotamos a classe de problemas N P -completos NPC. entrada w e um número n (em codificação unária). Como a composição de polinômios é um polinômio. wi | MT M para com entrada w} não é decidı́vel.) Uma instância w ∈ A pode ser reduzido em tempo polinomial para w0 ∈ B.e. um problema L é C-≤-difı́cil. (Fecho para baixo. • Qual o caso com Parada limitada (ingl. bounded halt) Instância MT M . tudo em tempo polinomial. Proposição 11. Questão M para em n passos? 202 . A ∈ P.

Podemos reduzir uma entrada w ∈ L em tempo k polinomial para w0 = hM. 11. Prova. Para alguma linguagem L ∈ NP. 1n i pela codificação de n em unário. 1n i | MT M para com entrada w em n passos} é NP-completo.  Ladrilhar: Exemplo Ladrilhar: Solução 203 . Logo é suficiente de mostrar que qualquer problema em NP pode ser reduzido para BHALT. w. Observe que a codificação de uma execução em limitada polinomialmente em termos da entrada hM. temos w ∈ L ⇔ w0 ∈ BHALT. w. seja M uma MTND com L = L(M ) que aceita L em tempo nk . BHALT ∈ NP porque podemos verificar uma execução em n passos em tempo polinomial. Logo L ≤P BHALT.3 BHALT = {hM.2 Reduções Teorema 11. 1n i. w.

11 Teoria de NP-completude Ladrilhar: Exemplo Ladrilhar: O problema • Para um conjunto finito de cores C. o tipo de um ladrilho é uma função t : {N. S. W. E} → C. Ladrilhamento 204 .

No último caso. a) e para q. L) − (q. a0 ) (q 0 . Idéia: os cores dos cantos de sul e de norte vão codificar um sı́mbolo da fita a informação se a cabeça está presente e o estado da máquina. Prova. tem ladrilhos 205 . O problema é em NP. uma instância tem tamanho O(k + n2 ). . Nos vamos usar as cores Q ∪ {−} × Γ na direção norte/sul e Q × {L. Vamos reduzir qualquer problema em L ∈ NP para Ladrilhamento. . tk e um grade de tamanho n × n com cores nas bordas. (Cada ladrilho pode ser representado por quatro sı́mbolos para as cores. a0 . . vamos construir uma instância de Ladrilhamento do tamanho (|w|k )2 . codificado em unário. . a → q 0 . . R) (q.2 Reduções Instância Tipos de ladrilhos t1 . O canto sul da grade vão ser colorido conforme o estado inicial da máquina. . se as cores no sul e norte representam configurações sucessores. R (−. R} ∪ {−} na direção oeste/este. Para entrada w. Questão Existe um ladrilhamento da grade tal que todas cores casam (sem girar os ladrilhos)? Teorema 11. Os cores dos cantos oeste e este vão codificar informação adicional para mover a cabeça. 11. porque dado um conjunto de tipos de ladri- lhos e um ladrilhamento. a) Além disso. o canto norte com o estado final e vamos projetor as ladrilhas de tal forma que ladrilhar uma linha (de sul para o norte) e somente possı́vel. podemos verificar as restrições das cores em tempo polinomial. . Seja L = L(M ) para alguma MTND e seja k tal que M precisa tempo nk . . L os ladrilhos tem a forma (−. a0 ) − (q 0 . Para uma regra q. a0 . sl com a pergunta se eles podem ser estendidas para n × n. n deve ser uma entrada também. a grade consiste de n2 ladrilhos em branco e 4n cores.4 (Levin) Ladrilhamento é NP-completo. Somente 4n cores nas bordas ou somente ladrilhos s1 . a → q 0 .

R) − − (q. A construção do grade e das tipos de ladrilhos pode ser computado por uma máquina de Turing em tempo polinomial. que sempre é possı́vel) (qa . L) − − (−. ) e as cores dos lados oeste e este todos são −. • Outro valor: Para provar que um problema L ∈ NPC. a1 )(−.11 Teoria de NP-completude (q. a) As cores no sul da grade representam a configuração inicial (q0 . Proposição 11. Pela construção uma com- putação da MT que aceita corresponde com um ladrilhamento e vice versa. ) as cores no norte a configuração final (supondo que a máquina limpa a fita depois. por exemplo Ladrilhamento ≤P L. ) · · · (−. a) (q. a) (−. an )(−. é suficiente de mostrar que.  Resultado intermediário • Primeiros problemas em NPC: Para uma separação é “só” provar que Ladrilhamento 6∈ P ou BHALT 6∈ P.3 Se A ⊆ B e A é fechado para baixo em relação à redução ≤ e L e B-≤-completo então L ∈ A ⇐⇒ A = B. a) (q. Exemplo: O problema SAT 206 . a) (−. • Infelizmente: a prova é difı́cil. ) · · · (−. −)(−. a2 ) · · · (−. mesmo que a maioria das pesquisadores acredita P 6= NP. O fecho para baixo é necessário para evitar que A é subconjunto de B que contém os problemas completas mais não todos problemas em B. a) (−.

ti (E) ∧ ¬Ex.y := Nx.y.c c∈C c6=ti (N ) ^ ∧ Wx.y. E analogamente ^ Li.y. W. xn ).y. . .y.y.y. 11.c variável “o norte da posição x. an ∈ B que satisfaz Φ? Teorema 11.2 Reduções SAT Instância Fórmula proposicional em forma normal conjuntiva Φ(x1 . . .y.5 (Cook) SAT é NP-completo.y. Questão Tem uma atribuição a1 . .c c∈C c6=ti (E) Prova (2) 207 . .c c∈C c6=ti (W ) ^ ∧ Sx.c c∈C c6=ti (S) ^ ∧ Ex.ti (W ) ∧ ¬Wx. y tem cor c” S.x. .ti (N ) ∧ ¬Nx.ti (S) ∧ ¬Sx. . Prova (1) Objetivo: Provar Ladrilhamento ≤P SAT. Seja Nx.

O significado do P = NP Kurt Gödel 1958: Uma carta para John von Neumann Obviamente.cx. Seja φ a conjunção de ^ ^ _ Lc. Seja Φ(F.y Toda posição tem um ladrilho x∈[1.y.1.n] c∈[1. para cada fórmula F da lógica de predicados de primeira ordem e cada número na- tural n. Se existisse uma máquina com Φ(n) ∼ kn (ou pelo menos Φ(n) ∼ kn2 ).y. se F tem uma prova do tamanho n (tamanho = número de sı́mbolos). porque para fórmula φ e atribuição a. podemos construir uma máquina de Turing.n.n[ y∈[1.c Correspondência W-E x∈]1. e seja Ψ(n) = maxF Φ(F.n] Prova (3) • O número de variáveis e o tamanho de φ é polinomial em n.c Correspondência E-W x∈[1.cn.y as cores na bordas.x. • Portanto.n] y∈[1. SAT é NP-difı́cil.c Correspondência S-N x∈[1. n). k.E y∈[1.y.k] ^ Sx.n[ ^ ^ Sx. podemos verificar a |= φ em tempo polinomial.n[ y∈]1.y.y.n Cores corretas nas bordas N.c ⇒ Ex−1. É possı́vel provar que Φ(n) ≥ kn.c ⇒ Nx.y Cores corretas nas bordas W. que decide.n] ^ ^ Wx. n) o número de passos que a máquina precisa para isso.cx.c ⇒ Wx+1.c1.y.S x∈[1.n[ y∈[1. A questão é como Φ(n) cresce para uma máquina ótima.1 ∧ Nx. isso teria consequências da maior 208 .y ∧ En.c ⇒ Sx.y.n] y∈[1.11 Teoria de NP-completude Sejam cx.y+1.y.y−1.n] ^ ^ Ex.c Correspondência N-S x∈[1.n] ^ W1.n] ^ ^ Nx. • SAT ∈ NP. φ pode ser computado em tempo polinomial para uma instância de Ladrilha- mento.

11.2 Reduções

importância. Assim, seria óbvio, apesar da indecibilidade do Entscheidungs-
problem, poderia-se substituir completamente o raciocı́nio do matemático em
questões de sim-ou-não por máquinas. (Sipser, 1992)
Em original a carta diz
Man kann offenbar leicht eine Turingmaschine konstruieren, welche von
jeder Formel F des engeren Funktionenkalküls u. jeder natürl. Zahl n
zu entscheiden gestattet, ob F einen Beweis der Länge n hat [Länge
= Anzahl der Symbole]. Sei Ψ(F, n) die Anzahl der Schritte, die die
Maschine dazu benötigt u. sei φ(n) = maxF Ψ(F, n). Die Frage ist,
wie rasch φ(n) für eine optimale Maschine wächst. Man kann zeigen
φ(n) ≥ k ·n. Wenn es wirklich eine Maschine mit φ(n) ∼ k ·n (oder auch
nur ∼ k · n2 ) gäbe, hätte das Folgerungen von der grössten Tragweite.
Es würde nämlich offenbar bedeuten, dass man trotz der Unlösbarkeit
des Entscheidungsproblems die Denkarbeit des Mathematikers bei ja-
oder-nein Fragen vollständig durch Maschinen ersetzen könnte.

A significado do P = NP

• Centenas de problemas NP-completos conhecidos seriam tratável.

• Todos os problemas cujas soluções são reconhecidas facilmente (polino-
mial), teriam uma solução fácil.

• Por exemplo na inteligência artificial: planejamento, reconhecimento de
linguagens naturais, visão, talvez também composição da música, escre-
ver ficção.

• A criptografia conhecida, baseada em complexidade, seria impossı́vel.

I have heard it said, with a straight face, that a proof of P = NP
would be important because it would airlines schedule their flight
better, or shipping companies pack more boxes in their trucks! (Aa-
ronson, 2005)

Mais um problema NP-completo

Minesweeper consistência

Instância Uma matriz de tamanho b × b cada campo ou livre, ou com um
número ou escondido.

209

11 Teoria de NP-completude

Decisão A matriz é consistente (tem uma configuração dos campos es-
condidos, que podem ser “bombas” ou livres tal que os números são
corretos)?

O mundo agora
• O milagre da NP-completude
– Qualquer problema em NP tem uma redução po-
linomial para SAT!
– Por que não usar só SAT? (soluções em 1.3n )?
Teorema 11.6 (Ladner (Ladner, 1975))
• Se P 6= N P , existe uma linguagem L ∈ N P que nem
é NP-completo nem em P.
Stephen Arthur
Cook (*1939)

Leonid Levin
(*1948)

Muitos se interessavam

Woeginger’s página sobre P vs. NP

210

12 Fora do NP
Classes fora do P-NP

L = DSPACE[log n]
NL = NSPACE[log n]
[ k
EXPTIME = DTIME[2n ]
k>0
[ k
NEXPTIME = NTIME[2n ]
k>0
[ k
EXPSPACE = DSPACE[2n ]
k>0
[ k
NEXPSPACE = NSPACE[2n ]
k>0

Co-classes
Definição 12.1 (Co-classes)
Para uma linguagem L, a linguagem complementar é L = Σ∗ \ L. Para uma
classe de complexidade C, a co-classe co − C = {L | L ∈ C} e a classe das
linguagens complementares.
Proposição 12.1
P = co− P.
• Qual problema pertence à NP?
CLIQUE, SAT, TSP, COMPOSITE.

Prova. Seja L ∈ P. Logo existe um MTD M tal que L = L(M ) em tempo
nk . Podemos facilmente construir uma MTD que rejeita se M aceita e aceita
se M rejeita. 
Não sabemos se CLIQUE, SAT, TSP pertencem à NP. Em 2002 foi provado,
que COMPOSITE ∈ P (Agrawal et al., 2004). Observe que se aplicas so para
o teste se um número e primo ou não. O problema de fatorização é mais
complicado.

211

12 Fora do NP

A classe co-NP

• A definição da classe NP é unilateral. Por exemplo, considere

TAUT
Instância Fórmula proposicional em forma normal disjuntiva ϕ.
Decisão ϕ é uma tautologia (Todas as atribuições satisfazem ϕ)?

• Uma prova sucinta para esse problema não é conhecido, então suponha-
mos que TAUT 6∈ NP.

• Em outras palavras, NP parece de não ser fechado sobre a comple-
mentação:
co-NP 6= NP ?

Proposição 12.2
Se L ∈ NPC então L ∈ co-NP ⇐⇒ NP = co-NP.

Proposição 12.3
TAUT é co-NP-completo.

Prova. (Proposição 12.2.) Seja L ∈ NPC. (→): Seja L ∈ co-NP. Se L0 ∈ NP,
temos L0 ≤P L ∈ co-NP, logo NP ⊆ co-NP. Se L0 ∈ co-NP, então L0 ∈ NP e
L0 ≤P L ∈ co-NP, logo L0 ∈ co-NP e L0 ∈ NP. (←): Como L ∈ NPC ⊆ NP, e
NP = co-NP, também L ∈ co-NP. 
Prova. (Proposição 12.3, rascunho.) TAUT ∈ co-NP, porque uma MT com
um estado universal pode testar todas atribuições das variáveis proposicionais
e aceita se todas são verdadeiras.
Para provar a completude, temos que provar, que toda linguagem L ∈ co-NP ≤P
TAUT. A prova é uma modificação da prova do teorema de Cook: Com en-
trada w ∈ L produzimos uma fórmula ϕw usando o método de Cook. Temos

w ∈ L ⇐⇒ ϕw satisfatı́vel pela def. de ϕw
w ∈ L ⇐⇒ ϕw insatisfatı́vel negação da afirmação
⇐⇒ ¬ϕw é tautologia



212

SAT = {hϕi | ϕ em FNC é satisfatı́vel}
SAT = {hϕi | ϕ em FNC é insatisfatı́vel (ou lixo)}
= {h¬ϕi | ϕ em FND é uma tautologia (ou lixo)} = ¬TAUT
TAUT = {hϕi | ϕ em FND é uma tautologia}

SAT é trivial sobre fórmulas disjuntivas, TAUT é trivial sobre fórmulas con-
juntivas (ambas tempo O(n)).

A classe co-NP

• NP: Resposta sim, se existe uma computação que responde sim.

• Ou: Dado um certificado, verificável em tempo polinomial.
• co-NP: Resposta sim, se todas as computações respondem sim

• Ou: Dado um “falsificado”, falsificável em tempo polinomial.

O mundo da complexidade ao redor do P

213

• Lembrança a problema de Post: Palavras v1 .q.1 De P até PSPACE • Quase todos os problemas não são recursivos (Teorema do Rice). quantified boolean formulas. . . . . se NP = PSPACE ou até P = PSPACE • Como resolver isso? Da mesma forma que a questão P = NP: busque problemas PSPACE-completos (relativo a ≤P ). xn )] com Qi ∈ {∀. QBF) Instância Uma sentença booleana Φ := (Q1 x1 )(Q2 x2 ) · · · (Qn xn )[ϕ(x1 . w1 . . . wn : ∃i1 . .12 Fora do NP 12. vi1 · · · vik = wi1 · · · wik ? O mundo inteiro (2) Problemas PSPACE-completos • Não sabemos. vm . . . . . ik t. . . Decisão Φ é verdadeira? 214 . ∃}. . . x2 . • Considere Formulas booleanas quantificadas (ingl. .

s.t que afirma que tem uma transição do estado q para s em ao máximo t passos.1 podemos usar basicamente a mesma fórmula do teorema de Cook.s. Decisão w ∈ L(Γ) Mais quantificações O que acontece.t/2 ) define se tem uma transição com estado intermediário r.t/2 ∧ φr. palavra w.r. s)}(φa. . (Rascunho. Um estado pode ser codificado em um string de |w|k bits.  Outro exemplo Palavra em linguagem sensı́vel ao contexto Instância Gramática Γ sensı́vel ao contexto. Para provar a completude. Para t > 1 a fórmula φq.1 QBF é PSPACE-completo.t/2 ) evite a ocorrência dupla de φ a tem comprimento polinomial. Essa fórmula infeliz- mente tem t sı́mbolos (que é demais para 2cf (n) ).2cf (n) com 2cf (n) sendo o número máximo de estados para entradas de tamanho n. temos que mostrar que toda linguagem L ∈ PSPACE pode ser reduzido para QBF. A idéia é testar φq0 . ∃} vamos aplicar o algoritmos para os casos ϕ(0) e ϕ(1).) com Q ∈ {∀.) É fácil de provar que QBF ∈ PSPACE: Podemos verificar recursivamente que a sentença é verdadeira: Para uma fórmula Qx1 ϕ(x1 . A idéia principal é construir uma fórmula φq. 12. r).s.r. Prova. .qf .t = ∃r∀(a. b) ∈ {(q. se nós permitimos mais quantificações? 215 . mas a fórmula φq. (r.s.b. Para φq. .t = ∃r(φq.1 De P até PSPACE • Exemplo: (∀x1 )(∃x2 )(∀x3 )(x1 ∨ x3 ≡ x2 ) Teorema 12. Assume que existe uma MT que reconhece L = L(M ) em espaço nk e seja w ∈ L.

. . . . . . . . y1 . y1 . e x ∈ L ⇐⇒ ∀y1 ∃y2 · · · Qi : (x. . y1 . e x ∈ L ⇐⇒ ∃y1 ∀y2 · · · Qi : (x. Σi+1 = NPΣi Πi+1 = co−Σi+1 ∆i+1 = PΣi 216 . yi ) ∈ R • Definição: Πi é a classe das linguagens L. Uma relação R ⊆ (Σ∗ )i+1 é limitada polinomial. . Π1 = co-NP. tal que existe uma relação de aridade i + 1 que pode ser reconhecida em tempo polinomial. • Observação: Σ1 = NP.12 Fora do NP A hierarquia polinomial • Estendemos relações para aridade i + 1. . . yi ) ∈ R • As classes Σi e Πi formam a hierarquia polinomial. tal que existe uma relação de aridade i + 1 que pode ser reconhecida em tempo polinomial. yi ) ∈ R ∃p ∈ poly ∀i |yi | ≤ p(|x|) • Definição: Σi é a classe das linguagens L. se ∀(x.

Kozen.1 De P até PSPACE Quantificações restritas ou não • Conjunto das classes com quantificações restritas: [ PH = Σk k≥0 • Classe das linguagens reconhecidas por um máquina de Turing com al- ternações sem limite: APTIME • As máquinas correspondentes são máquinas de Turing com alternação com tempo t(n): ATIME[t(n)]. Stockmeyer) Para t(n) ≥ n [ 2 ATIME[t(n)] ⊆ DSPACE[t(n)] ⊆ ATIME[ct(n) ]. c>0 Corolário 12. 12.1 ATIME = PSPACE • Esta caracterização facilite entender por que QBF é PSPACE-completo A hierarquia polinomial Uma expressão inteira é • Um numeral n em binário (representando o conjunto {n}) • (e ∪ f ).2 (Chandra. Teorema 12. se e e f são expressões inteiras (representando o conjunto e ∪ f ) 217 .

. . . 1987).12 Fora do NP • (e + f ). . vários jogos são PSPACE-completos: Generalized Hex. . n] com i∈T yi ∈ I. b ∈ f ) Integer expression equivalence Instância Duas expressões inteiros e. . Seja M = Z ∩ [1. existe um passo tal que possa ganhar?” • Ganhar um jogo: ∃p1 ∀p2 ∃p3 ∀p4 · · · ∃p2k+1 : p1 . um ı́ndice k. Double Knapsack Instância Dois conjuntos de itens X = {x1 . . . . se e e f são expressões inteiras (representando o conjunto {a + b|a ∈ e. Auxilio Seja P Z o conjunto de números inteiros tal queP existe S ⊆ [1. 218 . tal que para todos os passos do adversário. xm } ⊆ N. . m] com i∈S xi ∈ I mas não existe T ⊆ [1. • Ganhar um jogo em um passo: ”Existe um passo tal que possa ganhar?” • Ganhar um jogo em dois passos: ”Existe um passo. um limite N ∈ N. Y = {y1 . Decisão O bit k do M é 1? Comentário ∆P 3 -completo (Krentel. p3 . p2 . Decisão e e f representam conjuntos diferentes? Comentário ΣP 2 -completo. N ] caso Z 6= ∅ ou M = 0 caso contrário. • Portanto. . Mais exemplos da classe PSPACE • Observação: Uma questão com alternação é tı́pica para resolver jogos. . gene- ralized Geography. p2k+1 é uma sequência de passos para ganhar. . . . f . yn } ⊆ N.

Mais exemplos da classe PSPACE (3) Geografia generalizada (ingl. A única resposta para isso é Omã – a segunda vez. Generalized geography) Instância Um grafo G = (V. O primeiro jogador que não é capaz de dizer um novo paı́s.. 219 . 12. Peru. Cada nome tem que começar com a última letra do nome anterior. o primeiro jogador pode ga- nhar com certeza? Teorema 12. E) e um nó v0 ∈ V Decisão Jogando ”geografia”com este grafo.1 De P até PSPACE Mais exemplos da classe PSPACE (2) Jogo de geografia para dois jogadores. perde. Aqui só tem dois saı́das pouco conhecidos: Afeganistão e Azerbaijão. Em alternação cada jogador diz o nome de um paı́s. ele não tem resposta..3 Geografia generalizada é PSPACE-completo. Minha estratégia (em português): Tira o adversário em paı́ses com a.

consideramos os seguintes classes O(1) [ k EXP = DTIME[2n ]= DTIME[2n ] k≥0 O(1) [ k NEXP = NTIME[2n ]= NTIME[2n ] k≥0 O(1) [ k EXPSPACE = DSPACE[2n ]= DSPACE[2n ] k≥0 • Estas classes são as primeiras demonstravelmente separadas de P. Generalized chess) Instância Uma configuração de xadrez com tabuleiro de tamanho n × n.2 De PSPACE até ELEMENTAR Problemas intratáveis demonstráveis • Agora. • Consequência: Uma linguagem completa em EXP não é tratável. Decisão Branco pode forçar o ganho? Intuição para problemas completos: NP: Suchbaum hat exponentielle Zahl von Blättern. • Exemplo de um problema EXP-completo: Xadrez generalizada (ingl.12 Fora do NP O mundo até PSPACE 12. 220 . aber alle Pfade haben polynomiale Länge.

Problemas ainda mais intratáveis • As classes k − EXP. considere a torre de dois de altura três: 22 0 1 2 3 4 4 16 65536 ≈ 1.16 × 1077 ≈ 2 × 1019728 • Problemas desse tipo são bem intratáveis [ ELEMENTAR = k − EXP k≥0 • Mas tem ainda problemas decidı́veis fora desta classe! O mundo até ELEMENTAR Um corte final: Expressões regulares • Uma expressão regular é 221 . Summation).U. EXPTIME: Hier haben selbst (einzelne) Pfade exponentielle Länge. k − NEXP e k − EXPSPACE tem k nı́veis de expo- nenciação! 2k • Por exemplo. alle durchgehen (z. aber ich muss u.2 De PSPACE até ELEMENTAR PSPACE: Auch hier haben Pfade noch polynomiale Länge. 12.B.

• Decisão: Dadas as expressões regulares e. ∗ . ·.3 Exercı́cios Exercı́cio 12. ·. shows that graph isomorphism is PSPACE-complete. • Operadores possı́veis: ∪. (Delacorte. and finite automata see [3] for example.2 .∗ PSPACE ∪. ·. · NP ∪. Acha o erro na prova. ¬ Fora do ELEMENTAR! • O tempo do último problema de decisão cresce ao menos como uma torre de altura lg n. L(e) 6= L(f )? Expressões regulares com Completo para ∪. se ◦ é um operador. right-linear grammars. ·. e e. – e ◦ f . 12.12 Fora do NP – 0 ou 1 (denota o conjunto L(0) = {0} e L(1) = {1}).1 Considera a seguinte prova que o problema de isomorfismo de grafos (GI) é PSPACE-completo: The equivalence problem for regular expressions was shown to be PSPACE-complete by (Meyer and Stockmeyer [2]). 2007) Sabendo que GI pertence a NP isso implicaria PSPACE = NP. 2 . ·. Taking these two results together with the equi- valence of regular expressions.2 NEXP ∪. f . f são expressões regulares. Booth [1] has shown that isomorphism of finite automata is equivalent to graph isomorphism. ¬. 222 .∗ EXPSPACE ∪.

1) x ≤ |x| (A.A Conceitos matemáticos Nessa seção vamos repetir algumas definições básicas da matemática. Definição A. O casos restantes podem ser analisadas analogamente. (ii) Analise da casos. racionais e reais. Para um conjunto finito S. Escrevemos também N0 = N ∪ {0}. respectivamente. se x > 0 temos y > 0 e |xy |= xy = |x||y|.4) Prova. P(S) denota o conjunto de todos subconjuntos de S. Caso xy < 0 similar. logo ` x |= −x e |x |= −x. C+ := {x ∈ C|x > 0} e C− := {x ∈ C|x < 0}. (iv) Para xy ≥ 0: Se x = 0 temos |xy |= 0 = |x||y|. (i) Se −x > 0 temos x < 0. (iii) Para x + y < 0: |x + y |= −(x + y) = (−x) + (−y) ≤` x|+ ` y |= |x| + |y|. Por exemplo R+ = {x ∈ R|x > 0}.1 (Regras para valores absolutos) ` x| = |x| (A. Z.1 Funções comuns N. inteiros. A.  223 . e para um dos conjuntos C acima.1 (Valor absoluto) O valor absoluta | · | é definido por ( x se x ≥ 0 |x |= −x se x < 0 Proposição A.3) |xy| = |x||y| (A. Para x + y ≥ 0: |x + y |= x + y ≤ |x| + |y|. se x < 0 temos y < 0 e |xy |= xy = (−|x|)(−|y|) = |x||y|. Q e R denotam os conjuntos dos números naturais sem 0.2) |x + y| ≤ |x| + |y| Desigualdade triangular (A.

A Conceitos matemáticos Corolário A.1 .

.

.

.

.

X .

X .

.

xi .

.

5) . ≤ |xi | (A.

1≤i≤n .

1≤i≤n .

.

.

.

.

Y .

Y .

.

x i .

= .

|xi | (A.6) .

1≤i≤n .

8) i i i Prova. Prova com indução sobre n. Proposição A. Observe que o parte fracionário sempre é positivo. Seja ak + bk = maxi ai + bi . 1≤i≤n (A.7. Logo   max ai + bi = ak + bk ≤ max ai + bi ≤ max ai + max bi . i i i i  Definição A.10) 224 .3 (Regras para pisos e tetos) Pisos e tetos satisfazem x ≤ dxe < x + 1 (A.  Proposição A. Formalmente bxc = max{y ∈ Z|y ≤ x} dxe = min{y ∈ Z|y ≥ x} O parte fracionário de x é {x} = x − bxc. bi ∈ R max ai + bi ≤ max ai + max bi (A.3} = 0. por exemplo {−0.2 (Regras para o máximo) Para ai .9) x − 1 < bxc ≤ x (A.2 (Pisos e tetos) Para x ∈ R o piso bxc é o maior número inteiro menor que x e o teto dxe é o menor número inteiro maior que x.7) Prova.

15) m loga (nm ) = m · loga (n) propriedade da potência (A. 1≤i≤n Temos a seguinte aproximação do fatorial (fórmula de Stirling) √  n n n! = 2πn (1 + O(1/n)) (A.14) n loga ( ) = loga (n) − loga (m) propriedade da divisão (A.13) loga (n · m) = loga (n) + loga (m) propriedade do produto (A. 225 .11) e Uma estimativa menos preciso.18) logc (a) 1 logb (a) = (A.12) loga (n) a =n por definição (A.17) logc (n) loga (n) = mudança de base (A.20) Os números harmônicos X 1 Hn = i 1≤i≤n ocorrem freqüentemente na análise de algoritmos.19) loga (b) alogc (b) = blogc (a) expoentes (A.16) loga (n) = logb (n) · loga (b) troca de base (A. A. Revisão: Logaritmos loga (1) = 0 (A.3 O fatorial é a função Y n! : N → N : n 7→ i. pode ser obtido pelas observações n! ≤ nn X ni nn en = > i! n! i≥0 que combinado ficam (n/e)n ≤ n! ≤ nn .1 Funções comuns Definição A.

Resultado da observação que Z n+1 Z n+1 1 1 dx < Hn < 1 + dx 1 x 2 x−1 R (veja figura A.2 Somatório Revisão: Notação Somatório 226 .A Conceitos matemáticos Proposição A. A.1: Cota inferior e superior dos números harmônicos.1) e o fato que 1/x = ln x: Z n+1 1 ln(n) ≤ ln(n + 1) = 1 x Z n+1 1 = ln(n) 2 x−1  2 1 0 0 1 2 3 4 5 6 7 8 9 10 Figura A. Prova.4 ln n < Hn < ln n + 1.

temos C = [0. Algoritmo A. A.23) i=1 j=1 i=1 j=1 n X n X n X (ai + bi ) = ai + bi Associatividade (A. faça um algoritmo que copie a matriz triangular inferior de matB para matA.24) i=1 i=1 i=1 Xp n X n X ai + ai = ai (A. pois laços while e for em geral podem ser representados por somatórios. Dadas duas matrizes matA e matB. i∈C π(i)∈C No exemplo da regra acima.2 Somatório Para k uma constante arbitrária temos n X n X kai = k ai Distributividade (A. 0≤i≤n 0≤p−i≤n p−n≤i≤p Parte da análise de algoritmos se faz usando somatórios.26) i=0 i=p−n A última regra é um caso particular de troca de ı́ndice (ou comutação) para somas.22) i=1 n X m n ! m  X X X ai bj = ai  bj  Distributividade generalizada (A.25) i=1 i=p+1 i=1 n X Xp ap−i = ai (A. Saı́da Matriz A com a matriz triangular inferior copiada de B.1 (CopiaMTI) Entrada Matrizes quadráticos A e B e dimensão n. Para um conjunto finito C e uma permutação dos números inteiros π temos X X ai = aπ(i) . Como exemplo. n] e π(i) = p − i e logo X X X ap−i = ap−(i−p) = ai . 227 . considere o seguinte problema.21) i=1 i=1 Xn k = nk (A.

28) i=0 x−1 se |x| < 1 então ∞ X 1 xk = série geométrica infinitamente decrescente (A. para x 6= 1 (A.A Conceitos matemáticos 1 f o r i := 1 t o n do 2 f o r j := 1 t o i do 3 Aij = Bij 4 end f o r 5 end f o r Uma análise simples deste algoritmo seria: X i n X n X 1= i = n(n + 1)/2 = O(n2 ) i=1 j=1 i=1 Séries n X n(n + 1) i= série aritmética (A.27) i=1 2 n X xn+1 − 1 xi = série geométrica.29) 1−x k=0 Série geométrica com limites arbitrários: X xb+1 − xa xi = para x 6= 1 x−1 a≤i≤b Séries 228 .

3 Indução Revisão: Indução matemática • Importante para provar resultados envolvendo inteiros. A.31) i=0 6 Xn i2i = 2 + (n − 1)2n+1 (A. 1≤j≤n 1≤i≤n 1≤i<j Uma aplicação:   X X X X X  xn+1 − x1 xj − x1  ixi =  xi − xi  = − x−1 x−1 1≤i≤n 1≤j≤n 1≤i≤n 1≤i<j 1≤j≤n 1 X xn+1 − x j  = x−1 1≤j≤n xn+1 − x1   1 n+1 x = nx − = (xn (nx − n − 1) + 1) x−1 x−1 (x − 1)2 e com x = 1/2 temos X i2−i = 2(2(2−1 −2−n−1 )−n2−n−1 ) = 2((1−2−n )−n2−n−1 ) = 2−2−n (n+2) 1≤i≤n (A.33) A.3 Indução n X 2i = 2n+1 − 2 (A.30) i=1 n X n(n + 1)(2n + 1) i2 = (A.32) i=0 Mais geral para alguma sequência fi temos X X X X X X ifi = fi = fi = fi 1≤i≤n 1≤i≤n 1≤j≤i 1≤j≤i≤n 1≤j≤n j≤i≤n   X X X =  fi − fi  . 229 .

conclui-se que P(n) é valida para qualquer valor de n ≥ n0 Indução matemática: exercı́cios • Mostre que n! ≤ nn . • Encontre uma fórmula alternativa para n X 2i − 1 i=1 e prove seu resultado via indução matemática. – Prova: provar que P(n) é válida para qualquer valor de n ≥ n0 . • Use indução matemática para provar que n−1 X qn − 1 qi = . i=0 q−1 • Resolva os exercı́cios do capı́tulo 1. – Hipótese: assumir P(n) válida. Revisão: Indução matemática • Para aplicarmos indução matemática deve-se: – Passo inicial: verificar se P(n) é verdadeira para a base n0 . • Se os passos acima forem verificados. 230 .A Conceitos matemáticos • Seja P(n) uma propriedade relativa aos inteiros. 1 • Mostre que loga (c) = logc (a). • Demonstre a propriedade dos expoentes. – Se P(n) é verdadeira para n=1 e – se P(k) verdadeira implica que P(k+1) é verdadeira – então P(n) é verdadeira para todo inteiro n ≥ 1.

35) n→∞ Também temos   lim inf f (n) = lim inf f (m) n→∞ n→∞ m≥n   lim sup f (n) = lim sup f (m) n→∞ n→∞ m≥n Lema A.34) n→∞ Caso não existe um c ∈ R a função é divergente. Uma forma especial de divergência é quando a função ultrapasse qualquer número real. ⇒ é obvio.1 (Definição alternativa do limite) É possı́vel substituir < com ≤ na definição do limite.5 Probabilidade discreta Probabilidade: Noções básicas • Espaço amostral finito Ω de eventos elementares e ∈ Ω. escolhe 0 = /2 < . (A.  A. A.4 (Limites) Para f : N → R o limite de n para ∞ é definido por lim f (n) = c ⇐⇒ ∃c ∀ > 0 ∃n0 ∀n > n0 |f (n) − c| < . Para ⇐.4 Limites Definição A. lim f (n) = ∞ ⇐⇒ ∀c ∃n0 ∀n > n0 f (n) > c (A.4 Limites A. • Distribuição de probabilidade Pr[e] tal que X Pr[e] ≥ 0. Pr[e] = 1 e∈Ω • Eventos (compostos) E ⊆ Ω com probabilidade X Pr[E] = Pr[e] e∈E 231 . lim f (n) = c ⇐⇒ ∀ > 0 ∃n0 ∀n > n0 |f (n) − c| ≤  n→∞ Prova.

) X X Pr[X = i]i = Pr[X −1 (i)]i 0≤i 0≤i X X X = Pr[e]X(e) = Pr[e]X(e) 0≤i e∈X −1 (i) e∈Ω  Prova. 5. • Variáveis aleatórias independentes P [X = x e Y = y] = P [X = x]P [Y = y] • Valor esperado X X E[X] = Pr[e]X(e) = i Pr[X = i] e∈Ω i≥0 • Linearidade do valor esperado: Para variáveis aleatórias X.1 Para um dado sem bias temos Ω = {1. 4. 3. 6} e Pr[i] = 1/6. 2.) X E[X + Y ] = Pr[e](X(e) + Y (e)) e∈Ω X X = Pr[e]X(e) Pr[e]Y (e)) = E[X] + E[Y ] e∈Ω e∈Ω  232 . (Da linearidade.P 4.A Conceitos matemáticos Exemplo A. 6} tem probabilidade Pr[Par] = e∈Par Pr[e] = 1/2. Y E[X + Y ] = E[X] + E[Y ] Prova. (Das formulas equivalentes para o valor esperado. O evento Par = {2. ♦ Probabilidade: Noções básicas • Variável aleatória X:Ω→N • Escrevemos Pr[X = i] para Pr[X −1 (i)].

X X E[X] = Pr[X = i]i = 1/6 i = 21/6 = 7/2 i≥0 1≤i≤6 X E[Y ] = Pr[Y = i]i = Pr[Y = 1] = 1/2E[X + Y ] = E[X] + E[Y ] = 4 i≥0 ♦ A. Um ciclo de comprimento k + 1 é um caminho com a aresta adicional {vn . a vizinhança (de vértices) N (v) é o conjunto de todas vértices adjacentes com ele. escrito G0 = G[V 0 ]. escrito G0 ⊆ G. duas arestas e. se {u. . E) de vértices V e arestas E ⊆ V 2 . Cada aresta e = (u.1. v existe um caminho entre eles em G. E) de vértices (ou nós ou pontos) V e arestas (ou arcos ou linhas) E tal que E ⊆ [V ]2 .e. Dois vértices u. . se e ∩ f 6= ∅. E 0 = E ∩ [V 0 ]2 ) ela é um subgrafo induzido de V 0 em G. vi+1 } | 0 ≤ i < k}) com todo vi diferente. v) tem um começo u e um termino v. Caso G0 contém todas arestas entre vértices em V 0 (i. O grau de um vértice v é o número de vizinhos δ(v) = |N (v) |= |E(v)|. {{vi . o ciclo de comprimento k com C k . respectivamente. Um subgrafo de G é um grafo G0 = (V 0 . . Um caminho de comprimento k é um grafo C = ({v0 . e a vizinhança (de arestas) E(v) é o conjunto de todas arestas adjacentes com ele. Para um vértice v. v0 }. .) Seja X a variável aleatório que denota o número sorteado.6 Grafos Exemplo A. Um grafo direcionado é um par G = (V. E 0 ) tal que V 0 ⊆ V e E 0 ⊆ E. Um grafo (ou grafo não-direcionado) é um par G = (V. Com |G| e kGk denotamos o número de vértices e arestas. Um grafo G é conexo se para todo par de vértices u. e Y a variável aleatório tal que Y = [a face em cima do dado tem um ponto no meio]. v} ∈ E.2 (Continuando exemplo A. 233 . f são adjacentes. A. O caminho com comprimento k é denotado com P k . v são adjacentes.6 Grafos Seja [D]k o conjunto de todos subconjuntos de tamanho k de D. vk }.

.

2: Se g ∈ cΩ(f ). “⇐”: Seja f + c ∈ O(g).4) Ω(f )Ω(g) = Ω(f g) (B. Portanto ∀n > n0 g = cg 0 ≥ cc0 f e com cc0 e n0 temos g ∈ Ω(f ). logo existem c0 e n0 tal que ∀n > n0 f + c ≤ c0 g.15 com ≤ substituı́do por ≥.1: Escolhe c = 1. Prova de B. As provas são modi- ficações simples das provas das caracterı́sticas 1.5: h = f 0 g 0 com f 0 ≥ cf f e g 0 ≥ cg g tal que h = f 0 g 0 ≥ cf cg f g.B Soluções dos exercı́cios Solução do exercı́cio 1.1) cΩ(f ) = Ω(f ) (B. e logo g ≥ cc0 h a partir de max(n0 . As caracterı́sticas correspondentes são f = Ω(f ) (B. Prova de B.2. Prova de B. Portanto f ≤ f + c ≤ c0 g também. Escrevendo h = f g 0 temos que mostrar g 0 ∈ Ω(g). n0 = 0. temos g = cg 0 e existem c0 > 0 e n0 tal que ∀n > n0 g 0 ≥ c0 f .5) Ω(f g) = f Ω(g) (B. Prova de B. “⇒”: Essa direção no caso geral não é válida.3) Ω(Ω(f )) = Ω(f ) (B. Mas g 0 = h/f ≥ cf g/f = cg.4: Para g ∈ Ω(Ω(f )) temos g ≥ ch com h ≥ c0 f a partir de ı́ndices n0 e n00 .6) Todas as caracterı́sticas se aplicam para Ω também. Prova de B.1. Um contra-exemplo simples é 0 ∈ O(0) mas 0 + c 6∈ O(0).  Solução do exercı́cio 1.3: Para g ∈ Ω(f ) + Ω(f ) temos g = h + h0 com c > 0 e n0 tal que ∀n > n0 h ≥ cf e c0 > 0 e n00 tal que ∀n > n0 h0 ≥ c0 f . Prova. n00 ) temos g = h + h0 ≥ (c + c0 )f . e temos f ∈ O(g). Prova de B. n00 ).10 até 1.2) Ω(f ) + Ω(f ) = Ω(f ) (B.6: h ≥ cf g. Logo para n > max(n0 . O problema é que a função g pode ser 0 um número infinito 235 .

Logo para n > max(n00 . Escolhe um c. E simples ver que f ∈ ô(g) implica f ∈ o(g). Então f = log g ≤ log cn2 = log c+2 log n ≤ 3 log n para n > max(c. i. Uma tentativa leva a fn = 2fn−1 ≤ 2cn 6≤ cn Perdido! que mostra que essa prova não funciona. Assim f tem que ser 0 nesses pontos também. 236 . f = log g com g tal que ∃n0 . Logo f ≤ c/2g < cg para n > max(n0 .4. 1. Seja f ∈ log O(n2 ). n0 ). Como g ∈ Ω(1) também existem c00 e n000 tal que ∀n > n000 g ≥ c00 . c c Solução do exercı́cio 1. c ∀n > n0 g ≤ cn2 . 3. Temos que mostrar que ∀c > 0 : ∃n0 tal que f < cg.B Soluções dos exercı́cios de vezes. Como f ∈ o(g) sabemos que existe um n0 tal que f ≤ c/2g para n > n0 .6. e por isso ela não é válida. Para provar fn = O(n) temos que provar que existe um c tal que fn ≤ cn a partir um ponto n0 .5. Temos que mostrar que existem c e n0 tal que ∀n > n0 log log n ≤ c log n. Mas com a restrição que g ∈ Ω(1). mas f + c não é. 2.3. Para mostrar a outra direção suponha que f ∈ o(g). Para n ≥ 2 temos log 1 + n ≤ log 2n = log 2 + log n ≤ 2 log n.e. n00 ). Primeira verifique-se que Φ satisfaz Φ + 1 = Φ2 . Solução do exercı́cio 1. Solução do exercı́cio 1. n000 ) c c f + c ≤ c0 g + c ≤ c0 g + 00 g = (c0 + 00 )g. Ele tem que provar que fn ≤ cn para algum c fixo. Se g 6= 0 para n > n00 então c/2g < g também. Na verificação do professor Veloz a constante c muda implicitamente. temos uma prova: Seja f ∈ O(g) logo existem c0 e n00 tal que ∀n > n00 f ≤ c0 g. Como log n ≤ n para todos n ≥ 1 a inequação acima está correto com c = 1. Solução do exercı́cio 1. É importante que a constante c é a mesma para todo n.

Solução do exercı́cio (Toscani and Veloso.5 ≤ n (equação linear) √ 2. d1 ns ≤ g ≤ d2 ns a partir de um n0 (para constantes c1 . Prova que fn ∈ Ω(Φn ) com indução que fn ≥ cΦn .) Logo d1 f q ≤ g ◦ f ≤ d2 f q ⇒ d1 (c1 np )q ≤ g ≤ d2 (c2 np )q ⇒ f1 cq1 np+q ≤ g ≤ d2 cq2 np+q ⇒ g ∈ Θ(np+q ) 237 . 2005. 2005. 2.38.62. 6. .809 . 1.3). 3n + 7 ≤ 5n + 2 ⇐⇒ 5 ≤ 2n ⇐⇒ 2. Base: Vamos escolher n0 = 1.9). 2.Prova que fn ∈ O(Φn ) com indução que fn ≤ cΦn . Base: f0 = 0 ≤ c e f1 = 1 ≤ cΦ para c ≥ 1/Φ ≈ 0. 5n + 7 ≤ 3n2 + 1 ⇐⇒ 0 ≤ 3n2 − 5n − 6 ⇐⇒ 5/6 + 97/6 ≤ n (equação quadrática) 3. Passo: fn = fn−1 + fn−2 ≤ cΦn−1 + cΦn−2 = (cΦ + c)Φn−2 ≤ cΦn caso cΦ + c ≤ cΦ2 . c2 . d2 . Veja item (b) 5. . n2 3n ≥ n3 2n + 1 ⇐ n2 3n ≥ n3 2n+1 ⇐⇒ 2 log2 n + n log2 3 ≥ 3 log2 n + (n + 1) log2 2 ⇐⇒ n log2 3 ≥ log2 n + (n + 1) ⇐ n(log2 3 − 1)/2 ≥ log2 n Solução do exercı́cio (Toscani and Veloso. 52n + 3 ≥ 3n2 + 5n ⇐⇒ n ≥ 2n ≥ (3n2 + 5n − 3)/5 ⇐ 2n ≥ n2 . Com f ∈ Θ(nr ) e g ∈ Θ(ns ) temos c1 nr ≤ f ≤ c2 nr . d1 . f1 = 1 ≥ cΦ e f2 = 1 ≥ cΦ2 caso c ≤ Φ−2 ≈ 0. Passo: fn = fn−1 + fn−2 ≥ cΦn−1 + cΦn−2 = (cΦ + c)Φn−2 ≤ cΦn caso cΦ + c ≥ cΦ2 . ≤ n 4. 5 log2 n + 7 ≤ 5n + 1 ⇐⇒ 75 + 27 − 2 ≤ 25n ⇐⇒ 16933 ≤ 25n ⇐⇒ 2.

13. Resolva com detalhes e confira se a complexidade final corresponde à encontrada na análise abaixo. i−1 n 2X n X c X i Cp [Alg1] = c= · 2 = c · 2n − c = O(2n ) i=1 j=1 2 i=1 Os detalhes da resolução do algoritmo abaixo foram suprimidos. X X X X Cp [Alg2] = j2 ≤ j2 1≤i≤n 1≤j≤2i 1≤i≤n 1≤j≤2i j ı́mpar X = O( (2i )3 ) 1≤i≤n X 8n+1 − 8 = O( 8i ) = ≤ 8n+1 = O(8n ) 7 1≤i≤n n X X n n X i Cp [Alg3] = 2 = 2i · (n − i + 1) i=1 j=i i=1 Xn n X n X n X = (n2 − i2i + 2i ) = i n. Pela regra de L’Hospital log m 1 lim = lim =0 m→∞ m m→∞ m Solução do exercı́cio 2.2i + 2i i=1 i=1 i=1 i=1 = n · (2n+1 − 2) − (2 + (n − 1) · 2n+1 ) + (2n+1 − 2) = n2n+1 − 2n − 2 − n2n+1 + 2n+1 + 2n+1 − 2 = 2n+2 − 2n − 4 = O(2n ) 238 .B Soluções dos exercı́cios Solução do exercı́cio 1. n0 a partir de um n ≥ n0 . Temos log n ≤ cn ⇐⇒ log n log n ≤ log c +  log n ⇐⇒ log m ≤ m + c0 com a substituição m = log n e c0 = log c. Nos vamos mostrar que log m ≤ m para qualquer  a partir de m ≥ m0 que é equivalente com limm→∞ log m/m = 0.1.2i − i. Temos que mostrar que log n ≤ cn para constantes c.

Essa prova vira X Tn = n − 1 + 2/n O(i) 0≤i<n X ≤ n − 1 + 2c/n i 0≤i<n = n − 1 + c(n − 1) = cn + (n − 1 − c) 6≤ cn Não funciona para n > c + 1 Solução do exercı́cio 2. Uma solução simples é manter um máximo M e o segundo maior elemento m no mesmo tempo: 1 M := ∞ 2 m := ∞ 239 . O problema é o mesmo da prova do exercı́cio 1.3. Para provar Tn = O(n) temos que provar Tn ≤ cn para c fixo.2.4: Na prova a constante c muda implicitamente. n X X i n X Cp [Alg4] = 2j = (2i+1 − 2) i=1 j=1 i=1 n X n X i =2 2 − 2 = 2 · (2n+1 − 2) − 2n i=1 i=1 = 4 · 2n − 4 − 2n = O(2n )   n X X n n X n X i−1 X Cp [Alg5] = 2j =  2j − 2j  i=1 j=i i=1 j=1 j=1 n X n  X 2n+1 − 2 − (2i−1+1 − 2) = 2 · 2n − 2 − 2i + 2  = i=1 i=1 n X n X =2 2n − 2i = 2 · n2n − (2n+1 − 2) i=1 i=1 = 2 · n2 − 2 · 2 + 2 = O(n2n ) n n Solução do exercı́cio 2.

Portanto. B Soluções dos exercı́cios 3 fo r i = 1. n. Solução do exercı́cio 2. . . . Existem outras soluções que encontram o segundo maior elemento com somente n + log2 n comparações.4. e esse limite ocorre numa sequência crescendo 1. . n do 4 i f ai > M then 5 m := M 6 M := ai 7 e l s e i f ai > m do 8 m := ai 9 end i f 10 end f o r 11 return m O número de comparações é ao máximo dois por iteração. Uma abordagem simples com busca exaustiva é P 1 m := 1≤i≤n ai 2 fo r C ⊆. a complexidade pessimista é 2n = Θ(n). . . . . 2.

n] do . [1.

m0 := .

i∈C ai − i6∈C ai .

.

P P 3 .

Com a distribuição uniforme temos E[Ai ] = 1/6 e pela linearidade   X E[A] = E  Ai  = n/6. 1≤i≤n Com o mesmo argumento a segunda distribuição leva a E[Ai ] = 1/10 é E[A] = n/10 finalmente. Para um dado n temos sempre n − bn/2c atualizações.7. . o número médio de atualizações é e mesma. Solução do exercı́cio 2. k] precisa i comparações e a árvore tem 1≤i≤k 2i−1 = P 240 .6. . respectivamente. A1 . Logo. Seja A. Cada chave em nı́vel i ∈ [1. An as variáveis aleatórias que denotam o número total de atualizações. e o número de atualizações devido a posição i. Solução do exercı́cio 2. . Solução do exercı́cio 2.5. 4 i f m0 < m then 5 m := m0 6 end i f 7 end f o r Ele tem complexidade cp = O(n) + O(2n nc) = O(n2n ). .

2. . . n do 6 i f s0i = sj then 7 i := i + 1 8 i f i > m then 9 return t r u e 10 end i f 11 end i f 12 end f o r 13 return f a l s e e tem complexidade O(n).1. . . 1 ≤ i ≤ n. se S 0 ⊆ S (S 0 é uma subsequência de S) 1 i f m > n then 2 return f a l s e 3 end i f 4 i := 1 5 f o r j := 1.2k − 1 nós e folhas em total. O seguinte algoritmo resolve o problema: Algoritmo B. sn . . podemos sempre escolher gulosamente o primeiro elemento da sequência maior. Solução do exercı́cio 4. 241 . . Portanto. Para o número de comparações C temos X X 2i−1 X E[C] = P [C = i]i = k−1 i = 2−k 2i i = 2(k − 1) + 21−k . A corretude resulta de observação que para cada subsequência possı́vel temos outra subsequência que escolhe o elemento mais esquerda em S. .2 (Bases) Entrada Uma sequência de posições xi de n cidades. . 2 1≤i≤k 1≤i≤k 1≤i≤k Solução do exercı́cio 4.1 (Subsequência) Entrada Sequência S 0 = s01 . Saı́da true. s0m e S = s1 . O seguinte algoritmo resolva o problema: Algoritmo B.

Afirmação: bi ≥ b0i . . a solução gulosa não contém mais bases que alguma outra solução. xi+1 = h + 4 ≥ h0 + 4 ≥ b0i+1 . Logo. Portanto. Prova da afirmação com indução: A base b1 ≥ b01 é correto porque toda solução tem que alimentar a primeira casa e o algoritmo guloso escolhe a última posição possı́vel. e b0i as posições de alguma outra solução. T (n) = 9T (n/3) + n X T (n) = 9i (n/3i ) + Θ(9log3 n ) 0≤i<log3 n X =n 3i + n2 0≤i<log3 n 3log3 n − 1 =n + n2 = Θ(n2 ) 2 242 . (x0 + 4) { aumenta a sequência B } 6 Remove t o d o s o s e l e m e n t o s x ≤ x0 + 8 de S 7 end while O algoritmo tem complexidade O(n) porque o laço tem ao máximo n iterações.1. Passo: Seja bi ≥ b0i e sejam h. Solução do exercı́cio 6. Prova de corretude: Seja bi as posições do algoritmo guloso acima. 1 Sejam S = x01 . O algoritmo guloso escolha h + 4. x0n a s p o s i ç õ e s em ordem c r e s c e n t e 2 B= 3 while S 6  do 4 S e j a S = x0 S 0 5 B := B.B Soluções dos exercı́cios Saı́da Uma sequência mı́nima de posições bi de bases. . h0 as posições da próximas casas sem base. 1. mas como bi ≥ b0i e h ≥ h0 temos b0i+1 ≤ h0 + 4 porque h0 precisa uma base.

2. Produto de dois números binários (exemplo 5. Saı́da O produto r = pq (que tem ≤ 2n bits).3. y2 ) 7 t := (x1 y1 )2n + (x1 y2 + x2 y1 )2n/2 + z 8 u := mult-bin(p1 . T (n) = 2T (n/2) + n log n X T (n) = 2i (n/2i ) log2 n/2i + Θ(2log2 n ) 0≤i<log n X =n log2 n − i + Θ(n) 0≤i<log n n log2 n(log2 n − 1) = n log22 n − + Θ(n) 2 = O(n log22 n) Solução do exercı́cio 6. q2 ) 10 r := u2n + (t − u − v)2n/2 + v 11 return r 12 end i f É importante de observar que x é a soma de dois números com n/2 bits e logo tem no máximo n/2 + 1 bits.8 em (Toscani and Ve- loso. 2005)). 1 i f n = 1 then 2 return pq { multiplica dois b i t s em O(1) } 3 else 4 x := p1 + p2 5 y := q1 + q2 6 z := mult-bin(x2 . Algoritmo B. A divisão de x em x1 e x2 é tal que x1 represente o bit n/2 + 1 e x2 o resto. q com n bits.3 (mult-bin) Entrada Dois números binários p.3. q1 ) 9 v := mult-bin(p2 . 243 . 1.

Se usarmos a hipótese de que T (n) ≤ cnlog2 3 . Complexidade do algoritmo Inicialmente provaremos pelo método da substituição que a recorrência deste algoritmo é O(nlog2 3 ). Caso este fator adicional for menor em ordem que a complexidade que queremos provar. v = p2 q2 (que foram obtidos com duas chamadas recursivas com n/2 bits) temos p1 q2 + p2 q1 = t − u − v pq = u2n + (t − u − v)2n/2 + v substituindo u e v nas equações B.8) A linha 7 do algoritmo calcula t (usando uma chamada recursiva com n/2 bits para obter z = x2 y2 ).7) Usando t = (p1 + p2 )(q1 + q2 ) = p1 q1 + p1 q2 + p2 q1 + p2 q2 obtemos p1 q2 + p2 q1 = t − p1 q1 − p2 q2 .8.B Soluções dos exercı́cios p = | p1 | p2 | | {z } | {z } n/2bits n/2bits x = | p1 | | {z } n/2bits + | p2 | | {z } n/2bits = |x1 | x2 | |{z} | {z } 1bit n/2bits (y tem a mesma subdivisão.) Corretude do algoritmo Temos a representação p = p1 2n/2 + p2 e q = q1 2n/2 + q2 e logo obtemos o produto pq = (p1 2n/2 +p2 )(q1 2n/2 +q2 ) = p1 q1 2n +(p1 q2 +p2 q1 )2n/2 +p2 q2 (B. podemos usar uma hipótese mais forte como apresen- tado abaixo. 244 .7 e B. não conseguiremos finalizar a prova pois permanecerá um fator adicional que não podemos remover da equação. (B. Com os produtos u = p1 q1 .

0001. x = p1 + p2 = 1.0101. porque uma multiplicação com x1 ou y1 precisa tempo constante (de fato é um if).0011. ele pode ser aplicado para números com base arbitrário.1 Com p = (1101. 2.0011.111. 1971) que multiplica em O(n log n log log n).1001 tal que x1 = 1 e x2 = 1001 e y = q1 + q2 = 1011 tal que y1 = 0 e y2 = 1011.58 ) (com 1. t = y2 24 + z = 21. para d ≤ −2b: T (n) ∈ O(nlog2 3 − dn) ∈ O(nlog2 3 ). Ele é conhecido como algo- ritmo de Karatsuba (Karatsuba and Ofman. Um algoritmo mais eficiente é do Schönhage e Strassen (Schönhage and Strassen. Exemplo B. a linha 7 do algoritmo também precisa tempo constante. 245 . Hipótese: T (n) ≤ cnlog2 3 − dn T (n) ≤ 3(c(n/2)log2 3 − d(n/2)) + bn ≤ 3cnlog2 3 /(2log2 3 ) − 3d(n/2) + bn ≤ cnlog2 3 − 3d(n/2) + bn ≤ cnlog2 3 − dn A desigualdade acima é verdadeira para −3d(n/2) + bn ≤ −dn. Algoritmo de Strassen para multiplicação de matrizes. u = p1 q1 = 0111. Fürer (2007) apresenta um algoritmo ∗ que multiplica em n log n 2O(log n) . um pouco acima do limite inferior Ω(n log n).58 ≈ log2 3. ou seja.0010)2 = (146)10 temos n = 8.1000 = 32120. A recorrência correspondente é T (n) = 7T (n/2) + Θ(n2 ). ♦ O algoritmo acima não é limitado para números binários. O algoritmo está descrito na seção 6. Logo z = x2 y2 = 0110. v = p2 q2 = 0001. Com a hipótese que uma multiplicação com 2k precisa tempo constante (shift left).1100)2 = (220)10 e q = (1001. 1962).1010. O custo das adições é O(n) e temos a recorrência ( 1 se n = 1 Tn = 3T (n/2) + cn se n > 1 cuja solução é Θ(n1. aplica o teorema Master).1000 e finalmente r = 1111.3.

vamos estimar o custo da árvore da seguinte forma: (i) Temos que garantir. (ii) Vamos substituir o sub-problema 7n/10 + 6 com a cota superior (7 + )n/10 para um  > 0 pequeno. Na aplicação da árvore de recorrência. que o segundo subproblema sempre é menor: 7n/10+6 < n. Por isso. 3. enfren- tamos dois problemas: (i) Os ramos tem comprimento diferente. Algoritmo de seleção do k-ésimo elemento. Isso é satisfeito para n ≥ 60/. (ii) O tamanho 7n/10 + 6 do segundo subproblema leva a somas difı́ceis. cada um com tamanho n/2i e custo c(n/2i )2 = cn2 /4i e altura h = dlog2 ne (com h + 1 nı́veis) que leva a soma X T (n) ≤ cn2 (7/4)i + 7h+1 0≤i≤h = (4/3)cn2 ((7/4)h+1 − 1) + 7h+1 com 4h+1 ≥ 4n2 ≤ (7c/3 + 1)7h − (4/3)cn2 com 7h ≤ 7 7log2 n ≤ (49c/3 + 1)nlog2 7 = O(nlog2 7 ). podemos estimar T (n) ≤ anc − bn2 com c = log2 7 que resulta em T (n) = 7T (n/2) + dn2 ≤ 7a/2c nc − 7b/4n2 + dn2 = anc − bn2 + (d − 3b/4)n2 que é satisfeito para d − 3/4 ≤ 0 ⇔ b ≥ (4/3)d. porque os subproblemas tem tamanho diferente (portanto o método Master não se aplica nesse caso). (iii) Sejam c1 := 1/5. Então a árvore tem custo ci n no nı́vel i e no ramo mais longo (que corresponde a c2 ) uma altura de h = logc2 20/n . Portanto.B Soluções dos exercı́cios Analisando com a árvore de recorrência. obtemos 7i problemas em cada nı́vel. Para aplicar o método Master. é suficiente de verificar que com Θ(n2 ) = O(nlog2 7 − ) se aplica o caso 1. Esse algoritmo obedece a recorrência T (n) = T (n/5) + T (7n/10 + 6) + O(n) (sem considerar o teto). 246 . c2 := (7 + )/10 e c := c1 + c2 . Para aplicar o método de substituição. Isso é satisfeito para n > 20. e portanto a complexidade é Θ(nlog2 7 ).

94 ) não serve! Como as folhas satisfazem a recorrência ( F (dn/5e) + F (b7n/10 + 6c) se n > 20 F (n) ≤ O(1) se n ≤ 20 F (n) ≤ cn pode ser verificado com substituição (resolvido no livro do Cormen).obtemos uma cota superior para o custo da árvore X T (n) ≤ n ci + F (n) 0≤i≤h X ≤n ci + F (n) porque c < 1 = 10n/(1 − ) + F (n) 0≤i<∞ com o número de folhas F (n). Caso F (n) = O(n) obtemos a estimativa desejada T (n) = O(n). O método Master não se aplica nesta recorrência. Observe que a estimativa F (n) = 2h+1 ≤ 42logc2 20 nlog1/c2 2 = Ω(n1. 247 .

.

On the solution of linear recurrence equa- tions. editor. and Moni Naor. CRC Press. More algorithms for all-pairs shortest paths in weighted graphs. Cambridge University Press. Springer-Verlag. March 2005. Computational Complexity: A Modern Ap- proach.nada. Matrix multiplication via arithmetic progressions. 1992. 2009. The MIT Press. 10:195–210. Computational Optimization and Applications. 1998. P. Complexity zoo. Manindra Agrawal. In FOCS. and M. Protasi. Marchetti-Spaccamela. Oded Margalit. and Nitin Saxena. A.se/~viggo/approxbook. Charles E. 1987. 2001. 2007. and Clifford Stein. Thomas H. 1962. Online. Dynamic programming treatment of the travelling salesman problem. Totally greedy coin sets and greedy obstructions. ACM SIGACT News. Complexity and approximation – Combinatorial Optimiza- tion Problems and their Approximability Properties. URL http://www. Crescenzi. Sanjeev Arora and Boaz Barak. J. 2nd edition. Zvi Galil. PRIMES is in P. Robert Cowen. Ronald L. 9(1):61–63. Kann. V. G. 249 . NP-complete problems and physical reality. and Arthur Steinberg. Chan. Rivest. pages 1–6.Bibliografia Scott Aaronson. Algorithms and theory of computation handbook. The Electronic Journal of Combinatorics. Ausiello. In STOC ’87: Proceedings of the nineteenth annual ACM conference on Theory of computing. Richard Bellman. Timothy M.kth. 1999. Cowen. Mohamad Akra and Louay Bazzi. Noga Alon. Annals of Mathematics. ACM. 2008. 160:781–793. Don Coppersmith and Shmuel Winograd.J. Witnesses for boolean matrix multiplication and for shortest paths. In STOC’07. 1999. Introduction to Algorithms. complexity zoo. 15. Gambosi. Neeraj Kayal. Atallah. Leiserson. 2004. L. Cormen. G. Mikhail J.

volume III.1145/1250790. 595–596. SIAM J. Languages. Faster integer multiplication. 16(3):486–502. 1987. R. Approximating the minimu-degree steiner tree to within one of optimal. A. 2001. Graph theory. Martin Fürer. Knuth. and Charles Rackoff. 1965. 1962. Hirschberg. Springer. ar- Xiv:0708. Multiplication of many-digital numbers by automatic computers. 1985. New York. ISBN 978-1-59593-631-8. 2004. Sorting and searching. Reinhard Diestel. Advances in Algorithms. 1994. 3rd edition. Stearns. The knowledge com- plexity of interactive proof-systems. Donald E. Computer Journal. of the ACM. Springer. 2007. NY. 2007. 1962. A linear space algorithm for computing maximal common subsequences. doi: http://doi. Translation in Soviet Physics-Doklady 7 (1963). Hoare.In Honor of Ronald V. In ACM Symposium on Theory of Computing (STOC). pp. Expected computation time for Hamilto- nian path problem. C.acm. 5:10–15. 2005. and Complexity . Algorithm design. Martin Fürer and Balaji Raghavachari. On the complexity of computing determi- nants. 13:91–130. editors. Journal of Algorithms. Erich Kaltofen and Gilles Villard. Graph isomorphism is PSPACE-complete.org/10. 117: 285–306. Ding-Zhu Du and Ker-I Ko. Addison-Wesley. Addison-Wesley. Kluwer. In STOC ’07: Proceedings of the thirty-ninth annual ACM symposium on Theory of computing. pages 291–304. 2nd edition. pages 57–66. Anatolii Alekseevich Karatsuba and Yu Ofman. Jon Kleinberg and Éva Tardos. Silvio Micali. Nauk SSSR. The art of computer programming. Comm.1250800. Book. 18(6):341–343. Doklady Akad. 1997. 145(2):293– 294. 250 . 1975. Quicksort. 1998. Transactions of the American Mathematical Society. on Computing. ACM. On the computational complexity of algorithms.Bibliografia Matthew Delacorte. Dan S. USA. Juraj Hromkovič. Yuri Gurevich and Saharon Shelah. Algorithmics for hard problems. Juris Hartmanis and Richard E. Shafi Goldwasser. 2005. Computational complexity.4075.

Physical Review Letters. J. Mohit Singh and Lap Chi Lau. Magazine.org/story/v9/st27. 2002.J. When the greedy solution solves a class of knapsack problems. 2005. Department of Computer Science. Pearson. G. 1969. Tom Leighton.Nemhauser. R. MIT.html. Jour- nal of the ACM. Approximating minimum bounded degree spanning trees to within one of the optimal. PhD thesis. 13:354– 356. The equivalence problem for regular expression with squaring requires exponential time. Journal of the ACM. 23(2):207–217. 33(3):231–234. Seth Lloyd. M. 2007. URL http://weblog. Numer. and L. Introduction to the theory of computation. pages 707–710. Schnelle multiplikation grosser zahlen. Computational capacity of the universe. Bibliografia Mark William Krentel. Salvador Roura. In STOC ’07: Proceedings of the thirty-ninth annual ACM symposium on Theory of computing. A. 12th IEEE Symposium on Switching and Automata Theory. 251 . Michael Sipser. 1992. pages 603–619. Binary codes capable of correcting deletions. 1996. Volker Strassen. pages 125–129. 1966. Math. Operations research. 1971.E.L. Richard Ladner. 88(23). Vladimir Iosifovich Levenshtein. Cornell University. 48(2):170–205.fortnow. 1975. Soviet Physics Doklady. Schönhage and V. The complexity of optimization problems. Michael Sipser. http://focus. 7:281–292. A polynomial time algorithm for the change-making problem. Guassian elimination is not optimal. 1972. insertions. Stockmeyer. A.Trotter. 2006.com/2005/09/ favorite-theorems-np-incomplete-sets. Com- puting. 1975. The history and status of the P versus NP question. Operations Research Letters. In Pro- ceedings of the 24th Annual ACM Symposium on the Theory of Computing. In Proc. Strassen. 2001. Improved master theorems for divide-and-conquer recurren- ces. and reversals.aps. Manuscript. Thomson. On the structure of polynomial time reducibility. 1987. Meyer and L. D.

Handbook of theoretical computer science. URL http: //www. Springer. Approximation algorithms. Proc. 2010. Vitányi and Lambert Meertens. Vijay V. 1997.com/2010/04/ 24/cs254-lecture-2-p-and-np. Big omega versus the wild func- tions.Bibliografia Laira Vieira Toscani and Paula A. 2010. V. Volume A: Algorithms and complexity of . Luca Trevisan. chapter Average-Case Intractable NP Problems. On computable numbers with an application to the Entscheidungsproblem.nasa. 1985. Handbook of theoretical computer science. S. Vazirani. Paul M. B. MIT Press. Jan van Leeuwen. Vassilevska Williams and Ryan Williams. http://map. 2a edition. 1990.wordpress. Book. Jie Wang.. 16(4). volume A: Algorithms and complexity. 1936. chapter Average-case analysis of algorithms and data structures. London MathṠoc. 2(42):230–265. and Complexity . Online.gov. Advances in Algorithms. URL http://www. J. Veloso. 1990.com/Handbook-Theoretical-Computer-Science-Vol/ dp/0262720140. Wilkinson microwave anisotropy probe. 2001. URL http://www. http://lucatrevisan. 2005. P and NP.ufrgs. Complexidade de Algoritmos. Editora Sagra Luzzatto. 252 . Triangle detection versus matrix multiplication: a study of truly subcubic reducibility.S. gsfc.amazon. Vitter and Philipe Flajolet. com/Handbook-Theoretical-Computer-Science-Vol/dp/0262720140. Kluwer. van Leeuwen (1990). editor. Languages.amazon.In Honor of Ronald V.inf. br/~laira/. Alan Mathison Turing. Wilkinson. SIGACT News.

22 all pairs shortest paths. 225 Busca seqüencial (algoritmo). 163  (relação de crescimento). 163  (relação de crescimento). 219 PrefixTree. 249 PSPACE. 202 randomizado. 162  (relação de crescimento). 82 DTIME. 195. 202 algoritmo de Hirschberg. 237 árvore binário. 185 NSPACE. 46. 202 alfabeto. 179 Σn . 79 Bayes. 38. 99 APX. 48 PO. 204 busca linear. 117 aval (função de complexidade). 26 absoluta. 22 de Karatsuba. 225 FP. 161 Busca em Largura (algoritmo). 143 espalhada mı́nima. 26 relativa. 202 algoritmo de Shor. 195 guloso. 55 NPO. 84 ≺ (relação de crescimento). 34 de busca. 163 Θ (Notação). 26 aresta. 157 Ω (Notação). 22 algoritmo r-aproximativo. 104 PF. 237 árvore atribuição. 83 NP. 194 AEM-Prim (algoritmo). 75 Πn . 163 Bubblesort (algoritmo). 225 ω (Notação). 26 algoritmo de Grover. 194. 117 backtracking. 82. 194 AEM-Kruskal (algoritmo). 92 P. 49 BHALT.Índice DSPACE. 121 53 absorção (de uma função). 92 bottom-up. 26 Busca1 (algoritmo). 41 binária. 219 algoritmo -aproximativo. 194. 53 adjacência de vértices. ABB-ÓTIMA (algoritmo). 36. 161 Busca binária (algoritmo). 195 de aproximação. 26 aproximação  (relação de crescimento). 237 código 253 . 195 algoritmo NTIME. 43.

38 grafo. 49. 34 conjuntiva. 84 elementar. 237 condicional. 90 Floyd-Warshall (algoritmo). Philippe. 211 não-direcionado. 91 Eliminação de Gauss (algoritmo). 236 divisão e conquista. 38. Lev. Sir William Rowan. 18 fatoração. 104 desemp (função de desempenho). 35. 237 fórmula de Stirling. 237 espaço-construtı́vel. 88 máximo (problema). 18. 42 função objetivo. 236 entre um nó e todos outros. 161 composicionalidade. 34 certificado. 229 euleriano. 161 disjuntiva. 114 complexidade função média. 18 CopiaMTI (algoritmo). 87 254 . 232 perfeito. 150 85 conexo. algoritmo de. 236 entre todas pares. 87 direcionado. Charles Anthony Richard. 94 distribuição. 87 de intervalo. Robert W. 150 conjunto compatı́vel de intervalos. 34 pessimista. Stephen Arthur. 34 otimista. 150 corte. 42 k-partido. 34 Hoare. bipartido. 18 caminho mais curto evento. 157 Floyd. Edsger. 18 fatorial. Dijkstra. 123 independent set.Índice livre de prefixos. 38. 35 de desempenho (desemp). 219 Hirschberg. 20 Counting-Sort (algoritmo). 99 11 caixeiro viajante. 225 hamiltoniano. 47 Hamilton. 51 Euler. 236 caminho. 238 Cook. 84 exec (função de execução). 38. 194 Caminho Hamiltoniano. cache. 18 custo (função de custos). 79 conjunto independente. 229 classe de complexidade. 116 espaço amostral. 37 de custos (custo). 85 58 distância de Levenshtein. 34 hierarquia polinomial. 52 cobertura por vértices. 58. 34 componente de execução (exec). 39 função de otimização. 80 Grover. 202 ciclo. 50 de complexidade (aval). 114 coloração mı́nima. 105 Huffman (algoritmo). 194 Flajolet. 225 cota assintótica superior. Leonhard.

81 Mergesort. 58 máquina de Turing. 185 não-determinı́stica. 230 indefinida. 187 determinı́stica. 189 palavra. de construção. 229 Bubblesort. 57 número de clique. 126 de intervalos. 19 o. 41 números harmônicos. informação 249 quantidade de. Robert C. 236 recorrência. Joseph Bernard. 56 número cromático. 150 iteração número Fibonacci. 57 sos. 38. 133 Partition (algoritmo). 211 O (notação). 51 método particionamento da substituição. Θ. 203 112 de avaliação. 125 probablidade condicional. 33 Quicksort. 22 Karatsuba. 92 memoização. 99 Prim. 54 máquina de RAM. 58 maximum independent set (problema). 237 mochila máxima.. Índice indução natural. 22 linguagem. 50. 161 50 de decisão. 47 por inserção direta (algoritmo). 234 multiplicação de números (algoritmo). 125. Vladimir Iosifovich. 203 255 . 44. 17. 139 difı́cil. 150 tabela de. 22 249 ω. Anatolii Alekseevitch. 109 problema Multiplicação de matrizes. 161 algoritmo de Coppersmith-Winograd. 109 PrefixTree (algoritmo). 97 definida. PD-matrizes. 17 probabilidade. 38. 45. 237 o (Notação). 81 O. 41 notação assintótica Ω. 19 linearidade do valor esperado. 105 Levin. 93 inversão. 161 algoritmo de Strassen. 189 Parada não-determinı́stico em k pas- Máximo (algoritmo). 131 de um vetor. 185 ordenação logaritmo. 58 mestre. 50. 88–90 de árvore de recursão. 125. 43 Loteria Esportiva (algoritmo). 22 Levensthein. completo. 134 maximum Knapsack. 125. 110 87 potenciação. Leonid. 22 Kruskal.

225 single-source shortest paths. 157 . 93 teorema de Savitch. 198 seqüência. 54 Strassen. 101 tabela de inversões. 97. 38. 77 subgrafo. Claude. 194 teorema de Bayes. 237 quantidade de informação. 26 Vitter. 85 Shannon. 76 relação Turing. 84 somatório. 26 vertex cover. 26 notação de. 232 Savitch. 25 valor esperado.. 237 série aritmética. 60 tese de Cobham-Edmonds. 56 simplificar. 238 subseqüência. 34 programação dinâmica. 99 recorrência transposição. 198 Quicksort (algoritmo). Peter. 101 subseqüência comum mais longa. 203 troca mı́nima (algoritmo). 237 relação de crescimento. 52 retrocedimento. Alan Mathison. 58. 39 seqüenciamento de intervalos (algoritmo). 114 série geométrica. Jeffrey Scott. 231 straight insertion sort (algoritmo). 26 Vinogradov. 86 de intervalos (problema). 237 ≺. 125 traveling salesman. 26 variável aleatória. 232 Warshall.. Walter J. I. Volker. 139 subestrutura ótima. 26 . 57 256 . 44. 93 Shor. 202 vértice. 26 . 8 top-down. 186 polinomialmente limitada. Stephen.Índice problema de otimização. 238 induzido. 116 redução. 143 vizinhança. 161 tam (tamanho de entradas). 161. 100 tempo-construtı́vel. M. 237 .