Programação Dinâmica Partição de Inteiros

Transcrição

1 Notas de aula da disciplina IME -8 ALGORITMOS E ESTRUTURAS DE DADOS II Paulo Eustáquio Duarte Pinto (pauloedp arroba ime.uerj.br) abril/9 Partição de Inteiros Dado n inteiro, determinar o número de maneiras de particionamento de n. Exemplo : n = Exemplo : n = 6 maneiras distintas: maneiras distintas: Partição de Inteiros Formulação recursiva: dado n, T(n, p) = número de partições onde a maior parcela p T(n, p) =, se (n < ) ou (n > e p = ) T(n, p) =, se (n = ) T(n, p) = T(n p, p) + T(n, p - ), n >, p > Procura-se obter T(n, n). Pode-se implementar a recursão com memorização. Partição de Inteiros T(n, p) =, se (n < ) ou (n >, p = ) T(n, p) =, se (n = ) T(n, p) = T(n p, p) + T(n, p - ), n >, p > Quer-se obter T(n, n). A idéia da programação dinâmica é evitar a recursão, de forma análoga à memorização, mas calculando, de forma bottom-up, todos os subproblemas menores do que o problema a ser solucionado. Por forma bottom-up deve-se entender que a solução dos subproblemas deve ser feita por ordem de tamanho, dos menores para os maiores. Neste caso, é possível usar a idéia da PD! Partição de Inteiros T(n, p) =, se (n < ) ou (n >, p = ) T(n, p) =, se (n = ) T(n, p) = T(n p, p) + T(n, p - ), n >, p > Quer-se obter T(n, n). Para implementar PD, calcular T(n, p) em ordem crescente por n e p, começando por qualquer um dos dois parâmetros. Partição de Inteiros T(n, p) =, se (n < ) ou (n >, p = ) T(n, p) =, se (n = ) T(n, p) = T(n p, p) + T(n, p - ), n >, p > Algoritmo (por linha): Partição(): para p até n incl.: T[, p] para i até n incl.: T[i, ] para p até n incl.: se (i p): T[i, p] T[i, p-] + T[i-p, p] senão: T[i, p] T[i, p-] Complexidade: O(n )

2 Partição de Inteiros T(n, p) =, se (n < ) ou (n >, p = ) T(n, p) =, se (n = ) T(n, p) = T(n p, p) + T(n, p - ), n >, p > Algoritmo (por coluna): Partição(): T[,] para i até n incl.: T[i, ] para p até n incl.: para i até n incl.: se (i p): T[i, p] T[i, p-] + T[i-p, p]; senão: T[i, p] T[i, p-] Partição de Inteiros Cálculo de T(, ) 6 Partição de Inteiros ExS Completar a tabela abaixo, para n = 6 Partição de Inteiros Exercício - Solução Completar a tabela abaixo, para n = Dados os tipos de moedas de um país, determinar o número de maneiras distintas para dar um troco de valor n. Exemplo: V = {,,,,,} m = 6 n = 6 Há maneiras distintas:,,,,,,...,,,,,,,...,,...,...,,,,,,,,,...,,,...,,..., Formulação recursiva: dados m, n T(p, n) = formas distintas de dar um troco n, usando os p tipos iniciais de moedas, V[]...V[p] T(p, n) =, (n < ) T(p, n) =, (n = ) T(p, n) = T(p, n V[p]) + T(p-, n), (n > ) A solução do problema é obter T(m, n). Observe que a formulação é a mesma feita no estudo de memorização.

3 Exemplo: V = {,,,,,} m = 6 n = 6 Há maneiras distintas: T(,6) =T(,)+...=+.., T(,6)=T(,6)+...=6+..,,,,,...,,,,,,,...,,...,... T(,6)=T(,) +,,,=,,,,, = +...,,,,..,,,..,,..,.. =T(,6) =,... Exemplo: V = {,,,,, } m = 6, n = A solução por PD consiste em preencher a tabela m x n por ordem crescente do tamanho dos subproblemas, sem necessidade de recursão. Há duas formas de fazer isso: + ou + Ex. da a forma: V = {,,,,, } Exercício: Completar a tabela abaixo para n = V = {,, } ExS: Preencher a tabala para n = T(p, n) =, (n < ) ou (p = ) T(p, n) =, (n = ) T(p, n) = T(p, n V[p])+T(p-,n), (n > ) Algoritmo, com preenchimento linha x coluna: (): para i até m incl.: T[i, ] para j até n incl.: se j > V[i]: T[i,j] T[i,j] + T[i,j-V[i]] senão T[i, j] se i > T[i, j] T[i,j] + T[i-, j] Complexidade: O(n.m)

