Técnicas de projeto de algoritmos

Técnicas de projeto de algoritmos
Parte 3 Técnicas de projeto de algoritmos

Técnicas de projeto de algoritmos
Divisão e conquista Algoritmos gulosos Programação dinâmica Caminhamento em grafos Heurísticas Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Divisão e conquista

Divisão e conquista Princípio básico: function DC (x)
se {x é suficientemente pequeno ou simples} então return ADHOC(x) senão decompor x em x1, x2, …, xK para i = 1 até K faça yi  DC (xi); recombinar os yi para obter y return y Pesquisa binária Merge Sort Top down Recorrente Balanceamento Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Máximo e mínimo Entrada: a1,, a2 , …, an Saída: MIN, MAX
com: MIN  min { a1, a2 , … , an } MAX= max{ a1, a2 , … , an } trivial: determinar MIN: (n-1) comparações determinar MAX: (n-1) comparações 2n-2 comparações melhorado: MIN, MAX  a1 para i = 2 até n faça se ai > MAX então MAX  ai senão se ai < MIN então MIN  ai melhor caso: ai n-1 comparações pior caso: ai 2n-1comparações Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Máximo e mínimo procedure MaxMin(i, j, fmax, fmin) integer i, j
global n, A(1:n) case : i=j fmax, fmin  A(i) : i=j se A(i) < A(j) então fmax  A(j) fmin  A(i) else fmax  A(i) fmin  A(j) : else meio  (i+j)/2 MaxMin(i, meio, gmax , gmin) MaxMin(meio+1, j, hmax , hmin) fmax  max(hmax , gmax) fmin  min(hmin , gmin) endcase T(n) = O(1) + 2·T(n/2) T(n) = O(n) Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Divisão e conquista Pesquisa binária max min
Multiplicação de polinômios Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Divisão e conquista mergesort multiplicação de polinômios
Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Problema de seleção Dado um vetor a1, a2, …, an obter o k-ésimo menor elemento ordenação: O(n log n) + O(k) k pequeno: O(k·n) É possível fazer melhor do que isso? Reorganizar o vetor a em relação a um pivô x: ai  x ai  x Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Problema de seleção A partition(A, p, r, x) i  p-1 x j  r+1
enquanto TRUE faça repita j  j -1 até que A[j]  x repita i  i+1 até que A[i]  x se i < j então troca A[i] ↔ A[j] senão retornar j fim Complexidade: O(n) Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Exemplo: X = 5 A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] 5 3 2 6 4 1 3 7
3 5 1 6 i i A[i]  5 i A[i]  5 i A[i]  5 i A[i]  5 i A[i]  5 j A[j]  5 j A[j]  5 j A[j]  5 j A[j]  5 j Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Problema de seleção P1 P2  X  X Determinar o k-ésimo menor elemento:
Se |P1|  k  procurar o k-ésimo em P1 Se |P1|  k  procurar o k-|P1| ésimo em P2 usar o algoritmo de partição Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Problema de seleção Select(k,n):
Dividir os n elementos em n/5 grupos de 5 elementos cada. Extrair a mediama de cada um dos n/5 grupos de 5 elementos cada. Extrair recursivamente a mediana das n/5 medianas usando select: Select (n/10,n/5). Seja x esta mediana: Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Problema de seleção m1 m2 m3 m5 m6 m7 X Setembro 2004
Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Problema de seleção Particionar os dados de entrada utilizando x como pivô usando o algoritmo partition Sejam b1 e b2 o número de elementos em cada partição. Se k  b1: aplicar select para obter o k-ésimo da 1a parte Se k > b1: aplicar select para obter o (k-b1)-ésimo da 2a parte (recursivamente) Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Multiplicação de polinômios
Polinômio de grau n-1 tem n termos Entrada: p(x) e q(x) têm tamanho n Saída : r(x)=p(x)·q(x) “força bruta”: para i = 0 até 2n-2 faça r(i)  0; para i = 0 até n-1 faça para j = 0 até n-1 faça r(i+j)  r(i+j) + p(i)·q(j); T(n) = O(n2) Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

n=2k p(x) + q(x)  O(n) p(x) · q(x)  O(n2), computacionalmente mais caro Idéia: substituir “·” por “+” Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

| b1 b0 a0b1 a1b1 b0 + b1 a0b0 a1b0 a a1 a0+ a1 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

4 multiplicações 1 adição Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Complexidade: É necessário resolver menos de quatro problemas Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Multiplicação de matrizes
Hipótese: n=2k Particionar A e B em quatro submatrizes n/2 x n/2 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

A · B: oito multiplicações de matrizes (n/2) Adicionar duas matrizes n/2 x n/2 : O(n2) Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Aumentar o número de adições de matrizes para diminuir o número de multiplicações: método de Strassen 7 multiplicações 18 adições Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Problema do par mais próximo
Problema do par mais próximo: dados n pontos no plano com coordenadas (xi, yi), i=1,…n, obter o par de pontos mais próximo “Força bruta”: calcular todas as n(n-1)/2 distâncias: O(n2) É possível fazer melhor do que isso? Ordenar todos n pontos pelas coordenadas xi  O(n log n) Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Separar os pontos em duas metades, de acordo com a ordenação pelas coordenadas xi P P2 d1: menor distância entre pontos de P1 d2: menor distância entre pontos de P2 Verificar se existe A1  P1 e A2  P2 tais que: d(A1,A2) = d < min{d1,d2} d1 e d2 podem ser calculados recursivamente. Falta calcular d = min {d(A1,A2): A1  P1 e A2  P2}. Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

T(n) = 2.T(n/2) + O(n)  T(n) = O(n log n) Como calcular d em O(n)?  = min {d1,d2} Só é necessário calcular d se d < . P1 P2 d1 d2  Só é necessário examinar uma faixa de pontos a distância   da reta vertical que separa P1 e P2. Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Muitos pontos são eliminados, mas no pior caso podem restar O(n) pontos nesta faixa: o cálculo de d continuaria O(n2). É possível mostrar que na média há na média. para i =1 até #pontos_na_faixa-1 faça para j = i+1 até #pontos_na_faixa-1 faça se d(pi, pj) <  então   d(pi, pj) Como melhorar? Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

As coordenadas y dos dois pontos que definem d diferem por no máximo , senão d > . Se os pontos na faixa estão ordenados em ordem crescente pelas coordenadas y, se d(pi,pj) >  pode-se abandonar a análise de pi e passar-se a pi+1. Hipótese: pontos na faixa ordenados por yi. para i =1 até #pontos_na_faixa-1 faça para j = i+1 até #pontos_na_faixa-1 faça se |yi - yj| >  então examinar pi+1 e sair do loop interno senão se d(pi,pj) <  então   d(pi, pj) Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

      i   Não pode haver mais do que oito pontos no retângulo  x . Um deles é o ponto sendo examinado. Verificar no máximo sete pontos: pode ser feito em O(1). Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Algoritmo 1: Ordenar os pontos pelas coordenadas x. Dividir o conjunto em duas partes P1 e P2. Recursivamente calcular as distâncias d1 e d2. Fazer  ← min {d1,d2}. Eliminar os pontos a uma distância superior a  da linha de separação. Ordenar os pontos na faixa de acordo com as coordenadas y. Investigar os pontos na ordem e computar a distância de cada um deles a no máximo sete vizinhos. Se alguma distância for menor do que , então atualizar . T(n) = O(n log n) + 2.T(n/2) + O(1) + O(n) + O(n log n) + O(n) Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Algoritmo 2: Ordenar os pontos pelas coordenadas x. Dividir o conjunto em duas partes P1 e P2. Recursivamente: Calcular as distâncias minímas d1 e d2. . Ordenar os pontos em P1 e P2 segundo as coordenadas y. Combinar as duas listas ordenadas em uma única Fazer  ← min {d1,d2}. Eliminar os pontos a uma distância superior a  da linha de separação. Investigar os pontos na ordem e computar a distância de cada um deles a no máximo sete vizinhos. Se alguma distância for menor do que , então atualizar . T(n) = 2.T(n/2) + O(n) = O(n log n) Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Algoritmos gulosos

