Projeto e Aálise de Algoritmos Cristiao Damiai Vascocellos cristiao.vascocellos@udesc.br Agradeço ao Prof. Diego Buchiger por ajudar a aprimorar esse material. diego.buchiger@outlook.com
Bibliografia Algoritmos. Thomas H. Corme, Charles E. Leiserso, Roald L. Rivest, Cliford Stei. Campus. Algorithms. Sajo Dasgupta, Christos Papadimitriou, Umesh Vazirai. McGraw Hill.
Aálise de Algoritmos Aalisar um algoritmo sigifica prever os recursos que algoritmo ecessita. Por exemplo, memória, largura de bada e mais frequetemete o tempo de computação. Para aalisar um algoritmo é ecessário defiir um modelo de computação. O modelo de computação do computador tradicioal é o RAM (Radom Access Machie). Ode as istruções são executadas em sequêcia, sem cocorrêcia, e os dados são armazeados em células de memória com acesso aleatório.
Aálise de Algoritmos Cotar o úmero de istruções que são executadas pelo algoritmo. Por exemplo: load, store, add, sub, div, mul, call, ret, cmp, jump, etc.
Qual o tempo de execução? it pesquisa(estrutura *v, it, it chave) { it i; } for (i = 0; i < ; i++) if (v[i].chave == chave) retur i; retur -; O úmero de istruções e o tempo de execução depede do processador, compilador, etc.
Programa Notação Assitótica. Complexidade de tempo e espaço. Relações de Recorrêcia. Somatórios. Divisão e Coquista. Algoritmos Gulosos. Programação Diâmica. Tratabilidade (classes P, NP e NP-Completo).
Crescimeto de Fuções Para simplificar o processo usamos uma abstração que igora o custo de cada istrução, que é costate. Cocetrado a aálise o crescimeto do tempo de execução (ou de outro recurso) em relação ao crescimeto da etrada.
Notação Assitótica (Notação O grade Limite Superior) Uma fução f() domia assitoticamete outra fução g() se existem duas costates positivas c e 0 tais que, para > 0, temos g() c. f(). g() = O(f()) 600 500 400 2 2 300 200 00 0 2 + 4-4 2 3 4 5 6 7 8 9 0 2 3 4 5 6 2 + 4-4 = O( 2 )
Algumas Operações com Notação O c.o(f()) = O(f()), ode c é uma costate. O(f()) + O(g()) = O(MAX(f(), g()).o(f()) = O(.f()) O(f()).O(g()) = O(f().g())
Complexidade de Tempo it pesquisa(estrutura *v, it, it chave) { it i; // O() } for (i = 0; i < ; i++) // O() if (v[i].chave == chave) // O() retur i; // O() retur -; // O() Em que situações ocorrem o melhor caso, pior caso e o caso médio?
Complexidade de Tempo Caso médio: Caso o i-ésimo registro seja o registro procurado são ecessárias i comparações. Sedo p i a probabilidade de procurarmos o i-ésimo registro temos: f() =.p + 2.p 2 +... +.p. Cosiderado que a probabilidade de procurar qualquer registro é a mesma probabilidade, temos p i = /, para todo i. f ( ) ( 2... ) ( ) 2 ( ) 2
Crescimeto de Fuções! 2 2.log() log()
Crescimeto de Fuções 0 000000 2000000 3000000 4000000 5000000 6000000 7000000 8000000 9000000 0000000 000000 2000000 3000000 4000000 5000000 6000000 7000000 8000000 9000000 20000000 4 7 0 3 6 9 22 25 28 3 34 37 40 43 46 49 52 55 58 6 64 0 000000 2000000 3000000 4000000 5000000 6000000 7000000 8000000 9000000 0000000 000000 2000000 3000000 4000000 5000000 6000000 7000000 8000000 9000000 20000000 4 7 0 3 6 9 22 25 28 3 34 37 40 43 46 49 52 55 58 6 64 2 4 3
Hierarquia de fuções Hierarquia de fuções do poto de vista assitótico: c c c c log log log log ode e c são costates arbitrárias tais que 0 < < < c.
void isercao(it *v, it ) { it i, j, x; for (i = ; i < ; i++) { x = v[i]; j = i - ; while (j >= 0 && v[j] > x) { v[j+] = v[j]; j--; } v[j+] = x; } } Exemplo (Ordeação por Iserção)
void bubble(it *v, it ) { it i, j, aux; for (i = - ; i > 0; i--) { for (j = 0; j < i; j++) { if (v[j] > v[j+]) { aux = v[j]; v[j] = v[j+]; v[j+] = aux; } Exemplo (Bubble Sort) } } }
it pesqbi(it *v, it p, it r, it e) { it q; if (r<p) retur -; q = (p + r)/2; if (e == v[q]) retur q; if (e < v[q]) retur pesqbi(v, p, q-, e); retur pesqbi(v, q+, r, e); } Exemplo (Pesquisa Biária)
it pesqbi(it *v, it p, it r, it e) { it q; if (r<p) retur -; q = (p + r)/2; if (e == v[q]) retur q; if (e < v[q]) retur pesqbi(v, p, q-, e); retur pesqbi(v, q+, r, e); } Exemplo (Pesquisa Biária) Relação de Recorrêcia: T() = T(/2) + O() T() = O() A relação abaixo descreve de forma mais precisa a execução, mas a simplificação acima ão altera a complexidade: T() = T(/2 - ) + O() T() = O()
Relação de Recorrêcia T() = T(/2) + T(/2) = T(/2 2 ) + T(/2 2 ) = T(/2 3 ) +... T(/ l- ) = T(/2 l ) + 2 l = 2 l l = log 2 O(log ) Mudaça de base: T() = + +... + + T() log 2 vezes log b log log a a b
Exemplo (Pesquisa Biária) it pesqbi2 (it *v, it, it e) { it p, q, r; } p = 0; r = -; do { q = (p + r) / 2; if (e == v[q]) retur q; if (e < v[q]) r = q -; else p = q + ; } while (p<= r); retur -;
Recursividade de cauda Uma fução apreseta recursividade de cauda se ehuma operação é executada após o retoro da chamada recursiva, exceto retorar seu valor. Em geral, compiladores, que executam otimizações de código, substituem as fuções que apresetam recursividade de cauda por uma versão ão recursiva dessa fução.
Exemplo (Merge Sort) it mergesort(it *v, it p, it r) { it q; if (p<r) { q = (p+r)/2; mergesort(v, p, q); mergesort(v, q+, r); merge(v, p, q, r); } } void msort(it *v, it ) { mergesort(v, 0, -); }
Exemplo (Merge Sort) it mergesort(it *v, it p, it r) { it q; if (p<r) { q = (p+r)/2; mergesort(v, p, q); mergesort(v, q+, r); merge(v, p, q, r); } } void msort(it *v, it ) { mergesort(v, 0, -); } Relação de Recorrêcia: T() = 2T(/2) + O() T() = O()
Dividir e Coquistar Desmembrar o problema origial em vários subproblemas semelhates, resolver os subproblemas (executado o mesmo processo recursivamete) e combiar as soluções.
Quick Sort void quicksort(it *a, it p, it r) { } it q; if (p < r) { } q = particao(a, p, r); quicksort(a, p, q); quicksort(a, q +, r);
Quick Sort it particao(it *v, it e, it d) { it pivo, j, aux; pivo = e; // Geralmete essa ão é a melhor escolha para o pivô. for (j = e + ; j <= d; ++j) { if (v[j] < v[e]) { ++pivo; swap(&v[pivo], &v[j]); } } swap(&v[e], &v[pivo]); retur pivo; }
Propriedades dos Somatórios i i i i i i i i i i i i i i i a a b a b a a c ca 0 0 0 0 0 0 0 ) ( (Distributiva) (Associativa) (Comutativa)
Propriedades das Potêcias m m m m m m a a b b a b a b a ab a a a a a a a ) ( 0, ) ( 0,
Propriedades dos Logaritmos a c c c b b c b c c c c c c b a b b b a c a b a a a c a b a b a b a ab b a b c c a log log log log log log log log log log ) / ( log log log ) ( log log
Notação Assitótica Limite Iferior (Notação ) Uma fução f() é o limite iferior de outra fução g() se existem duas costates positivas c e 0 tais que, para > 0, temos g() c. f(), g() = (f()). 350 300 2 + 4-4 250 200 50 2 00 50 2 + 4-4 = ( 2 ) 0 2 3 4 5 6 7 8 9 0 2 3 4 5 6
Notação Assitótica Limite Firme (Notação ) Uma fução f() é o limite restrito de outra fução g() se existem três costates positivas c, c 2, e 0 tais que, para > 0, temos c. f() g() c 2. f(), g() = (f()) 600 500 400 300 2 2 2 + 4-4 200 00 2 2 + 4-4 = ( 2 ) 0 2 3 4 5 6 7 8 9 0 2 3 4 5 6
Ordeação por Iserção 40 Pior caso Caso médio Pior Caso: ( 2 -)/2 O( 2 ), ( 2 ), ( 2 ). 35 30 25 Caso Médio: 2 /4 20 Melhor caso O( 2 ), ( 2 ), ( 2 ). 5 0 Melhor Caso: - 5 0 2 3 4 5 6 7 8 9 0 2 3 4 5 6 O(), (), ().
Heap Biário É um arrajo, ode os dados estão orgaizados de forma que podem ser acessados como se estivessem armazeados em uma árvore biária. No caso de um heap máximo, os elemetos armazeado em uma subárvore serão sempre meores que o elemeto armazeado a raiz. Essa árvore é completa todos seus íveis, com a possível exceção do ível mais baixo. 0 2 3 4 5 6 7 8 9 2 0 8 9 4 5 7 2 2 it esquerda (it i) {retur (2 * i + );} 0 8 9 4 it direita(it i) {retur (2 * i + 2);} 5 7 2
Heap Biário void heapif (it *a, it, it i) { it e, d, maior; e = esquerda(i); d = direita(i); if (e < && a[e] > a[i]) maior = e; else maior = i; if (d < && a[d] > a[maior]) maior = d; if (maior!= i) { swap (&a[i], &a[maior]); heapif(a,, maior); } } T() 3 T( ) T(2 O() 3 3) O() 3
Heap Biário it heapextract(it *a, it ) { it maior; } maior = a[0]; a[0] = a[ - ]; heapif(a, -, 0); retur maior; void buildheap(it *a, it ) { it i; } for (i = (-)/2; i >= 0; i--) heapif(a,, i);
Heap Biário void buildheap(it *a, it ) { it i; } for (i = (-)/2; i >= 0; i--) heapif(a,, i); O( ) log 2 T ( ) ( h i)2 i0 i h
Heap Sort void heapsort(it *a, it ) { it i; } buildheap(a, ); for (i = - ; i > 0; i--) { swap(&a[0], &a[i]); heapif(a, i, 0); }
Algoritmos com Iteiros Até esse mometo temos cosiderado costate a complexidade de operações como: adição, subtração, multiplicação, divisão, módulo e comparação. Mas quado essas operações evolvem úmeros cujo o tamaho, em úmero de bits, é muito maior que a palavra do processador (atualmete 32 ou 64 bits)?
Algoritmos com Iteiros A adição e multiplicação de grades úmeros em computadores é bastate similar a operações com bits. Carr: + 00 (22) 000 (99) 00 (22) Adição de 2 bits, ode é o tamaho da palavra do processador: b 2 b 2-... b +2 b + Carr b b -... b 2 b Podemos cosiderar que a adição de grades úmeros tem complexidade O(), ode é o úmero de bits.
Algoritmos com Iteiros (Multiplicação) bigit mul (bigit x, bigit ) { bigit r = 0; while ( > 0) // Comparação etre iteiros grades { r = r + x; // Adição etre iteiros grades O(). --; } retur r; } O() + O() +... + O() vezes Sedo o úmero de bits, qual o valor de o pior caso?
Algoritmos com Iteiros (Multiplicação) X 2 25 60 (multiplica por 5, desloca 0) 2 (multiplica por, desloca ) 24 (multiplica por 2, desloca 2) 2580 X 00 (0) 0 (3) 00 (multiplica por, desloca 0) 0000 (multiplica por 0, desloca ) 00 (multiplica por, desloca 2) 00 (multiplica por, desloca 3) 000000 (30)
bigit mul(bigit x, bigit ) { bigit r; if ( == 0) retur 0; r = mul(x, >> ) // r = x * (/2) if (par()) retur r << ; // retur 2*r else retur x + r << ; // retur x+2*r } Algoritmos com Iteiros (Multiplicação)
Algoritmos com Iteiros (Multiplicação) ) ( ) ( 2 2 ) )(2 (2 2 2 2 / 2 / 2 / 2 / 2 / R R L R R L L L R L R L R L R L R L R L x x x x x x x x x x x x x
Algoritmos com Iteiros (Multiplicação) x 2 x L L 2 / 2 ( x L R x R L ) ( x R R ) bigit mul(bigit x, bigit ) // ode é o úmero de bits dos iteiros x e. { bigit xl, xr, l, r, p, p2, p3, p4; if ( == ) retur x; // se uméro de bits for (retora se x = ou =). xl = leftmost(x, /2); xr= rightmost(x, /2); // bits mais à esquerda e mais à direita. l = leftmost(, /2); r= rightmost(, /2); p = mul (xl, l); p2 = mul (xl, r); p3 = mul (xr, l); p4 = mul (xr, r); retur p << + (p2 + p3) << (/2) + p4; }
Números Primos Uma úmero atural é primo se possui exatamete dois divisores: o úmero e ele mesmo. Todo úmero composto pode represetado pela multiplicação de seus fatores primos. Primos relativos: Dois iteiros são chamados de primos relativos se o úico iteiro positivo que divide os dois é. Por exemplo, 49 e 5 são primos relativos.
Números Primos Teste de primalidade: Dado um úmero, determiar se é primo (fácil). Fatoração de iteiros: Dado um úmero, represetar através de seus fatores primos (difícil).
Aritmética Modular É um sistema para maipular faixas restritas de úmeros iteiros. Relação de cogruêcia: a b (mod m) m divide (a b). a b (mod m) se e somete se a mod m = b mod m. Exemplos: 38 4 (mod 2), 38 mod 2 = 4 mod 2-0 38 (mod 2), -0 mod 2 = 38 mod 2
Aritmética Modular O iverso multiplicativo modular de um iteiro a o módulo m é um iteiro x tal que: ax (mod m). O iverso multiplicativo de a o módulo m existe se e somete se a e m são primos relativos. O iverso multiplicativo de a o módulo m é um iteiro x que satisfaz a equação: ax = + m. Exemplo: Qualquer úmero cogruete à 5 (o módulo 2) é o iverso multiplicativo de 5 o módulo 2: {, -7, 5, 7, 29, }.
Criptográfia RSA Trasforma um iteiro M (que represeta um bloco de dados da mesagem) em um iteiro C (que represeta um bloco da mesagem criptografada), usado a seguite fução: C M e mod Sedo = pq, ode p e q são úmeros primos, e e um primo relativo de (p - )(q - ): Chave pública = (e, ). mdc (e, (p - )(q - )) =
Criptográfia RSA A trasformação da mesagem criptografada C a mesagem origial é executada através da formula: M C d mod Ode d é o iverso modular de e: ed mod(( p )( q )) Chave privada = (d, ).
Criptográfia RSA (Exemplo) Para M = 92, p = e q = 3 o valor de = 43. Escolher arbitráriamete um valor para e = 7, ote que: mdc (7, 20) =. Chave pública = (7, 43). Como 7d (mod 20), podemos dizer que 7d = + 20a, uma possível solução é a = - e d = -7 (ver algoritmo de Euclides Estedido), outras soluções são a = 6 e d = 3, a = 33 e d = 233, Se -7 é o iverso modular de 7 mod 20 etão todo iteiro cogruete a -7 mod 20 é também o iverso modular de 7 mod 20: (, -7, 3, 233, 353, ). Chave privada = (3, 43). C = 92 7 mod 43, C = 27. M = 27 3 mod 43, M = 92.
Algoritmos Gulosos (Greed Algorithms) Uma técica para resolver problemas de otimização, um algoritmo guloso sempre faz a escolha que parece ser a melhor em um determiado mometo, esperado que essa melhor escolha local leve ao melhor resultado do problema como um todo. Uma técica simples, mas que a maioria das vezes ão leva ao resultado ótimo.
Codificação de Huffma É um método de compressão de dados. Esse método usa a frequêcia com que cada símbolo ocorre, em uma coleção de dados, para determiar um código de tamaho variável para o símbolo. Caractere Frequêcia Código Código (fixo) (variável) a 45 000 0 b 3 00 0 c 2 00 00 Exemplo:... faca...... 000000000...... 000000... d 6 0 e 9 00 0 f 5 0 00
Codificação de Huffma (Exemplo) 0 00 Exemplo: a:45 0 55 0 25 30 0... faca...... 000000000...... 000000... c:2 b:3 4 d:6 0 f:5 e:9
Codificação de Huffma Huffma(C) C Q C para i até - z AlocaNo() x z.esq Extrair-Miimo(Q) z.dir Extrair-Miimo(Q) z.valor = x.valor +.valor Iserir(Q, z) retore Q
Árvore Geradora Míima (Miimum Spaig Tree) Uma árvore geradora para um grafo coexo é uma árvore que coecta todos os vértices do grafo e que o cojuto de arestas é um subcojuto das arestas desse grafo. A árvore geradora é míima se o somatório dos custos associados cada arestas for o meor possível. b 8 7 c 4 2 d 9 a 8 7 h i 6 g 4 2 f 4 0 e
Árvore Geradora Míima (Miimum Spaig Tree) MST-PRIM(G,w, r) // G grafo, w custos, r vértice iicial para cada u G.V b 8 7 c u.ke = 4 2 u.π = ull a i 4 r.ke = 0 7 6 8 Q = G.V Equato Q Ø // Executa V vezes u = Extrai-Miimo(Q) // O(log V ) heap biário para cada v G.Adj[u] // Executa A vezes se v Q e w(u, v) < v.ke v. π = u v.ke = w(u, v) // propriedade de heap O(log V ) Árvore geradora míima = {(v, v.π) v V - {r}} h g 2 d f 4 9 0 e
Problemas tratáveis e itratáveis Problemas tratáveis: resolvidos por algoritmos que executam em tempo poliomial. Problemas itratáveis: ão se cohece algoritmos que os resolvam em tempo poliomial.
Problemas de Decisão. Problemas de Otimização: Cada solução possível tem um valor associado e desejamos ecotrar a solução com melhor valor. Problemas de Decisão: Problemas que tem resposta sim ou ão.
Problema do Caixeiro Viajate Um vededor deseja visitar cidades e retorar a cidade de origem. Dado um grafo ão orietado completo com vértices, ode existe um custo c(i, j) (associado a cada aresta) para viajar da cidade i a cidade j. Qual o trajeto com custo míimo? E 9 0 7 A 2 5 4 6 C D 3 4 B
Problema do Caixeiro Viajate Existe um camiho com custo meor que k?
Algoritmos Não Determiistas Capaz de escolher uma etre várias alterativas possíveis a cada passo. A alterativa escolhida será sempre a alterativa que leva a coclusão esperada, caso essa alterativa exista. it pesquisa(estrutura *v, it, it chave) { it i; it pesquisa(estrutura *v, it, it chave) { it i; } for (i = 0; i < ; i++) if (v[i].chave == chave) retur i; retur -; } i = escolhend(0, - ); if (v[i].chave == chave) retur i; retur -;
Classes de Problemas P e NP Classe de Problemas P: Problemas que podem ser resolvido (por algoritmos determiistas) em tempo poliomial. Classe de Problemas NP: Problemas que podem ser resolvidos por algoritmos ão determiistas em tempo poliomial. Ou problemas que a solução pode ser verificada em tempo poliomial. Possível relação etre as classes: NP P
Redução de Problemas Problema A Algoritmo de Redução Solução para o Problema A Problema B Algoritmo que Resolve B Sim Não
Ciclo Hamiltoiao Um Ciclo Hamiltoiao em um grafo ão orietado é um camiho que passa por cada vértice do grafo exatamete uma vez. Problema do Ciclo Hamiltoiao: Um grafo G possui um ciclo Hamiltoiao? A B C D E
Redução do Problema do Ciclo Hamiltoiao ao Problema do Caixeiro Viajate G (G, 0) A B A 0 B D C E p Redução em tempo poliomial 0 D 0 C 0 E 0 0 para cada vértice i para cada vértice j se (i, j) H etão c(i, j) 0 seão c(i, j)
(SAT) Satisfazibilidade de Fórmulas Booleaas O problema da Satisfazibilidade de fórmulas booleaas cosiste em determiar se existe uma atribuição de valores booleaos, para as varáveis que ocorrem a fórmula, de tal forma que o resultado seja verdadeiro. Exemplo: x ( x2 x ) ( x2 x3 ) ( x x2 3) x
NP-Completo Teorema de Cook: SAT está em P se e somete se P = NP. Um problema X é NP-Completo se:. X NP 2. X p X para todo X NP. Possível relação etre as classes: NP NP-Completo P
Forma Normal Cojutiva Um literal é uma variável proposicioal ou sua egação. Uma formula booleaa está a Forma Normal Cojutiva (CNF) se é expressa por um grupo cláusulas AND, cada uma das quais formada por OR etre literais. Uma fórmula booleaa esta a k-cnf se cada cláusula possui exatamete k literais: ( x x2 x3) ( x x2 x3 ) ( x x2 x3 )
3-CNF-SAT Verificar se uma fórmula booleaa a 3-CNF é satisfazível. 3-CNF-SAT é NP-Completo: 3-CNF-SAT NP. SAT p 3-CNF-SAT.
SAT p 3-CNF-SAT Dada uma fórmula booleaa: x x ) ( x2 x 2 3. Costruir uma árvore que represete à fórmula. 2. Itroduzir uma variável i para a raiz e a saída de cada o itero. x x2
SAT p 3-CNF-SAT ( ( x 2)) ( 2 3) ( 3 ( x 2)) x x 2 3 x x2 3. Reescrevemos a fórmula origial como cojuções etre a variável raiz cláusulas que descrevem as operações de cada ó. Itroduz variável e cláusula para cada operador.
SAT p 3-CNF-SAT ( ( x 2)) ( 2 3) ( 3 ( x 2)) x Para cada i costruir uma tabela tabela verdade, usado as etradas que toram i verdade, costruir uma forma ormal disjutiva para cada. i
SAT p 3-CNF-SAT ( ( x 2)) ( 2 3) ( 3 ( x 2)) x x 2 2 ( x 2) V V V V V V F F V F V F V F F F F V V F F V F V F F V V F F F V ( 2 ( ( ( x x x x 2 2 ) Cada cláusula de itroduz o máximo 8 cláusulas em, pois cada cláusula de possui o máximo 3 variáveis. ) 2 ) 2 )
SAT p 3-CNF-SAT ) ( ) ( ) ( ) ( 2 2 2 2 2 x x x x ) ( ) ( ) ( ) ( 2 2 2 2 2 x x x x Coverter a fórmula para a CNF usado as leis de De Morga:
SAT p 3-CNF-SAT O último passo faz com que cada cláusula teha exatamete 3 literais, para isso usamos duas ovas variáveis p e q. Para cada cláusula C i em :. Se C i tem 3 literais, simplesmete iclua C i. 2. Se C i tem 2 literais, C i ( l l2), iclua: ( l l2 p) ( l l2 p 3. Se C i tem literal, l, iclua: ( l p q) ( l p q) ( l p q) ( l Itroduz o máximo 4 cláusulas por cláusula em. ) p q )
SAT p 3-CNF-SAT )) ( ( ) ( )) ( ( 2 3 3 2 2 x x x ) ( ) ( ) ( ) ( q p q p q p q p )) ( ( ) ( )) ( ( 2 3 3 2 2 x x x ) ( ) ( ) ( ) ( ) ( ) ( ) ( ) ( 2 2 2 2 x x x x q p q p q p q p
CLIQUE Um Clique em um grafo ão direcioado G = (V, A) é um subcojuto de vértices V V, ode cada vértice está coectado por uma aresta. Ou seja um subgrafo completo. Versão de otimização: Ecotrar o maior Clique possível. Versão de decisão: Existe um Clique de tamaho k? b c a f d e
CLIQUE Clique NP b c a f d e Dado um grafo G = (V, A), a solução (certificado) V e k Verificar de V k Para cada u V Para cada v V Se u v etão verificar se (u, v) A
3-CNF-SAT p CLIQUE ϕ = (x ~x 2 ~x 3 ) (~x x 2 x 3 ) (x x 2 x 3 ) ~x x2 x3 x x ~x 2 x 2 ~x 3 x 3 Existe um clique de tamaho k? Sedo k o úmero de cláusulas.
3-CNF-SAT p CLIQUE Dada uma istacia ϕ do problema 3-CNF-SAT, cada cláusula de ϕ gera 3 vértices, sedo que cada vértice correspode a um literal da cláusula. É adicioada uma aresta para cada par de vértices u e v duas codições a seguir forem satisfeitas: Se u e v ão foram gerados a partir da mesma cláusula; se as Se u e v ão foram gerados a partir de um literal que correspode a uma variável e sua egação. Por exemplo, um vértice correspodete a variável x ão pode ser coectado a um vértice correspodete a egação de x.
Cobertura de Vértices (VERTEX-COVER) Uma Cobertura de Vértices de um grafo ão orietado G = (V, A) é um subcojuto V V tal que se (u, v) A, etão u V ou v V. b c a f d e
Cobertura de Vértices (VERTEX-COVER) Versão de otimização: Ecotrar meor Cobertura de Vértices. Versão de decisão: Existe uma cobertura de tamaho k? b c a f d e
Cobertura de Vértices NP. Cobertura de Vértices (VERTEX-COVER) b c a f d e Dado um grafo G =(V, A) e a solução (certificado) V Verificar de V k Para cada (u, v) A Verificar se u V ou v V
CLIQUE p VERTEX-COVER b c b c a f a f d e d e CLIQUE Etrada (G, k), ode G = (V, A) VERTEX-COVER Etrada (, V - k) G
SUBSET-SUM Dado um cojuto fiito de de iteiros positivos S e um iteiro t > 0, determiar se existe um subcojuto S S ode o somatório dos elemetos de S é igual a t. i s t i
3-CNF-SAT p SUBSET-SUM ( x x2 x3 ) ( x x2 x3 ) x x 2 x 3 C C 2 v 0 0 0 v' 0 0 0 v 2 0 0 v' 2 0 0 0 0 v 3 0 0 0 0 v' 3 0 0 s 0 0 0 0 s' 0 0 0 2 0 s 2 0 0 0 0 s' 2 0 0 0 0 2 t 4 4
Programação Diâmica Método de solução de problemas baseado o uso de tabelas. Resolve problemas combiado as soluções de subproblemas. As soluções para cada um dos subproblemas são armezadas em uma tabela, dessa forma uma solução ão ecessita ser recalculada quado um subproblema ocorre repetidas vezes.
Programação Diâmica É idicada quado um subproblema ocorre repetidamete e sua solução pode ser reaproveitada. Exemplo: fib( ) fib( ) fib( 2) se 0 se
Programação Diâmica Abordagem top-dow (Memoizatio) Pode ser vista como o uso de recursão com apoio de tabelas: Como ocorre em algoritmos recursivos (divisão e coquista), um problema é resolvido dividido-o em subproblemas meores, resolvedo esses subproblemas recursivamete e combiado suas soluções. A solução de cada subproblema é armazeada em uma tabela, dessa forma ão é recalculada caso o subproblema ocorra repetidamete.
Programação Diâmica Abordagem top-dow (Memoizatio) Fib() se etão retore seão se F[] está idefiido F[] Fib( ) + Fib( 2) retore F[]
Fib() F[0] = 0 F[] = para i 2 até retore F[] Programação Diâmica Abordagem bottom-up F[i] = F[i 2] + F[i ]
Programação Diâmica Chage-Makig Problem Dado um cojuto de moedas, cada uma com um valor x i, e um valor t, achar o cojuto {f, f 2,, f }, ode f i represeta a quatidade de moedas de valor x i, que miimiza: f i i tal que: i x i f i t
Programação Diâmica Chage-Makig Problem Imprimir-Troco (s, x, t) Equato t > 0 Imprimir (x[s[t]]) t t x[s[t]] Ode c[t] é o úmero míimo de moedas para totalizar o valor t e s[t] é o ídice da última moeda que ocorre essa solução. Exemplo: x = {, 2, 5} e t = 9 t c s 0 0-2 2 3 2 2 4 2 2 5 3 6 2 3 7 2 3 8 3 3 9 3 3
Troco(x[..], t) c[0] 0 para p até t mi para i até c[p] mi s[p] moeda retore (c, s) Programação Diâmica Chage-Makig Problem se (x[i] p) e (c[p x[i]] + mi) etão mi c[p x[i]] + moeda i
Programação Diâmica (Subset-Sum) Dado um cojuto de iteiros positivos, represetados como um arrajo S[..], e um iteiro t, existe algum subcojuto de S tal que a soma de seus elemetos seja t. SubsetS( i, t) Verdade Falsidade SubsetS( i, t) se t 0 se t 0 i SubsetS( i, t x[ i])
Exemplo: x = {2, 3, 5} e t = 8. Programação Diâmica (Subset-Sum) SubsetS( i, t) Verdade Falsidade SubsetS( i, t) se t 0 se t 0 i SubsetS( i, t x[ i])
Programação Diâmica (Subset-Sum) SubsetSum(x[..], t) S[ +, 0] Verdade para j até t S[ +, j] Falsidade para i até S[i, 0] Verdade para j até x[i] S[i, j] S[i +, j] para j x[i] até t S[i, j] S[i +, j] v S[i +, j x[i]] retore S[,t]
Programação Diâmica (Subset-Sum) Exemplo: x = {, 3, 5, 7} e t = 0. 0 2 3 4 5 6 7 8 9 0 V V F V V V V V V V V 2 V F F V F V F V V F V 3 V F F F F V F V F F F 4 V F F F F F F V F F F 5 V F F F F F F F F F F
Algoritmos que Executam em Tempo Pseudo-Poliomial SUBSET-SUM Usado programação diâmica podemos implemetar um algoritmo pseudo-poliomial com complexidade O(t), ode é o umero de elemetos o cojuto e t o valor do somatório que se deseja alcaçar. Se restrigirmos ossa ateção a istâcias do problema ode o valor de t é limitado por um poliómio existe uma solução eficiete.
Algoritmos que Executam em Tempo Pseudo-Poliomial Essa restrição pode ser bastate razoável a prática: Problemas ode é impossível a ocorrêcia de úmeros muito grades (e.g. problemas de escaloameto). Problemas ode o tamaho do úmero possa ser restrito ao tamaho da palavra do processador. Note que esse ão é o caso da redução do 3-CNF-SAT ao SUBSET-SUM, ode o valor de t cresce expoeciamete ao úmero de variáveis e cláusulas presetes a fórmula booleaa.
Heurísticas e Algoritmos de Aproximação Procedimetos heurísticos são métodos que buscam soluções próximas a solução ótima de um problema. Utilizam alguma iformação (ou ituição) sobre a istâcia do problema para resolvê-lo de forma eficiete. Um algoritmo de aproximação, além de uma solução eficiete, garate a qualidade da solução. É ecessário provar a garatia de proximidade da solução ótima.
Algoritmos de Aproximação Caixeiro Viajate E E 9 9 0 0 A 2 5 4 7 D 6 C 3 A 2 5 4 6 7 C D 3 B 4 B 4 Dado o grafo G = (V, A) e o custo c:. Selecioe um vértice r V para ser o vértice raiz. 2. Obteha a ávore geradora míima a partir de r. 3. Faça P ser a lista de vertices ordeados de acordo com a primeira visita, cosiderado um percurso em pré-ordem. Se a fução custo satisfaz a desigualdade de triâgulos: c(u, w) c(u, v) + c(v, w) c(t ) < c(ótimo) c(t cocateado com [r]) 2c(ótimo)
Referêcias Algoritmos. Thomas H. Corme, Charles E. Leiserso, Roald L. Rivest, Cliford Stei. Campus. Algorithms. Sajo Dasgupta, Christos Papadimitriou, Umesh Vazirai. McGraw Hill. Cocrete Mathematics: A Foudatio for Computer Sciece (2d Editio). Roald L. Graham, Doald E. Kuth, Ore Patashik. Addiso Wesle. M. R. Gare ad D. S. Johso. 978. Strog NP-Completeess Results: Motivatio, Examples, ad Implicatios. J. ACM 25, 3 (Jul 978)