4 PD x Memorização V = {,,,,, } Formulação recursiva: dados m, n T(p, n) = formas distintas de dar um troco n, usando os p tipos iniciais de moedas, V[]...V[p] T(p, n) =, (n < ) T(p, n) =, (n = ) T(p, n) = Σ T(i, n V[i]), (n > ), i p A solução do problema é obter T(m, n). Observe que a formulação é diferente daquela feita no estudo de memorização. Exemplo: V = {,,,,, } m = 6, n = Mochila (/) Dada uma mochila com capacidade M e t ítens com peso w i cada, verificar se existe uma combinação de itens que preencha exatamente a mochila. Exemplo: Dado o conjunto de ítens {,,, 9, }, é possível preencher exatamente mochilas com capacidades e, mas não é possível preencher mochila com capacidade 6. Mochila (/) Define-se K(q, n) = x = indicador de solução quando se usa os q itens iniciais numa mochila de capacidade n. x =- não há solução, cc indica o menor índice de ítem que que completa a mochila. Formulação recursiva: K(q, ) =, K(, n) = -, se n >, K(q, n) = K(q-, n), se K(q-,n) -, n M; q t; K(q, n) = q, se K(q-, n-p q ) -, n M; q t; K(q, n) = -, nos demais casos Mochila (/) K(q, ) =, K(, n) = -, se n >, K(q, n) = K(q-, n), se K(q-,n) -, n M; q t; K(q, n) = q, se K(q-, n-p q ) -, n M; q t; K(q, n) = -, nos demais casos Algoritmo: Mochila(): K[, ] para j até M incl.: K[, j] - para i até t incl.: para j até M incl.: se (K[i-, j] -): K[i, j] K[i-, j] senão Se ((j P[i]) e (K[i-, j-p[i]] -)): K[i, j] i senão K[i, j] - Complexidade: O(t.M)

5 Mochila (/) Exemplo: P= {,,, 9, } M = Obs: - não representado () Mochila (/) P = {,,, 9, } ExS: Completar a tabela abaixo para M = () Mochila (/) Apresentação de uma solução Solução(): j M enquanto (j ): escrever (P[K[t, j]]) j j - P[K[t,j]] Para M =, a saída seria: 9 () () (9) () () () (9) () () () () (9) () Mochila (/) P = {,,, 9, } Exercício: Encontrar a solução para M = Mochila (/) outras versões a) usar dois valores booleanos em cada célula, o primeiro indicando se há solução e o segundo se o ítem atual é o de menor índice para a solução Exemplo: P = {,,, 9, } M = Obs: célula em branco com (F,F) Mochila (/) outras versões b) usar um vetor ao invés de uma matriz Exemplo: P = {,,, 9, } M = () () () (9) () () () () (9) () VF VF VV VF VV VF VV VF VF VV VF VV VF VV VV VF VF VF VF VF VV VF VF VV VF VV VV VV VF VF VF VF VF VF VF VF VF VF VF VF VV VF VV Algoritmo: Mochila(): K[] para j até M incl.: K[j] - para i até t incl.: para j M..P[i] incl.: se ((K[j] = -) e (K[j-P[i]] )): K[j] i

6 Mochila (/) outras versões b) usar um vetor ao invés de uma matriz Exemplo: P = {,,, 9, } M = Exercício: mostrar a situação do vetor acima após o processamento de cada ítem, a partir da situação inicial: Mochila (/) outras versões ExS: mostrar a situação do vetor para o problema mochila para M =, e ítens: {,,,, 6}: Mochila (/) outras versões b) usar um vetor ao invés de uma matriz Problema Ferry Loading (Val 6) Tem-se um ferry de comprimento lf, duas linhas para carros e uma fila dada de carros, com seus comprimen-tos lc i. Quer-se saber quantos carros podem ser carregados, obedecendo-se a fila. Dados: n carros de comprimentos lc i dados e o ferry com comprimento lf. lf = 9 Fila:,,,,,,, Sol: (/, /, /, /, /) Mochila (/) outras versões b) usar um vetor ao invés de uma matriz Problema Ferry Loading (Val 6) Tem-se um ferry de comprimento lf, duas linhas para carros e uma fila dada de carros, com seus comprimentos lc i. Quer-se saber quantos carros podem ser carregados, obedecendo a fila. lf = 9, lc = (,,,,,,, ) tot SIT V V V - - V - - V F Mochila (/) outras versões Problema Ferry Loading (Val 6) - Escolha dos carros Algoritmo: FerryLoading(): K[*] -; K[] ; F[*] ; i ; lotado F; tot ; enquanto ((i t) e (não lotado)): tot tot + lc[i]; lotado V; para j lf..lc[i] incl.: se ((K[j-lc[i]] > -) e ((tot-j) lf)): lotado F; F[i] ; se (K[j] = -): k[j] i; i i+; Mochila (/) outras versões Problema Ferry Loading (Val 6) - Determinação das filas Solução(): i lf enquanto (K[i] = -): i i-; enquanto (i > ): j K[i]; F[j] ; Vetor K Vetor F i i-lc[j]; SIT - - F i 6 8 9