Algoritmos gulosos Problema de otimização
Extensões sucessivas de soluções parciais Sempre escolhe a extensão viável que propicia o maior ganho (“gula”) Otimalidade nem sempre garantida Sistema de subconjuntos: matróide Algoritmos simples e eficientes Análise de complexidade: simples Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Cobertura por nós mínima
Grafo não-orientado G(V, E): obter S  V tal que: {u, v}  E então uS ou vS |S| é mínima 5 2 1 3 4 |S| = 4 ordem dos vértices divisão e conquista 2 1 3 5 4 |S| = 3 maior grau (guloso) 2 1 3 5 4 |S| = 2 2 1 3 5 4 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

O algoritmo guloso obtém necessariamente a solução ótima? Solução gulosa Solução ótima Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

O algoritmo guloso obtém necessariamente a solução ótima? n+2 nós grau 1 n+2 nós grau n+1 n nós grau n+2 A solução pode ser muito ruim! Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Armazenamento em fita Entrada: L  (l1, l2, …, ln) vetor com comprimentos de n arquivos a serem armazenados em uma fita suficientemente extensa Saída: (j, li(j)) para j=1, …, n i(j) é o índice do j-ésimo arquivo na fita Determinar a ordem de armazenamento dos arquivos na fita, de modo a minimizar o tempo médio TMR (ou total) de recuperação de um arquivo. Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Armazenamento em fita 7 3 5 2 … 7 3 2 5 … Setembro 2004
… … Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

B-A? Armazenamento em fita 2 3 5 7 …
… Armazenar arquivos em ordem crescente de tamanhos Algoritmo auxiliar: ordenar o vetor em O(n log n) Mostrar que o algoritmo é correto Numa solução ótima não existe Supondo-se que existisse: Trocando: B-A? Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Armazenamento em fita a troca diminuiria o custo. Setembro 2004

Problema da mochila em qualquer solução ótima Setembro 2004

Volume disponível na mochila = 20
Problema da mochila Exemplo: Objeto Ganho Volume total Volume disponível na mochila = 20 Guloso 1: maior ganho primeiro Guloso 2: menor volume primeiro Guloso 3: maior densidade primeiro (densidade = ganho/volume) Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Problema da mochila É permitido fracionar os objetos
guloso 1: ganhos decrescentes x1: fração do objeto 1  x1 = 1 volume residual = = 2 15·x2 = 2  x2 = 2/15 valor total: /15 · 24 = 28.2 x1 x2 x3 ganho 2/ 4/9 4/ Enche a mochila muito rapidamente! Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Problema da mochila x1 x2 x3 valor 1 2/15 0 28.2 4/9 4/5 0 30.3
/ 4/9 4/ 0 2/ 0 4/ / / guloso 1 guloso 2 guloso 3 i ci ai ci/ai ~1.38 3   b=20 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Problema da mochila Provar que a solução do guloso com o terceiro critério é ótima: Ordenar os objetos em ordem decrescente das razões cj/aj Solução gulosa: (1, 1, 1, …, 1, gj, 0,…, 0, 0) Diminuir o valor de uma variável em A  aumentar uma variável em B Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Problema da mochila Hipótese: não é permitido fracionar os objetos
O algoritmo guloso não obtém necessariamente a solução ótima! Por que? Propor outros algoritmos gulosos: soluções ótimas? contra-exemplos? Algoritmo guloso é uma heurística de baixa complexidade. Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Árvore Geradora de Peso Mínimo
Entrada: G = (V,E) grafo não-orientado peso c(e) e  E Saída: F  E tal que (i) O grafo G’=(V,F) é acíclico e conexo (G’ é gerador de G) (ii) F é maximal (iii) c(F)   c(e) é mínimo e  F Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Árvore Geradora de Peso Mínimo
Exemplos de árvores geradoras: 3 4 7 A B C F D E 8 3 4 9 2 7 8 A B C F D E 8 4 9 2 8 A B C F D E Princípio do algoritmo: a aresta de menor peso sempre pertence à solução ótima Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Algoritmo de Kruskal L  lista com arestas ordenadas em ordem crescente de pesos; F  ; count  0; enquanto count < n – 1 e L   faça seja (v,w) o próximo arco de L remover (v,w) de L se v e w não estão na mesma componente início F  F  {(v,w)} colocar v e w na mesma componente count  count + 1 fim Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Exemplo c(e) e 2 (f,c) (c,e) 3 (a,b) (a,d) 4 (a,f) 7 (b,c) 8 (b,e) (e,f) (c,d) 9 (d,e) (b,f) 3 A B 4 9 7 2 3 F C 8 2 8 8 D 9 E C(T) = = 14 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Exemplo c  e ? f  c ? 3  5 6  3 6 f 5 e 4 d 3 c 2 b 1 a Árvore
Vértice f  c ? 6  3 3 f 5 e 4 d c 2 b 1 a Árvore Vértice c  e ? 3  5 5 f e 4 d c 2 b 1 a Árvore Vértice Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Exemplo c  e ? 3  5 b  a ? a  d ? 2  1 a  f ? 1  4 4  5 5 f e
Árvore Vértice b  a ? 2  1 5 f e 4 d c 1 b a Árvore Vértice a  d ? 1  4 5 f e 4 d c b a Árvore Vértice a  f ? 4  5 5 f e d c b a Árvore Vértice Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Complexidade Ordenar  O(m log m)  O(m log n)
Testar componentes  O(1) m vezes  O(m) Reorganizar componentes  O(n) n vezes  O(n2) T(n) = O(m log m) + O(m) + O(n2) = = O(m log m + n2) = O(m log n + n2) Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Estrutura de dados Union finding: 1) Dado um nó, obter sua componente.
2) Fundir duas componetes. Colocar os nós de cada componente em uma árvore e representar a componente pela raiz da árvore. Achar a componente: seguir o caminho do nó até a raiz. Fundir duas componentes: fazer a raiz de uma componente tornar-se filha da raiz da outra. A raiz da árvore mais baixa torna-se filho da raiz da árvore mais alta. Altura da árvore  log n Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Estrutura de dados 1 1 2 2 3 3 ... 4 árvore mais baixa  árvore mais alta 1 2 3 4 2 1 4 3 ... Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Complexidade altura  log n
Determinar cada componente e testar: O(log n) Reorganizar componentes: O(1) Complexidade: T(n) = O(m log n), melhor do que O(m log n + n2) Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Algoritmo de Prim Começar com um nó qualquer.
A cada iteração, adicionar a aresta de menor peso que conecta um nó já conectado a um nó não conectado. 3 A B 4 9 7 2 3 F C 8 2 8 8 D 9 E Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Algoritmo de Prim Complexidade: T(n) = O(n2)
Seja (k,l) a aresta de menor peso Para i de 1 a n, fazer: prox(i)  l, se cil < clk prox(i)  k, caso contrário prox(k), prox(l)  0 Fazer (n-2) iterações: Seja j tal que prox(j)  0 e cj,prox(j) é mínimo Fazer prox(j)  0 Para k de 1 a n, faça Se prox(k)  0 e ck,prox(k) > ckj, então prox(k)  j Complexidade: T(n) = O(n2) Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Exemplo a 3 b 4 9 7 3 f 2 c 8 8 2 8 d 9 e a 3 b 3 d 4 2 f 2 c e Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Intercalação ótima de arquivos
Intercalar 2 arquivos com m e n registros: m + n operações (merge). Intercalar diversos arquivos: dois a dois Diferentes ordens levam a diferentes tempos de processamento: A = 30 B = 20 C = 10 registros A + B = 50 operações (A + B) + C = 60 operações B + C = 30 operações (B + C) + A = 60 operações Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

n1 + n2 n1 + n2 + n3 n1 + n2 + n3 + n4 3n1 + 3n2 + 2n3 + n4 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Menores arquivos primeiro! n1 + n2 n3 + n4 (n1 + n2)+ (n3 + n4) 2n1 + 2n2 + 2n3 + 2n4 n4 n3 n2 n1 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Arquivos: nós externos da árvore binária Operações: nós internos di: distâncias da raiz ao nó representando o i-ésimo arquivo Número total de operações (cópias/deslocamento) di.qi (qi é o número de registros no arquivo i) Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Lista L de n árvores Cada nó na árvore tem 3 campos LCHILD: RCHILD: PESO: tamanho de um arquivo procedure TREE(i,n) para i = 1 até n-1 GETNODE (T) LCHILD(T)  LEAST (L) RCHILD(T)  LEAST (L) WEIGHT(T)  WEIGHT(LCHILD(T)) + WEIGHT(RCHILD(T)) INSERT(L,T) return (LEAST(L)) Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

GETNODE(T): novo nó para usar na construção da árvore LEAST(L): obtém e remove da árvore em L cuja raiz tem menor peso INSERT(L,T): insere a árvore com raiz T na lista L Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

1 2 3 4 5 5 10 20 30 30 L: T GETNODE LEAST (L) 1 LEAST (L) 2 L: 3 5 6 4 15 20 30 30 5 10 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

35 30 30 15 20 5 10 35 60 15 20 30 30 5 10 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

95 35 15 20 5 10 60 30 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

n – 1 iterações Lista L ordenada pelos pesos LEAST  O(1) INSERT  O(n) L organizada como um heap LEAST  O(log n) INSERT  O(log n) O(n2) O(n log n) Prova por indução Se L inicialmente contém n  1 árvores-nós isoladas com pesos q1, ..., qn, então o algoritmo gera uma árvore ótima com estes pesos. Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Programação Dinâmica Setembro 2004

Motivação Trajetória ótima de cada nó ao destino final
Problema: determinar o caminho mais curto de 1 a 12 no grafo abaixo Trajetória ótima de cada nó ao destino final 7 2 4 7 4 6 9 6 9 9 2 4 5 2 16 7 3 5 4 2 7 1 2 3 7 10 12 18 1 3 4 11 7 5 5 5 2 8 11 15 11 6 5 8 Procedimento backwards Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Motivação Trajetória ótima do nó inicial até cada nó
Problema: determinar o caminho mais curto de 1 a 12 no grafo abaixo Trajetória ótima do nó inicial até cada nó 9 2 4 9 15 6 9 6 7 9 2 4 5 2 7 3 11 4 14 16 7 1 2 3 7 10 12 3 1 3 4 11 10 16 5 5 2 8 11 2 11 6 5 8 Procedimento forward Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Motivação Trajetória ótima através de cada nó
Problema: determinar o caminho mais curto de 1 a 12 no grafo abaixo Trajetória ótima através de cada nó 2 4 9+7 6 9 6 7+9 9 2 4 5 2 0+16 7 3 16+0 7 4 14+2 1 2 7 10 12 3 1 3 4 11 5 5 2 8 11 11 6 5 8 Combinação das trajetórias ótimas Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Motivação Trajetória ótima através de cada nó
Problema: determinar o caminho mais curto de 1 a 12 no grafo abaixo Trajetória ótima através de cada nó 2 4 6 9 6 9 2 4 5 2 7 3 7 4 1 2 3 7 10 12 1 3 4 11 10+7 5 5 2 8 11 11 6 5 8 Combinação das trajetórias ótimas Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Programação dinâmica Aplicação a problemas de decisões seqüenciais: cada decisão aplicada a um estado em determinado estágio leva a um estado do estágio imediatamente seguinte. Princípio da otimalidade: uma seqüência ótima de decisões tem a propriedade de que quaisquer que sejam o estado e a decisão inicial, as decisões remanescentes constituem uma seqüência ótima de decisões com relação ao estado decorrente da primeira decisão. Alternativamente: “toda subtrajetória da trajetória ótima é ótima com relação a suas extremidades inicial e final”. Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Programação dinâmica Método exato para resolver problemas de progamação inteira que envolvem apenas decisões seqüenciais, nos quais cada nova decisão depende apenas do estado do sistema, mas não das decisões anteriores (isto é, da forma como este estado foi atingido). Principais conceitos envolvidos: estágios (etapas) estados decisões função critério a ser otimizada Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Programação dinâmica Roteiro de aplicação:
Identificar um modelo de decisões seqüenciais através de seus estágios. Assegurar-se de que cada solução viável (ou trajetória) pode ser vista como uma seqüência de decisões tomadas a cada estágio, de modo tal que seu custo seja igual à soma dos custos das decisões individuais. Definir o conceito de estado como a resultante de todas as decisões relevantes tomadas no passado (caso forward). (alternativamente, definir o conceito de estado como a resultante de todas as decisões relevantes tomadas no futuro no caso backwards) Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Programação dinâmica Roteiro de aplicação (continuação):
Determinar as transições de estado possíveis. Atribuir o custo de cada transição de estado à decisão correspondente. Escrever uma recursão que defina o custo ótimo do estado inicial até o estado final. Exemplo de aplicação: problema da mochila Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Problema da mochila Caso (4): os itens não podem ser fracionados e no máximo uma unidade de cada item pode ser selecionada Problema de programação inteira As variáveis inteiras binárias (0-1) representam a decisão de selecionar um objeto ou não. Solução não trivial! Ordenar as variáveis pelo índice lucro/volume resolve o problema linear apenas, mas não o de programação inteira. Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Problema da mochila Decomposição do problema em estágios
Em vez de considerar uma solução (x1,x2,...,xn) completa de uma só vez, visualizar o problema como se as decisões fossem tomadas para um item de cada vez. Após k decisões, terão sido determinados quais dos primeiros k itens devem ser selecionados e, conseqüentemente, terão sido determinados os valores das variáveis x1,x2,...,xk. Neste ponto, o valor acumulado é e o volume acumulado é . Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Problema da mochila Estágio: cada variável do problema Estado:
volume total ocupado com as decisões já tomadas Decisão: selecionar ou não um item (isto é, fazer xk=1) Custo da decisão de selecionar o item k: aumento de ck unidades no lucro parcial acumulado Efeito da decisão de selecionar o item k: aumento do volume ocupado (estado) em ak unidades Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Problema da mochila Definição: yk(u) = lucro máximo que pode ser obtido com volume total igual a u e usando apenas itens do conjunto {1,...,k} Quanto vale y0(0)? y0(0) = 0 (sem objetos selecionados, o peso e o lucro são nulos) Definir yk(u) = - se é impossível obter um volume total igual a u apenas com itens dentre os do conjunto {1,...,k}. Quanto valem y0(u) e yk(0)? y0(u) = - para u > 0 (impossível acumular peso sem itens) yk(0) = 0 para k = 1,2,...,n (nenhum item selecionado) Calcular yk(u) para k = 1,...,n e u = 0,...b, a partir de y0(0). Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Problema da mochila yk(u) = lucro máximo que pode ser obtido com volume total igual a u e usando apenas itens do conjunto {1,...,k} Calcular yk(u) para k = 1,...,n e u = 0,...b: Interpretação: há duas alternativas para se obter yk(u), dependendo do item k ser selecionado ou não yk(u) = yk-1(u), se o item k não é usado yk(u) = yk-1(u-ak)+ck, se o item k é usado Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Problema da mochila Observar que o lucro associado ao estado resultante de uma decisão depende apenas do valor desta decisão e do estado atual, mas não depende da forma como este último foi atingido. Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Problema da mochila y5(4) = Setembro 2004