7 Mochila (/) outras versões c) contar o número de soluções Exemplo: P = {,,,, } M = Mochila (/) outras versões c) contar o número de soluções Algoritmo: Mochila (/) outras versões ExS6: mostrar o preenchimento do vetor para contar o número de soluções para M =, e ítens: {,,,,6}: ContaSoluçõesMochila(): K[] para j até M incl.: K[j] para i até t incl.: para j M..P[i] incl.: K[j] K[j] + K[j-P[i]] TESTE : SOLUÇÕES DA MOCHILA Escrever a recorrência para contar o número de soluções distintas da Mochila, K(p, q) Mochila (/) outras versões d) contar o número de itens na solução Exemplo: P = {,,, 9, } M = Mochila (/) outras versões d) contar o número de itens na solução Exemplo: P = {,,, 9, } M = Algoritmo: Algoritmo: ContaSoluçõesMochila(): K[] para j até M incl.: K[j] para i até t incl.: para j M..P[i] incl.: K[j] K[j] + K[j-P[i]] ExS6: M =, e ítens: {,,,,6}: ContaItensMochila(): K[,] para j até M incl.: K[,j] - para i até t incl.: para j até M incl.: K[i,j] - para r i.. incl.: para j P[i] até M incl.: se ((K[r, j] = -) e (K[r-,j-P[i]] )): K[r, j] i

8 Mochila (/) outras versões d) contar o número de itens na solução Problema Tug of War (Val ) Tem-se n competidores, e são dados os pesos de cada um. Quer-se dividir as pessoas em dois times tal que o número de competidores difira no máximo em e a soma dos pesos deve ser mínima. Indicar os pesos de cada grupo. Dados: n = 9 Pesos:, 6,, 8, 9,,, 66, 8 Sol: (,,,,,,,, ) Mochila (/) outras versões d) contar o número de itens na solução Problema Joys of Farming (Val ) Tem-se n casas, cada uma com quartos, em cada quarto um número variável de camas. Quer-se distribuir m moças e r rapazes pelas casas, tal que em cada quarto só tenha ou moças ou rapazes e não podendo os dois quartos de uma mesma casa serem ocupados pelo mesmo sexo. É possível fazer a distribuição? Dados: n =, m =, r = Quartos: /8, /6, /, 6/, / Sol: S (moças:, 6,, 6, rapazes: 8,,,, ) Mochila (/) - ExS: mostrar o preenchimento da matriz para mostrar o número de ítens na solução M =, e ítens: {,,,,6}: Mochila (/) outras versões e) Mochila com peso e valor: a cada ítem, além do peso(p) é associado um valor(v). O objetivo passa a ser determinar o valor máximo que pode comportar a mochila Ex: P = {(,), (,), (,), (9,), (,)} M = Mochila (/) outras versões Peso e Valor Ex: P = {(,), (,), (,), (9,), (,)} M = Mochila (/) outras versões Peso e Valor e) Mochila com peso e valor: a cada ítem, além do peso(w) é associado um valor(v). O objetivo passa a ser determinar o valor máximo que pode comportar a mochila Ex: P, V = {(,), (,6), (,), (9,), (,)} M = MochilaPesoeValor(): K[].me ; K[].vm ; para j até M incl.: K[j].me -; K[j].vm ; para i até t incl.: para j M..P[i] incl.: se ((K[j-P[i]].me ) e (K[j].vm < (K[j-P[i]].vm+V[i]))): K[j].me i; K[j].vm K[j-P[i]].vm+V[i]; Obs: K[j].me = menor índice que obtém o valor máximo K[j].vm = valor máximo