Valor ótimo = maxb=0,...,4 {y5(b)}
Problema da mochila y5(b) = Valor ótimo = maxb=0,...,4 {y5(b)} Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Problema da mochila y0(4) y5(4) y0(3) y5(3) y0(2) y5(2) y0(1) y5(1)
u = 4 u = 3 u = 2 u = 1 u = 0 y0(4) y5(4) y0(3) y5(3) y0(2) y5(2) y0(1) y5(1) y0(0) y1(0) y2(0) y3(0) y4(0) y5(0) k = 0 k = 1 k = 2 k = 3 k = 4 k = 5 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Problema da mochila y0(4) y0(3) y0(2) y0(1) u = 4 u = 3 u = 2 u = 1
k = 0 k = 1 k = 2 k = 3 k = 4 k = 5 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Problema da mochila - u = 4 u = 3 u = 2 u = 1 u = 0 k = 0 k = 1 k = 2

Problema da mochila - ? u = 4 u = 3 u = 2 u = 1 u = 0 k = 0 k = 1

Problema da mochila - u = 4 u = 3 u = 2 u = 1 u = 0 k = 0 k = 1 k = 2

Problema da mochila - 3 u = 4 u = 3 u = 2 u = 1 u = 0 k = 0 k = 1

Problema da mochila - ? 3 u = 4 u = 3 u = 2 u = 1 u = 0 k = 0 k = 1

Problema da mochila 2 - 3 u = 4 u = 3 u = 2 u = 1 u = 0 k = 0 k = 1
2 k = 0 k = 1 k = 2 k = 3 k = 4 k = 5 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Problema da mochila - ? 3 u = 4 u = 3 u = 2 u = 1 u = 0 k = 0 k = 1

Problema da mochila - 3 2 u = 4 u = 3 u = 2 u = 1 u = 0 k = 0 k = 1

Problema da mochila 2 - 3 2 u = 4 u = 3 u = 2 u = 1 u = 0 k = 0 k = 1

Problema da mochila 2 - 5 3 2 u = 4 u = 3 u = 2 u = 1 u = 0 k = 0

Problema da mochila - 5 3 2 u = 4 u = 3 u = 2 u = 1 u = 0 k = 0 k = 1

Problema da mochila - 5 ? 3 2 u = 4 u = 3 u = 2 u = 1 u = 0 k = 0

Problema da mochila 3 - 5 6 3 2 u = 4 u = 3 u = 2 u = 1 u = 0 k = 0

Problema da mochila - 5 6 3 2 u = 4 u = 3 u = 2 u = 1 u = 0 k = 0

Problema da mochila - 5 6 3 2 y5(4) = 6 y5(3) = 5 y5(2) = 3 y5(1) = 2
u = 4 u = 3 u = 2 u = 1 u = 0 - 5 6 3 2 y5(4) = 6 y5(3) = 5 y5(2) = 3 y5(1) = 2 y5(0) = 0 k = 0 k = 1 k = 2 k = 3 k = 4 k = 5 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Problema da mochila 6 - 5 3 2 y5(4) = 6 y5(3) = 5 y5(2) = 3 y5(1) = 2

Problema da mochila x5=1 6 - 5 3 2 y5(4) = 6 y5(3) = 5 y5(2) = 3

Problema da mochila x4=1 x5=1 6 2 - 5 3 y5(4) = 6 y5(3) = 5 y5(2) = 3

Problema da mochila x3=1 x4=1 x5=1 6 2 - 5 3 y5(4) = 6 y5(3) = 5

Problema da mochila x2=0 x3=1 x4=1 x5=1 6 2 - 5 3 y5(4) = 6 y5(3) = 5

Problema da mochila x1=0 x2=0 x3=1 x4=1 x5=1 6 2 - 5 3 y5(4) = 6

Problema da mochila Os estados em verde e as transições possíveis (arcos com setas) definem um grafo multiestágio para a aplicação da recursão de programação dinâmica. Número de operações (tempo de processamento) diretamente proporcional ao produto do tamanho da mochila pelo número de variáveis (preencher inteiramente a matriz de dimensões (b+1)x(n+1)): aplicabilidade limitada aos valores de n e de b Caso seja possível levar múltiplas cópias de cada item, aumenta o número de decisões e a complexidade do problema. Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Programação dinâmica p “linhas” 2 1 ... n-1 n B Cálculo da menor
Redução no número total de operações: p “linhas” 2 1 ... n-1 n B Cálculo da menor trajetória de A a B Total de adições? Total de trajetórias de A a B: pn Cálculo exaustivo: n.pn Programação dinâmica: p + p.p.(n-1) + p  n.p2 A Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Programação dinâmica Observar que o valor da função objetivo associado a um estado depende apenas dele, mas não depende da forma como foi atingido. O fato de serem implicitamente descartadas subtrajetórias não-ótimas é que leva à redução significativa do número de operações. Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Programação dinâmica Identificar decisões e estágios
Identificar o critério de otimização Construir a função critério Identificar o critério de otimalidade Para cada decisão relacionar recursivamente os valores do critério definindo as variáveis de estado necessários Considerando as variáveis de estado, fornecer condições de contorno para a função critério. Determinar a política ótima para cada estágio e estado. Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Programação dinâmica (I) Problema de otimização de investimentos: Considere-se um conjunto de n possíveis investimentos, nos quais é possível aplicar no máximo um total de M unidades monetárias. Seja cj(k) o retorno obtido com a aplicação de 0  k  M unidades monetárias no investimento j = 1,...,n. Determinar a aplicação ótima a ser feita em cada investimento, de modo a maximizar o retorno total. Resolver o problema para n = 3 e M = 4, considerando a matriz de retornos fornecida a seguir: Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Programação dinâmica k c1(k) c2(k) c3(k) 1 3 2 7 4 11 6 12 8
1 3 2 7 4 11 6 12 8 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Programação dinâmica Estágio: Estado: Decisão: Recursão:
cada investimento k = 1, 2, 3 considerado Estado: total ainda disponível para ser aplicado nos investimentos k, k+1, …, n outra alternativa: total aplicado nos investimentos 1, 2, …, k Decisão: quanto aplicar no investimento k Recursão: Rk(x) = max0yx {ck(y) + Rk+1(x-y)} Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Programação dinâmica Condições de contorno:
R4(0) = 0 Todos os recursos devem ser usados nos três investimentos. Valor máximo do retorno obtido: R1(4) = ? Maximizar o retorno obtido com a aplicação de um total de quatro unidades nos investimentos 1, 2, 3. Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Programação dinâmica Estado inicial: R1(4) = ? Estado final: R4(0) = 0
Investimento 1 Investimento 2 Investimento 3 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

3 2 1 Estado final: R4(0) = 0 Investimento 1 Investimento 2 Investimento 3 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

3 3 2 2 1 1 Estado final: R4(0) = 0 Investimento 1 Investimento 2 Investimento 3 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

4 4 4 3 Estado inicial: R1(4) = ? 3 3 7 11 2 2 12 1 1 Estado final: R4(0) = 0 Investimento 1 Investimento 2 Investimento 3 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

4 4 4 3 Estado inicial: R1(4) = ? 1 3 3 7 2 11 2 2 4 12 1 1 Estado final: R4(0) = 0 8 Investimento 1 Investimento 2 Investimento 3 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

4 4 4 3 Estado inicial: R1(4) = ? 1 3 3 7 4 1 2 11 2 2 4 2 12 1 1 Estado final: R4(0) = 0 8 Investimento 1 Investimento 2 Investimento 3 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

4 4 4 3 Estado inicial: R1(4) = ? 1 3 3 7 4 1 2 11 2 2 4 1 2 2 12 1 1 Estado final: R4(0) = 0 8 Investimento 1 Investimento 2 Investimento 3 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

4 4 4 3 Estado inicial: R1(4) = ? 1 3 3 7 4 1 2 11 2 2 4 1 2 2 12 1 1 1 Estado final: R4(0) = 0 8 Investimento 1 Investimento 2 Investimento 3 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

4 4 4 3 8 Estado inicial: R1(4) = ? 1 3 3 7 6 4 1 2 11 2 2 4 1 4 2 2 12 1 1 2 1 Estado final: R4(0) = 0 8 Investimento 1 Investimento 2 Investimento 3 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Programação dinâmica 8 Estado 6 inicial: R1(4) = ? 4 2 Estado final:
4 4 4 3 8 Estado inicial: R1(4) = ? 1 6 3 3 7 6 4 1 2 4 11 2 2 4 1 4 2 2 2 12 1 1 2 1 Estado final: R4(0) = 0 8 Investimento 1 Investimento 2 Investimento 3 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Programação dinâmica 8 8 Estado inicial: R1(4) = ? 6 4 2 Estado final:
4 4 4 3 8 Estado inicial: R1(4) = ? 1 6 3 3 7 6 4 1 2 4 11 2 2 4 1 4 2 2 2 12 1 1 2 1 Estado final: R4(0) = 0 8 Investimento 1 Investimento 2 Investimento 3 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Programação dinâmica 8 8 Estado inicial: R1(4) = ? 6 6 4 2 Estado
4 4 4 3 8 Estado inicial: R1(4) = ? 1 6 6 3 3 7 6 4 1 2 4 11 2 2 4 1 4 2 2 2 12 1 1 2 1 Estado final: R4(0) = 0 8 Investimento 1 Investimento 2 Investimento 3 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Programação dinâmica 8 8 Estado inicial: R1(4) = ? 6 6 4 4 2 Estado
4 4 4 3 8 Estado inicial: R1(4) = ? 1 6 6 3 3 7 6 4 1 2 4 4 11 2 2 4 1 4 2 2 2 12 1 1 2 1 Estado final: R4(0) = 0 8 Investimento 1 Investimento 2 Investimento 3 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Programação dinâmica 8 8 Estado inicial: R1(4) = ? 6 6 4 4 2 2 Estado
4 4 4 3 8 Estado inicial: R1(4) = ? 1 6 6 3 3 7 6 4 1 2 4 4 11 2 2 4 1 4 2 2 2 2 12 1 1 2 1 Estado final: R4(0) = 0 8 Investimento 1 Investimento 2 Investimento 3 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Programação dinâmica 13 8 8 Estado inicial: R1(4) = ? 6 6 4 4 2 2
4 4 4 3 8 Estado inicial: R1(4) = ? 1 6 6 3 3 7 6 4 1 2 4 4 11 2 2 4 1 4 2 2 2 2 12 1 1 2 1 Estado final: R4(0) = 0 8 Investimento 1 Investimento 2 Investimento 3 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Programação dinâmica 13 8 8 Estado inicial: R1(4) = ? 6 6
4 4 4 3 8 Estado inicial: R1(4) = ? 1 6 6 Solução ótima: projeto 1: 3 unidades projeto 2: 0 unidades projeto 3: 1 unidade Retorno total = 13 3 3 7 6 4 1 2 4 4 11 2 2 4 1 4 2 2 2 2 12 1 1 2 1 Estado final: R4(0) = 0 8 Investimento 1 Investimento 2 Investimento 3 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Programação dinâmica (II) Problema de substituição de equipamentos: Uma empresa precisa de uma máquina para produzir determinado produto ao longo dos próximos N anos. Os seguintes dados são disponíveis: P = preço de compra de uma máquina nova c(i) = custo anual de operação de uma máquina de idade i t(i) = preço obtido na troca de uma máquina de idade i r(i) = valor de residual uma máquina de idade i No início do período de programação, a empresa dispõe de uma máquina com M anos de uso. Determinar a política ótima de substituição desta máquina ao longo dos N anos, de modo a minimizar a soma dos custos anuais. Considerar N = 5 (horizonte), M = 2 (idade da máquina no início do horizonte), P = 50 (preço de compra de uma máquina nova) e os demais custos e preços informados na tabela a seguir. Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Programação dinâmica Observar que o modelo pode ser estendido para considerar preços diferentes para uma máquina nova a cada ano, taxa de desconto, troca por máquinas mais novas mas já usadas, etc. Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Programação dinâmica idade i 1 2 3 4 5 6 c(i) 10 13 20 40 70 100 110
1 2 3 4 5 6 c(i) 10 13 20 40 70 100 110 t(i) - 32 21 11 r(i) 25 17 8 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Programação dinâmica Estágio: Estado: Decisão: Recursão:
cada ano k = 1, 2, ..., N do horizonte Estado: idade da máquina no ano k Decisão: o que fazer com a máquina no ano k: trocá-la por uma nova ou mantê-la em funcionamento Recursão: Vk(i): custo ótimo total do ano k até o final do horizonte a partir de uma máquina de idade i Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Programação dinâmica Recursão:
Vk(i): custo ótimo total do ano k até o final do horizonte a partir de uma máquina de idade I Máquinas novas são sempre compradas no dia 1 de janeiro de cada ano e completam um ano de vida em 1 de janeiro do ano seguinte. Caso uma máquina de idade i seja trocada por uma nova no início do ano k: Vk(i) = p - t(i) + c(0) + Vk+1(1) Caso contrário: Vk(i) = c(i) + Vk+1(i+1) Vk(i) = mínimo {p - t(i) + c(0) + Vk+1(1), c(i) + Vk+1(i+1)} Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Programação dinâmica Condições de contorno:
VN+1(i) = -r(i) A máquina é vendida por seu valor residual ao final do horizonte. Início do ano 1: máquina tem idade M Custo mínimo ao longo do horizonte: V1(M) = ? Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Programação dinâmica Ano 1 Ano 2 Ano 3 Ano 4 Ano N=5 Ano 6

Programação dinâmica Ano 1 Ano 2 Ano 3 Ano 4 Ano N=5 Ano 6 2

Programação dinâmica Ano 1 Ano 1 Ano 2 Ano 3 Ano 4 Ano N=5 Ano 6 2

Programação dinâmica Ano 1 Ano 2 Ano 3 Ano 4 Ano N=5 Ano 6 3 20 2 39 1

Programação dinâmica Ano 1 Ano 2 Ano 3 Ano 4 Ano N=5 Ano 6 3 20 2 2 39
13 1 1 28 Ano 1 Ano 2 Ano 3 Ano 4 Ano N=5 Ano 6 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Programação dinâmica Ano 1 Ano 2 Ano 3 Ano 4 Ano N=5 Ano 6 4 40 3 20
49 2 2 39 13 1 1 28 Ano 1 Ano 2 Ano 3 Ano 4 Ano N=5 Ano 6 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

55 3 20 49 2 2 39 13 1 1 1 28 Ano 1 Ano 2 Ano 3 Ano 4 Ano N=5 Ano 6 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

55 3 3 20 49 20 2 2 39 2 39 13 13 1 1 1 28 28 Ano 1 Ano 2 Ano 3 Ano 4 Ano N=5 Ano 6 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

60 4 40 55 3 3 20 49 20 2 2 39 2 39 13 13 1 1 1 1 28 28 Ano 1 Ano 2 Ano 3 Ano 4 Ano N=5 Ano 6 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