9 Mochila (/) outras versões - Peso e Valor ExS8: mostrar a situação do vetor para os seguintes ítens, M =. Ex: P, V = {(,), (,), (,), (,)} M = Mochila (/) outras versões - Peso e Valor f) Mochila múltiplos itens: existem infinitos objetos de cada tipo de ítem Ex: P = {,,, 9, } M = Mochila outras versões f) Mochila múltiplos itens: existem infinitos objetos de cada tipo de ítem Ex: P = {,,, 9, } M = MochilaItensMultiplos(): K[] para j até M incl.: K[j] - para i até t incl.: para j P[i] até M incl.: se ((K[j-P[i]] ) e (K[j] = -)): K[j] i; Mochila outras versões g) Mochila com múltiplos itens, cada um com peso e valor: a cada ítem, além do peso(p) é associado um valor(v). O objetivo passa a ser determinar o valor máximo que pode comportar a mochila Ex: W = {(,), (,6), (,), (9,), (,)} M = (valores da versão /) Mochila outras versões g) Mochila com múltiplos itens, cada um com peso e valor: a cada ítem, além do peso(w) é associado um valor(v). O objetivo passa a ser determinar o valor máximo que pode comportar a mochila Ex: P, V = {(,), (,6), (,), (9,), (,)} M = MochilaItensMultiplosPesoeValor(): K[].me ; K[].vm ; para j até M incl.: K[j].me -; K[j].vm ; para i até t incl.: para j P[i] até M incl.: se ((K[j-P[i]].me ) e (K[j].vm < (K[j-P[i]].vm+V[i])): K[j].me i; K[j].vm K[j-P[i]].vm+V[i]; Mochila (/) Ítens múltiplos ExS9: mostrar a situação do vetor para os seguintes ítens, M =, Ex: P, V = {(,), (,), (,), (,)} M = a) Sem considerar o valor b) Considerando o valor

10 Mochila outras versões h) Mochila com ítens fracionáveis: cada ítem pode ser fracionado. Será visto adiante (Guloso) i) Mochila mista: parte dos itens não fracionáveis e parte fracionáveis. Será visto adiante (PD+Guloso) Mochila PD x Backtracking -Muitos itens pequenos S = {,,,, 9,, 6,,, 8,,,,,,,,,,, } é melhor PD -Poucos itens grandes S = {., 9.99,.,., 899.6,..,..6.86,.99..} é melhor BK Problemas com paradigma da "diagonal" Alguns problemas com solução por PD requerem que se examine todos os subproblemas relativos a intervalos consecutivos de um vetor, ou seja intervalos (,), (,)...(,n),(,)...(n-,n)(n,n). Neste caso, o resultado ótimo para cada intervalo (i,j), com j i é guardado na célula (i,j) de uma matriz M n x n, que geralmente é preenchida por diagonais, onde cada diagonal representa dada diferença de índices j-i, dos diversos intervalos. Só é preenchido o "triângulo" superior da matriz, Problemas apresentados são: Produto de Matrizes e Jogo da Soma. x x x x x x Produto de Matrizes Dada uma sequência de matrizes que devem ser multi-plicadas, determinar a ordem ótima de multiplicação (aquela que requer o menor número de operações), considerando que o produto é associativo. Exemplo: M ( x ) M ( x ) M ( x ) M ( x ) O produto pode ser feito de inúmeras maneiras, dentre as quais: ((M x M ) x (M x M )) (M x ((M x M ) x M )) Produto de Matrizes Associatividade M (a x b) x M (b x c) x M (c x d) a) ((M x M ) x M ) = M (a x d), (M x M ) = M (a x c) M ij = Σ k c M ik x M kj = Σ k c (Σ t b M it x M tk,) x M kj = Σ k c Σ t b M it x M tk x M kj b) (M x (M x M )) = M (a x d), (M x M ) = M 6 (b x d) M ij = Σ t b M it x M 6tj = Σ t b M it (Σ k c M itk x M kj ) = Σ k c Σ t b M it x M tk x M kj Produto de Matrizes Quantidade de operações M (a x b) x M (b x c) a x b x c produtos a x (b-) x c somas Produto de Matrizes Mais de duas matrizes M ( x ) M ( x ) M ( x ) M ( x ) a) ((M x M ) x (M x M )) x x + x x + x x = = b) (M x ((M x M ) x M )) x x + x x + x x = =

11 Produto de Matrizes Formulação recursiva Vetor de dimensões: M i (r i- x r i ) n r r r r n T[i, j] = núm. mínimo de operações p/ obter M i... M j T[i, j] = min i k <j {T[i, k]+t[k+,j] + r i- x r k x r j } T[i, i] = Produto de Matrizes Implementação com PD M M M M A idéia é calcular os produtos ótimos M i... M j em ordem crescente da diferença j i: T[,], T[,], T[,], T[,] T[,], T[,], T[,] T[,], T[,] T[,], a solução buscada! Produto de Matrizes Implementação com PD M M M M j i = Produto de Matrizes Implementação com PD M M M M j i = Produto de Matrizes Implementação com PD M M M M j i = Produto de Matrizes Implementação com PD M M M M j i = T[,] k = T[,]+T[,]+r.r.r = =. k = T[,]+T[,]+r.r.r = = T[,] k = T[,]+T[,]+r.r.r = =. k = T[,]+T[,]+r.r.r = =.

12 Produto de Matrizes PD - j i = M M M M T[,] k = T[,]+T[,]+r.r.r = =. k = T[,]+T[,]+r.r.r = =. k = T[,]+T[,]+r.r.r = = 8. Produto de Matrizes PD - Solução Custo Melhor k Multiplicação ótima: ((M x (M x M )) x M ) Produto Matrizes T[i, j] = min{t[i, k]+t[k+,j] + r i- x r k x r j } i k <j T[i, i] = Quer-se encontrar T[, n]. ProdutoMatrizes(): para k até n incl.: T[k, k] para d até n- incl.: para i até n-d incl.: j i + d; T[i, j] ; para k i até j- incl.: se ((T[i, k] + T[k+, j] + r[i-].r[k].r[j]) < T[i, j]): T[i, j] T[i, k] + T[k+, j] + r[i-].r[k].r[j]; MK[i, j] k; Complexidade: O(n ) Produto de Matrizes M M M M ExS: Calcular a pior maneira de multiplicar as matrizes acima. Produto Matrizes Impressão da expressão: baseada em uma recorrência sobre a matriz MK Algoritmo: String Expressao(i,j): se (i = j): retornar 'M' + i senão: retornar '(' + Expressao(i,MK[i,j])+ 'x' + Expressao(MK[i,j]+,j) + ')'; Jogo da Soma Dado um vetor V contendo inteiros, determinar ao melhor resultado para o seguinte jogo: os jogadores retiram, em turnos, quantos elementos quiserem do vetor, desde que seja de uma das pontas. A solução é maximizar a diferença entre os dois jogadores, levando em conta que os dois jogam de maneira ótima. Para o vetor abaixo, a maior diferença possível é : o primeiro retira e ; o segundo retira, o primeiro retira - e o segundo -, com a diferença (+-)-(-) =. - -