60 4 4 40 40 55 3 3 3 49 20 49 20 20 2 2 39 2 39 2 39 13 13 13 1 1 1 1 28 28 28 Ano 1 Ano 2 Ano 3 Ano 4 Ano N=5 Ano 6 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

60 5 70 60 4 4 40 40 55 3 3 3 49 20 49 20 20 2 2 39 2 39 2 39 13 13 13 1 1 1 1 1 28 28 28 Ano 1 Ano 2 Ano 3 Ano 4 Ano N=5 Ano 6 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

60 5 5 70 70 60 4 4 4 55 40 40 40 55 3 3 3 3 49 20 49 20 49 20 20 2 2 39 2 39 2 2 39 39 13 13 13 13 1 1 1 1 1 28 28 28 28 Ano 1 Ano 2 Ano 3 Ano 4 Ano N=5 Ano 6 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Programação dinâmica Ano 1 Ano 2 Ano 3 Ano 4 Ano N=5 Ano 6 -0 7 110 6
100 60 -0 5 5 70 70 60 -0 4 4 4 55 40 40 40 55 -8 3 3 3 3 49 20 49 20 49 20 20 -17 2 2 39 2 39 2 2 39 39 13 13 13 13 -25 1 1 1 1 1 28 28 28 28 Ano 1 Ano 2 Ano 3 Ano 4 Ano N=5 Ano 6 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

100 60 -0 5 5 70 70 30 60 -0 4 4 4 55 40 40 40 55 24 -8 3 3 3 3 49 20 49 20 49 20 20 14 -17 2 2 39 2 39 2 2 39 39 13 13 13 -4 13 -25 1 1 1 1 1 28 28 28 28 Ano 1 Ano 2 Ano 3 Ano 4 Ano N=5 Ano 6 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

100 56 60 -0 5 5 70 70 30 60 -0 4 4 4 55 40 45 40 40 55 24 -8 3 3 3 3 49 20 49 20 49 20 35 20 14 -17 2 2 39 2 39 2 2 39 39 13 13 24 13 -4 13 -25 1 1 1 1 1 28 28 28 28 Ano 1 Ano 2 Ano 3 Ano 4 Ano N=5 Ano 6 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

100 56 60 -0 5 5 70 70 79 30 60 -0 4 4 4 55 40 45 40 40 55 24 -8 3 3 3 3 49 20 49 63 20 49 20 35 20 14 -17 2 2 39 2 39 2 2 39 39 13 48 13 24 13 -4 13 -25 1 1 1 1 1 28 28 28 28 Ano 1 Ano 2 Ano 3 Ano 4 Ano N=5 Ano 6 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

100 56 60 -0 5 5 70 70 79 30 60 -0 4 4 4 55 40 97 45 40 40 55 24 -8 3 3 3 3 49 20 49 63 20 49 20 35 20 14 -17 2 2 39 2 39 2 2 39 39 76 13 48 13 24 13 -4 13 -25 1 1 1 1 1 28 28 28 28 Ano 1 Ano 2 Ano 3 Ano 4 Ano N=5 Ano 6 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

100 56 60 -0 5 5 70 70 79 30 60 -0 4 4 4 55 40 97 45 40 40 55 24 -8 3 3 3 3 49 20 115 49 63 20 49 20 35 20 14 -17 2 2 39 2 39 2 2 39 39 76 13 48 13 24 13 -4 13 -25 1 1 1 1 1 28 28 28 28 Ano 1 Ano 2 Ano 3 Ano 4 Ano N=5 Ano 6 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Programação dinâmica Solução ótima: trocar a máquina nos anos 1, 2 e 4
-0 7 Solução ótima: trocar a máquina nos anos 1, 2 e 4 Custo total = 115 110 35 6 100 56 60 -0 5 5 70 70 79 30 60 -0 4 4 4 55 40 97 45 40 40 55 24 -8 3 3 3 3 49 20 115 49 63 20 49 20 35 20 14 -17 2 2 39 2 39 2 2 39 39 76 13 48 13 24 13 -4 13 -25 1 1 1 1 1 28 28 28 28 Ano 1 Ano 2 Ano 3 Ano 4 Ano N=5 Ano 6 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Programação dinâmica (III) Problema simplificado de planejamento da operação: Considere-se um sistema formado por uma usina hidráulica com reservatório (ou um sistema equivalente) e uma usina térmica capaz de complementar toda a demanda. São conhecidas as afluências mensais, as demandas mensais, a vazão turbinada máxima mensal da usina hidráulica e os volumes inicial e final do reservatório. Equacionar um modelo passível de ser resolvido por programação dinâmica para a otimização da operação, minimizando o custo de complementação térmica. Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Programação dinâmica Dados: Horizonte: k = 1, 2, …, N
Demanda no mês k: d(k) Afluência no mês k: a(k) Vazão turbinada máxima no mês k: p(k) Custo unitário da geração térmica no mês k: c(k) Volume mínimo do reservatório no mês k: m(k) Volume máximo do reservatório no mês k: M(k) Volume inicial do reservatório: V(1) = Vi Volume final do reservatório: V(N+1) = Vf Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Programação dinâmica Estágio: Estado: Decisão:
cada mês k = 1, 2, …, N do horizonte de planejamento Estado: volume x(k) do reservatório no mês k Decisão: vazão turbinada u(k) na usina hidráulica no mês k geração térmica t(k) no mês k calculada a partir de u(k) e d(k): t(k) = max {0,d(k)-produção(u(k))} Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Programação dinâmica Recursão: x(k+1) = x(k) + a(k) - u(k)
m(k)  x(k)  M(k) x(1) = Vi x(N+1) = Vf 0  u(k)  p(k) t(k) = max {0,d(k)-produção(u(k))} minimizar k=1,…,n c(k).t(k) Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Programação dinâmica Considerações: Não-linearidades
produção na usina hidráulica em função da vazão turbinada custo de complementação térmica Discretização dos volumes e das vazões turbinadas aumento do espaço de estados Outras variáveis de decisão vertimento v(k) no mês k: x(k+1) = x(k) + a(k) - u(k) - v(k) produção térmica no mês k: d(k) = produção(u(k)) + t(k) + deficit(k) aumento do espaço de decisões Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Programação dinâmica Considerações (continuação):
Múltiplos reservatórios estado do sistema descrito por um vetor de volumes aumento do espaço de estados “explosão combinatória” Demandas e/ou afluências não-determinísticas modelo de programação dinâmica estocástica Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Todos os caminhos mais curtos
G = (V, E) grafo orientado |V| = n Obter o valor do caminho mais curto entre cada par de nós Caminho mais curto de i a j: Se o caminho curto de i a j passa por k, então ele usa o caminho mais curto de 1 a k e o caminho mais curto de k a j. Cii = 0 Cij = +  (i,j) E Não há ciclos negativos R i j  ciclo Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Se k é o índice do nó de maior índice entre i e j, então o caminho mais cursto de i a k não passa por nenhum nó de índice maior do que k–1. Ak(i,j): comprimento do caminho mais curto de i a j passando por nenhum vértice de índice maior do que k. A(i,j): comprimento do caminho mais curto de i a j. Obter o caminho mais curto de i a j pode ser visto como a determinação do nó de maior índice que faz parte deste caminho. Em seguida, achar dois caminhos mais curtos: de i a j sem usar nós de índice maior do de k a j que k-1 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

A(i, j) = min {Cij,A’(i, j)} A’(i, j) = min {Ak-1(i,k) + Ak-1(k,j)}  k  n A0(i, j) = Cij O caminho mais curto de i e j não passando por um nó de índice maior do que k ou passa pelo nó k ou não: Se passa : Ak(i, j) = Ak-1(i,k) + Ak-1(k,j) Se não passa: Ak(i, j) = Ak-1(i,j) Ak(i, j) = min {Ak-1(i,k) + Ak-1(k,j), Ak-1(i,j)} A1, A2, A3, ..., An  A = An Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