13 Jogo da Soma - Recorrência M(i,i) = V(i) M(i,j) = max( Ac(i,j), Ac(i,k) - M(k+,j), i k <j, Ac(k,j) - M(i, k-), i< k j, ) O primeiro termo da maximização corresponde à retirada de todos os números i a j; o segundo, às retiradas da ponta esquerda e o trceiro, às retiradas da ponta direita do vetor. Alagoritmo para p Jogo da Soma JogodaSoma(): para k até n incl.: T[k, k] V[k] VA[] para k até n incl.: VA[k] VA[k-]+V[k] para d até n- incl.: para i até n-d incl.: j i + d; T[i, j] VA[j]-VA[i-]; MI[i, j] (i, j); para k i até j- incl.: se ((T[i, j] < (VA[k]-VA[i-]-T[k+,j])): T[i, j] VA[k]-VA[i-]-T[k+,j] MI[i, j] (i, k) para k i+ até j incl.: se ((T[i, j] < (VA[j]-VA[k-]-T[i, k-])): T[i, j] VA[j]-VA[k-]-T[i,k-] MI[i, j] (k, j) Jogo da Soma - Exemplo: V x - x x x x x x x x x Diagonal de diferença de índices= Jogo da Soma - Exemplo: Jogo da Soma - Exemplo: Jogo da Soma - Exemplo: V x - 6 x x x x x x x x x Diagonal de diferença de índices= M(,) = max(-6, --(-), --(-)) = M(,) = max(-, --(), -(-)) =6 M(,) = max(, -(), -()) = M(,) = max(, -(), -()) = V x - 6 x x x x x x x x x Diagonal de diferença de índices= M(,) = max(-, --(6), -6-(), -(), --(-) =- M(,) = max(-, --(), --(), -(6), -(-)) = M(,) = max(, -(), -(), -(), -()) = V x x x x x x x x x x Diagonal de diferença de índices= M(,) = max(-, --(), -6-(),--(), -(-),-(), --(-))= M(,) = max(-, --(), --(), --(), -(),-(6),-(-)) =8

14 Jogo da Soma - Exemplo: V x x x x x x x x x x Diagonal de diferença de índices= M(,) = max(-, --(8), -6-(), --(),--(), -(), -(-), -(), -(-)) = Jogo da Soma - Exemplo: V - - Maior diferença - - x x x x x x x x x x Melhor intervalo x x x x x x - - x x x x - Distância de Edição Dados dois strings A e B, quer-se determinar a menor sequência de operações p/ transformar A em B. Os tipos de operação são: -inserção de um caracter -deleção de um caractér -substituição de um caractér Exemplo: ERRO transforma-se em ACERTO mediante operações: -inserção do A AERRO -inserção do C ACERRO -substituição do R ACERTO Distância de Edição - Formulação recursiva Dados os substrings A i (primeiros i caracteres) e B j, D(i, j) = distância de edição entre A i e B j = D(i-, j-), se a i = b j min(d(i-, j), D(i, j-), D(i-, j-)) +, se a i b j Deleção de a i Inserção de b j Substituição de a i por b j Cálculo da Distância de Edição A C E R T 6 O 6 E R R O Distância de Edição D(i, j) = D(i-, j-) =, se a i = b j min(d(i-, j), D(i, j-), D(i-, j-)) +, se a i b j DistânciaEdição(): #Dados: Strings A e B, com A = n e B = m para i até n incl.: D[i, ] i para j até m incl.: D[, j] j para i até n incl.: para j até m incl.: se (A[i] = B[j]): D[i, j] D[i-, j-] senão: D[i, j] min(d[i-, j-], D[i-, j], D[i, j-])+ Complexidade: O(n.m)

15 Distância de Edição - Apresentando a transformação A C E R T 6 O 6 E R R O Distância de Edição - Apresentando a transformação M A R R O 6 M 6 A M O R A Distância de Edição - Apresentando a transformação Transf(i,j): #Dados Matriz de distâncias D, Strings A e B se ((i>) ou (j>)): se (A[i] = B[j]): Transf(i-,j-); escrever 'Manteve' A[i]; senão se ((j > ) e D[i,j] = D[i,j-]+): Transf(i,j-); escrever 'Inseriu' B[j]; senão se ((i > ) e D[i,j] = D[i-,j]+): Transf(i-,j); escrever 'Deletou' A[i]; senão: Transf(i-,j-) escrever 'Transformou' A[i] 'em' B[j] Transf(n,m) Distância de Edição ExS: Determinar a distância de edição do seu ALSTRING(8 letras iniciais do nome) para o do colega. Mostrar duas transformações mínimas do primeiro string para o segundo. Exercício - a) Resolver intuitivamente o seguinte problema: Qual o valor máximo possível da soma dos números obtidos pela concatenação dos dígitos do particionamento do vetor de dígitos em segmentos consecutivos de a dígitos? Exercício - b) Escrever uma recorrência para o problema: Qual o valor máximo possível da soma dos números obtidos pela concatenação dos dígitos do particionamento do vetor de dígitos em segmentos consecutivos de a dígitos?

16 Exercício - c) Escrever um algoritmo de PD para o problema: Qual o valor máximo possível da soma dos números obtidos pela concatenação dos dígitos do particionamento do vetor de dígitos em segmentos consecutivos de a dígitos? Exercício - d) Escrever um algoritmo de PD para o problema: Qual a maneira de particionar um vetor de dígitos em partições de a dígitos, tal que a soma dos números resultantes da concatenação dos dígitos de cada partição seja máxima? Exercício - a) Escrever a recorrência que indica o número de caminhos mínimos distintos entre os pontos (,) e (n,m) em um grid de dimensões n x m, onde há obstáculos em alguns pontos de cruzamento (no máximo n- obstáculos)., ,6 Exercício b) Escrever um algoritmo de PD para a formulação anterior., Exercício c) Mostrar o preenchimento da matriz para o exemplo abaixo., Exercício - a) Escrever a recorrência que indica o número mínimo de quadrados, T(a,b) que podem ser obtidos com cortes transversais em uma chapa de dimensões a x b. Exemplo: a =, b=6,6,6

17 Exercício - Exercício - b) Escrever um algoritmo de PD para o problema descrito. Exemplo: a =, b=6 c) Preencher a matriz 6 x 6 relativa ao exemplo. Exemplo: a =, b=6 FIM