para i = 1 até n faça para j = 1 até n faça a(i,j)  Cij para k = 1 até n faça ak(i,j)  min{ak-1(i,j), ak-1(i,k) + ak-1(k,j)} T(n) = O(n3) Exemplo: 1 2 3 6 4 11  C = Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

 A0 = A1 = A3 = A2 = Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Encadeamento ótimo do produto de matrizes
Seqüência de matrizes A1,A2, ..., An Parentetizar para definir a ordem em que as matrizes serão multiplicadas. Multiplicar as matrizes duas a duas segundo o algoritmo tradicional. Um produto de matrizes está completamente parentetizado se é uma matriz única se é o produto de duas matrizes completamente parentetizados envolvido por parênteses. (A1 (A2 (A3 A4) ) ) (A1 ( (A2 A3 ) A4 ) ) ( (A1 (A2 A3 ) ) A4 ) ( (A1 A2 ) (A3 A4 ) ) ( ( (A1 A2 ) A3 ) A4 ) Qual é a influência da ordem? Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Algoritmo A: r  q A  B  pqr operações B: q  r Exemplo: A1A2A3
Matrix_Multiply (A, B) se colunas(A)  linhas(B) então erro senão para i  1 até linha (A) faça para j  1 até coluna(B) faça C[i,j]  0 para k  1 até coluna(A) faça C[i,j]  C[i,j] + A[i,k]  B[k,j] retorne C A: r  q A  B  pqr operações B: q  r Exemplo: A1A2A3 A1: 10 x 100 A2: 100 x 5 A3: 5 x 50 ( (A1A2)A3) = 7.500 (A1(A2A3)) = Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro

Problema 221221 k n-k Parentetizar k = 1, 2, ..., n-1
Dada uma cadeia A1, ..., An de n matrizes, onde a matriz A, tem dimensões pi-1  pi, completamente parentetizar o produto A1, ..., An de forma a minimizar o mínimo de operações de multiplicações escalares. Número de parentetizações: P(n): números de alternativas para parentetizar completamente o produto de n matrizes. k n-k Parentetizar k = 1, 2, ..., n-1 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro 221221

Cálculo dos custo ótimos
Um problema para cada i, j satisfazendo 1  i  j  n Um algoritmo recursivo resolve o mesmo problema muitas vezes. Aproveitar a estrutura dos subproblemas que se recobrem para acelerar. problemas (pares) Em vez de recursividade  enfoque botton-up Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro 222222

Caracterização da estrutura de uma solução ótima
Parentetização ótima separa o produto entre Ak e Ak+1 para algum k=1, ..., n-1 Para algum k: A parentetização de A1  A2  ... Ak tem que ser ótima, assim como a de Ak An Ai...j = Ai ...Aj A1 ... k Ak+1... n custo total = custo custo Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro 223223

Princípio da otimalidade
 Solução recursiva Definir recursivamente o valor da função ótima em termos das soluções dos subproblemas. Subproblema: determinar o custo mínimo m[i,j] de parentetizar Ai Ai+1...Aj para 1  i  j  n custo ótimo : m[1,n] Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro 224224

m[i,j] = ? i = j: a cadeia é formada por uma só matriz  m[i, j] = 0 i < j: usar a estrutura de uma solução ótima Hipótese: a parentetização de Ai...j separa a cadeia entre Ak e Ak+1 onde i  k < j. Então: m[i,j] = m[i,k] + m[k+1, j] + Pi-1  Pk  Pj Ai...k  Ak+1 ...j Pi-1 Pk Pk  Pj Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro 225225

k pode assumir valores entre i e j-1. Logo, m[i, j] = onde i  k < j S[i, j] = valor de k onde deve ser separado o produto Ai ...Aj S[i, j] = k tal que m[i,j] = m[i,k] + m[k+1, j] + Pi-1  Pk  Pj 0, min m[i,k] + m[k+1, j] + Pi-1  Pk  Pj i = j i < j i  k  j Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro 226226

227227 Algoritmo Recursive_ Matrix_Chain(P, i, j) se i=j então
retorne 0 m[i, j]   para k  1 até j-1 faça q  Recursive_ Matrix_Chain(P, i, k) + Recursive_ Matrix_Chain(P, k+1, j) + Pi-1  Pk  Pj se q < m[i, j] então m[i, j]  q retorne m[i, j] Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro 227227

228228 Complexidade n = 1 n > 1 T(K) T(n-k) i = 1, 2, ..., n-1 T(i)
Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro 228228

1...4 1...1 2...4 1...2 3...4 1...3 4...4 2...2 3...4 2...3 4...4 1...1 2...2 3...3 4...4 1...1 2...3 1...2 3...3 3...3 4...4 2...2 3...3 2...2 3...3 1...1 2...2 i  k  j Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro 229229

Preencher a matriz m como resolvendo-se o problema de parentetização em matrizes cujo comprimento aumenta: m[i, j] = onde i  k  j 0, min m[i,k] + m[k+1, j] + i = j i < j Pi-1  Pk  Pj calcular o produto de j-i+1 matrizes depende apenas do custo de processar produtos de menor de j-i+1 matrizes m[i, j]  0 Em seguida: m[i, i+1] i = 1, 2, ..., n-1 custos mínimos para cadeias de l =2 matrizes Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro 230

Matriz A: tem dimensões Pi-1  Pi A entrada é uma seqüência (P0, P1, ..., Pn) = P de comprimento n+1 Matrix_Chain_Order(P) n  length(P) - 1 para i  1 até n faça m[1, i]  0 para l  2 até n faça para i  1 até n-l+1 faça j  i + l – 1 m[i, j]   para k  i até j-1 faça q  m[i, k] + m[k+1, j] + Pi-1  Pk  Pj se q < m[i, j] então m[i, j]  q s[i, j]  k retorne m, s Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro 231

Exemplo 1 2 3 4 5 6 m A1 A2 A3 A4 A5 A6 15.125 j i A1 = 30 x 35 A4 = 5 x 10 A2 = 35 x 15 A5 = 10 x 20 A3 = 15 x A6 = 20 x 25 T(n) = O(n3) Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro 232

Exemplo s 6 1 3 5 2 j i 3 4 3 3 3 4 1 3 5 2 5 1 2 3 4 5 A[1, 6] = 3  (A1 A2 A3) (A4 A5 A6) A[1, 3] = 1 A[4, 6] = 5 ( (A1 ( A2 A3) ) ( (A4 A5 ) A6) ) Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro 233

234234 Algoritmo Lookup_Chain(P, i, j) se m[i, j] <  então
retorne m[i, j] se i = j então m[i, j]  0 else para k  i até j-1 faça q  Lookup_Chain(P, i, k) + Lookup_Chain(P, k+1, j) + Pi-1  Pk  Pj se q < m[i, j] então m[i, j]  q Cada m[i, j] é preenchido em uma chamada a Lookup_Chain. Cada Chamada é O(n)  T(n) = O(n3) Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro 234234

Algoritmo Será que é possível melhorar o algoritmo recursivo, mantendo uma tabela com as soluções dos problemas ? No início, a tabela tem um flag para dizer que os valores não foram processados. Hipótese: o conjunto de todos os possíveis subproblemas é conhecido, assim como a correspondência entre posição na tabela e subproblemas. Matrix_Chain_2(P) n  length [P] – 1 para i  1 até n faça para j  1 até n faça m[i, j]   retorne Lookup_Chain (P, 1, n) Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro 235235

Exemplo 1...4 1...1 2...4 1...2 1...3 2...2 3...4 2...3 4...4 3...3 4...4 2...2 3...3 i  k  j Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro 236236

Exemplo 1...4 1...1 2...4 1...2 1...3 2...2 3...4 2...3 4...4 3...3 4...4 2...2 3...3 i  k  j Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro 237237

Exemplo 1...4 1...1 2...4 1...2 1...3 2...2 3...4 2...3 4...4 3...3 4...4 2...2 3...3 Nós: T(n) = O(n2) Sucessores/nó: T(n) = O(n) i  k  j Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro 238238

239 Algoritmo Matrix_Chain_Multiply(A, s, i,j) se j > i então
x  Matrix_Chain_Multiply (A, s, i, s[i,j]) y  Matrix_Chain_Multiply (A, s, s[i,j]+1, y) retorne Matrix_Multiply(x, y) senão retorne A Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro 239

Subseqüência mais longa
X = (x1, x2, ..., xn) Z = (z1, z2, ..., zn) Z é uma subseqüência de x se existe uma subseqüência crescente (i1, i2, ..., ik) de índices de x tais que para todos J = 1, 2, ..., k Xij = Zj Exemplo: X = (A, B, C, B, D, A, B) Y = (B, C, D, B) Dados 2 seqüências X e Y, diz-se que Z é uma subseqüência comum de X e Y se Z é uma subseqüência de X e de Y. X = (A B C B D A B) Y = (B D C A B A) SML = (B C B A) (B D A B) Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro 240

Força bruta: X: m elementos  2m subseqüências exponencial Teorema: X = (x1, x2, ..., xm) Y = (y1, y2, ..., yn) Z = (z1, z2, ..., zk) SML (x, y) Então: se Xm = Yn, então Zk = Xm = Yn e Zk-1 é uma SML de Xm-1 e Ym-1 se Xm  Yn, então: Zk  Xm  Z = SML (Xm-1 , Y) Zk  Yn  Z = SML (X , Yn-1) Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro 241

Uma SML contém uma SML de prefixos das duas seqüências. Obter a SML se traduz em examinar um ou dois subproblemas: Xm = Yn,  obter SML (Xm-1 , Yn-1) Xm  Yn,  obter SML (Xm-1 , Y)  obter SML (X , Yn-1) estes dois subproblemas exigem a solução de SML (Xm-1 , Yn-1) Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro 242

Recorrência 243 c[i, j] = comprimento de SML (xi, yi)
i = 0 ou j = 0  c[i, j] = 0 c[i, j] = 0, i = 0 ou j = 0 c[i-1, j-1] + 1, i, j > 0 xi = yj c[i, j-1], max i, j > 0 xi  yj c[i-1, j] Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro 243

Algoritmo recursivo: exponencial
Há apenas m-n subproblemas distintos  P.D c[0...m, 0...n]  calculada linha a linha da esquerda para a direita. b[i, j]  tabela auxiliar aponta para a entrada da tabela correspondente à solução do subproblema ótimo escolhido durante o calculo de c[i, j] Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro 244

Exemplo 245 1 2 3 4 5 6 yi B D C A Xi 0  1  1  1  2  2  2  3 
1 2 3 4 5 6 yi B D C A Xi 0  1  1  1  2  2  2  3  3  3  4  7 4  Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro 245

Exemplo 246 1 2 3 4 5 6 yi B D C A Xi 0  1  1  1  2  2  2  3 
1 2 3 4 5 6 yi B D C A Xi 0  1  1  1  2  2  2  3  3  3  4  7 4  Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro 246

Algoritmo 247 SML(X, Y) m  compr [x] n  compr [y]
para i  1 até m faça c[i, 0]  0 para j  1 até n faça c[0, j]  0 para i  1 até m faça para j  1 até n faça se xi = yj então c[i, j]  c[i-1, j-1] + 1 b[i, j]   senão se c[i-1, j]  c[i, j-1] então c[i, j]  c[i-1, j] b[i, j]   senão c[i, j]  c[i, j-1] b[i, j]   retorne c, b j j i -1 i T(n) = O(m · n) Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro 247

Programação dinâmica estocástica
Jogo: Tabuleiro dividido em três regiões de mesma área Ficha lançada sobre o tabuleiro Regiões I, II, III equiprováveis Se a ficha cair na região I, o jogador escolhe entre as roletas A e B A: I  I p = ¼ l = 2 I  II p = ¾ l = 4 Região II : roletas C e D Região III: roletas E e F I II III Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro 248

1/ 1/4 12 1/4 0 B 1/2 10 C I II B 3/4 4 D 1/6 0 1/4 36 1/2 10 E F III 3/4 12 5/6 6 1/2 16 Três jogadas Qual roleta escolher a cada rodada? Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro 249

6 A 1/4 · /4 · 4 = 6 I A I B 5 I I B 10 II C 1/6 · 0 + 5/6 · 6 = 5 II II III D 9 15 E K = 2 K = 3 III III F 13 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro 250

6 A 1/4 · /4 · 4 = 6 I A I 6 B 5 I I B 10 II C 1/6 · 0 + 5/6 · 6 = 5 II II 10 III D 9 15 E K = 2 K = 1 III III 15 F 13 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro 251

12 A 6 6 I I B 4 C 10 10 II II D I: A 1/4 · (12 + 6) + 3/4 · (4 + 10) = 15 I: B 1/6 · () + 6) + 5/6 · (6 + 15) = 18.5 E 15 III III K = 1 F Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro K = 0 252

15 12 A 6 6 I I B 18.5 4 18 C 10 10 II II 22.8 D I: A 1/4 · (12 + 6) + 3/4 · (4 + 10) = 15 I: B 1/6 · () + 6) + 5/6 · (6 + 15) = 18.5 27.8 E 15 III III K = 1 K = 2 F Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro 25.5 253

Lucro esperado 254 27.7 A 18.5 I I 31.2 B C 30.6 22.8 II II 35.3 D E
K = I – B II – D III – E I I 31.2 B K = I – B II – D III – E C 30.6 22.8 II II 35.3 D K = I – A II – C III – E E 40.5 27.8 III III 38.3 F Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro 254

Lucro esperado 255 Lucro esperado:
PPD pode ter alguns elementos determinísticos, tais como o estado inicial ou o resultado de algumas decisões. PPD: uma mudança de estado envolve duas fases decisão resultado aleatório de decisão tomada Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro 255

Qual o maior ganho que pode ser obtido com esta estratégia?
54 42 12 I I I I A 12 B B 6 D 12 E 36 8 6 4 5/96 5/24 1/4 10 60 48 10 II II II II D C 10 12 12 3/64 3/16 1 36 36 78 E E 48 36 8 8 III III III III 5/96 1/16 1/4 Lucro máximo = 78 probabilidade = 1/3 + 5/96 = 5/288 Lucro mínimo = 4 probabilidade = 1/144 Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro 256

Solução: conjunto de decisões ótimas para cada estágio {decisões ótimas}: estratégia ótima Estratégia ótima: Lucro/ganho esperado ótimo = Maior e menor ganho possíveis com estratégia ótima? Probabilidadaes? Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro 257

Como joga um jogador que se considera
Completamente azarado ? (conservador) Completamente sortudo ? (arriscado) Setembro 2004 Projeto e Análise de Algoritmos - Celso Carneiro Ribeiro 258

Técnicas de projeto de algoritmos

Apresentações semelhantes

Apresentação em tema: "Técnicas de projeto de algoritmos"— Transcrição da apresentação:

Apresentações semelhantes

Sobre projeto

Feedback

Login

Autorizar-se através da rede social:

Técnicas de projeto de algoritmos

Apresentações semelhantes

Apresentação em tema: "Técnicas de projeto de algoritmos"— Transcrição da apresentação:

Apresentações semelhantes

Sobre projeto

Feedback