SCC211 Cap 11

Paradigmas de Resoluo de Problemas Programao Dinmica
SCC-211 - Captulo 11 Programao Dinmica

Joo Lus Garcia Rosa1
1 Departamento de Cincias de Computao Instituto de Cincias Matemticas e de Computao Universidade de So Paulo - So Carlos http://www.icmc.usp.br/~joaoluis
2011
Joo Lus G. Rosa c 2011 - SCC-211: XI. Programao Dinmica 1/53
Sumrio
Paradigmas de Resoluo de Problemas Busca Completa (backtracking ) Algoritmos diviso-e-conquista Algoritmos gulosos Programao Dinmica PD Exemplo
Joo Lus G. Rosa c 2011 - SCC-211: XI. Programao Dinmica
2/53
Busca Completa (backtracking ) Algoritmos diviso-e-conquista Algoritmos gulosos
Os quatro paradigmas
Os quatro paradigmas de resoluo de problemas mais comumente usados em competies de programao so [3]:
1 2 3 4
Busca Completa (backtracking) Diviso e Conquista Busca Gulosa Programao Dinmica
3/53
Sumrio
4/53
Algoritmos tentativa-e-erro
Um algoritmo tentativa-e-erro aquele que testa exaustivamente todas as solues possveis de um problema, de modo a obter a desejada, As solues so testadas indiscriminadamente:
No utiliza critrios para eliminar outras solues que no podero ser melhores que a obtida no estgio considerado.
As solues so enumeradas de modo semelhante ao percurso em uma rvore que possua todas as solues, Muitas vezes a rvore de solues cresce exponencialmente [8]!
5/53
Algoritmos tentativa-e-erro [8]
Algoritmos tentativa e erro no seguem regra xa de computao:

Passos em direo soluo nal so tentados e registrados, Caso esses passos tomados no levem soluo nal, eles podem ser retirados e apagados do registro.
Quando a pesquisa na rvore de solues cresce rapidamente necessrio usar algoritmos aproximados ou heursticas que no garantem a soluo tima mas so rpidas.
6/53
Exerccio:
Qual o menor caminho da cidade a at a c?
7/53
Exerccio:
TODOS os caminhos so enumerados:
a b c : 21 a b d c : 32 a b f d c : 51
8/53
Sumrio
9/53
Algoritmos diviso-e-conquista
O paradigma diviso-e-conquista consiste em:
1
2 3
Dividir o problema a ser resolvido em subproblemas menores e independentes; Encontrar solues para as partes; Combinar as solues obtidas em uma soluo global.
Os algoritmos utilizam recurso para dividir e combinar. Processo recursivo :

dada uma entrada, se ela sucientemente simples, obtm-se diretamente uma sada correspondente; caso contrrio, ela decomposta em entradas mais simples, para as quais se aplica o mesmo processo, obtendo sadas correspondentes que so ento combinadas em uma sada para a entrada original.
10/53
Algoritmos diviso-e-conquista [8]

Exemplo: encontrar o maior e o menor elemento de um vetor de inteiros, A[1..n], n 1:
void MaxMin4 (int Linf, int Lsup, int *Max, int *Min) { int Max1, Max2, Min1, Min2, Meio; if (Lsup - Linf <= 1) { if (A[Linf-1] < A[Lsup-1]) { *Max = A[Lsup-1]; *Min = A[Linf-1]; } else { *Max = A[Linf-1]; *Min = A[Lsup-1]; } } else { Meio = (Linf+Lsup)/2; MaxMin4(Linf, Meio, &Max1, &Min1); MaxMin4(Meio+1, Lsup, &Max2, &Min2); if (Max1 > Max2) *Max = Max1; else *Max = Max2; if (Min1 < Min2) *Min = Min1; else *Min = Min2; } }
Cada chamada de MaxMin4 atribui Max e Min o maior e o menor elemento em A[Linf ], A[Linf + 1], ..., A[Lsup].
11/53
Diviso-e-conquista: anlise do exemplo [8]

Seja f (n) o nmero de comparaes entre os elementos de A, se A contiver n elementos, f (n ) = 1 para n 2 f ( n/2 ) + f ( n/2 ) + 2 para n > 2
Quando n = 2i para algum inteiro positivo i : f (n) 2f (n/2) 4f (n/4) . . . 2i 2 f (n/2i 2 ) = = = = 2f (n/2) + 2 4f (n/4) + 2 2 8f (n/8) + 2 2 2 . . . 2i 1 f (n/2i 1 ) + 2i 1
12/53
Diviso-e-conquista: anlise do exemplo [8]
Adicionando lado a lado, obtm-se: f (n ) = = = = 2i 1 f (n/2i 1 ) + 2i 1 f (2) + 2i 2 2i 1 + 2i 2 3n 2 2

i 1 k k =1 2
Logo, f (n) = 3n/2 2 para o melhor caso, pior caso e caso mdio (soluo tima).
13/53
Algoritmos diviso-e-conquista
Exemplos de algoritmos:
Busca binria; SelectionSort, MergeSorte, Quicksort; Maior elemento de uma sequncia; Fibonacci recursivo.
14/53
Sumrio
15/53
Algoritmos gulosos
So tipicamente usados para resolver problemas de otimizao, Por exemplo, o algoritmo para encontrar o caminho mais curto entre duas cidades:
Um algoritmo guloso escolhe a estrada que parece mais promissora no instante atual e nunca muda essa deciso, independentemente do que possa acontecer depois.
A cada iterao:
seleciona um elemento conforme uma funo gulosa, marca-o para no consider-lo novamente nos prximos estgios, atualiza a entrada, examina o elemento selecionado quanto sua viabilidade, decide a sua participao ou no na soluo.
Algoritmos gulosos
Algoritmo guloso genrico:

C: conjunto de candidatos; S: conjunto soluo. S= Enquanto (C = ) e (S no tem soluo)
x = seleciona(C ) C = C {x } Se (S + {x } vivel) ento S = S + {x }
Se (S tem soluo) ento retorna S Seno no existe soluo
17/53
Caractersticas dos Algoritmos Gulosos [8]

Para construir a soluo tima existe um conjunto ou lista de candidatos, So acumulados um conjunto de candidatos considerados e escolhidos, e o outro de candidatos considerados e rejeitados, Existe uma funo que verica se um conjunto particular de candidatos produz uma soluo (sem considerar otimalidade no momento), Outra funo verica se um conjunto de candidatos vivel (tambm sem se preocupar com a otimalidade), Uma funo de seleo indica a qualquer momento quais dos candidatos restantes o mais promissor, Uma funo objetivo fornece o valor da soluo encontrada, como o comprimento do caminho construdo (no aparece de forma explcita no algoritmo guloso).
Caractersticas da Implementao de Algoritmos Gulosos [8] Quando funciona corretamente, a primeira soluo encontrada sempre tima, A funo de seleo geralmente relacionada com a funo objetivo, Se o objetivo :
maximizar provavelmente escolher o candidato restante que proporcione o maior ganho individual, minimizar ento ser escolhido o candidato restante de menor custo.
O algoritmo nunca muda de ideia:

Uma vez que um candidato escolhido e adicionado soluo ele l permanece para sempre, Uma vez que um candidato excludo do conjunto soluo, ele nunca mais reconsiderado.
Algoritmos gulosos
Exerccio:
Calcule o menor caminho da cidade a at a c , utilizando um algoritmo guloso.
20/53
PD Exemplo
Sumrio
21/53
PD Exemplo
Introduo
Projetistas de algoritmos e programadores: escrever programas que achem a melhor soluo para todas as instncias dos problemas. relativamente fcil escrever um programa que fornea uma soluo decente e correta, mas assegurar que sempre ele retorna a melhor soluo... Programao Dinmica uma ferramenta geral muito poderosa para resolver problemas de otimizao em itens ordenados da esquerda para a direita, como as cadeias de caracteres. necessrio trabalhar com muitos exemplos para entender PD!
PD Exemplo
Programao Dinmica
Quando um algoritmo recursivo tem complexidade exponencial, a programao dinmica (PD) pode levar a um algoritmo mais eciente, A tcnica de programao dinmica consiste em dividir o problema original em subproblemas mais simples e resolv-los, armazenando os resultados em uma tabela, Isso feito iterativamente. A ideia bsica da programao dinmica construir por etapas uma resposta tima combinando respostas j obtidas para partes menores, Inicialmente, a entrada decomposta em partes mnimas, para as quais so obtidas respostas.
PD Exemplo
Programao Dinmica
Em cada passo, sub-resultados so combinados obtendo-se respostas para partes maiores, at que se obtenha uma resposta para o problema original, A decomposio feita uma nica vez e os casos menores so tratados antes dos maiores, Suas solues so armazenadas para serem usadas quantas vezes for necessrio.
24/53
PD Exemplo
Programao Dinmica
Estrutura geral da programao dinmica [6]:
25/53
PD Exemplo
Programao Dinmica
baseada no princpio da otimalidade:

Em uma sequncia tima de escolhas ou de decises, cada subsequncia tambm deve ser tima:
Por exemplo: o menor caminho de So Carlos a So Paulo passando por Campinas dado pelo menor caminho de So Carlos a Campinas combinado com o menor caminho de Campinas a So Paulo.
Reduz drasticamente o nmero total de vericaes pois evita aquelas que sabidamente no podem ser timas:
A cada passo so eliminadas subsolues que certamente no faro parte da soluo tima do problema.
26/53
PD Exemplo
Programao Dinmica
Exemplo: Qual a melhor maneira de se fazer o produto entre n matrizes?

O produto de uma matriz p q por uma matriz q r requer O(pqr ) operaes.
Considere o produto:
M = M1 [10, 20] M2 [20, 50] M3 [50, 1] M4 [1, 100]:
O produto na ordem M = M1 (M2 (M3 M4 )) requer 125.000 operaes; O produto na ordem M = (M1 (M2 M3 )) M4 requer 2.200 operaes.
27/53
PD Exemplo
Programao Dinmica
Resolver esse problema por tentativa e erro, isto , testar todas as ordens possveis de fazer o produto das matrizes para se obter qual a melhor (f (n)), um processo exponencial em n (f (n) 2n2 [1]). Usando programao dinmica possvel obter um algoritmo O(n3 )!
28/53
PD Exemplo
Programao Dinmica
Seja mij o menor custo para calcular o produto Mi Mi +1 ... Mj para 1 i j n, Assim, mij =
onde:
o termo mik representa o custo mnimo para calcular M = Mi Mi +1 ... Mk , o segundo termo mk +i ,j representa o custo mnimo para calcular M = Mk +1 Mk +2 ... Mj , o terceiro termo, bi 1 bk bj , representa o custo de multiplicar M [bi 1 , bk ] por M [bk , bj ], bi 1 bi so as dimenses da matriz Mi , a equao acima diz que mij , j > i , representa o custo mnimo de todos os valores possveis de k entre i e j 1, da soma dos trs termos.
0 se i = j Mini k j (mik + mk +1,j + bi 1 bk bj ) se j > i
PD Exemplo
Programao Dinmica
Seja mij o menor custo para calcular o produto Mi Mi +1 ... Mj para 1 i j n, Assim, mij = Min 0 se i = j Mini k j (mik + mk +1,j + bi 1 bk bj ) se j > i i k j
principio da otimalidade
Em uma sequncia tima de escolhas ou de decises, cada subsequncia tambm deve ser tima.
30/53
PD Exemplo
Programao Dinmica
Os valores mij so calculados na ordem crescente das diferenas nos subscritos, O clculo inicia com mii para todo i , depois mi ,i +1 para todo i , depois mi ,i +2 , ... Assim, esse mtodo chamado ascendente, ao contrrio dos mtodos recursivos, que so chamados descendentes.
31/53
PD Exemplo
Programao Dinmica
Hierarquia de instncias na programao dinmica [6]:
32/53
PD Exemplo
Programao Dinmica
Exemplo: Tabela de dados calculados pela programao dinmica para o produto:

M = M1 [10, 20] M2 [20, 50] M3 [50, 1] M4 [1, 100] m11 = 0 m12 = 10.000 m22 = 0 m13 = 1.200 m23 = 1.000 m33 = 0 m14 = 2.200 m24 = 3.000 m34 = 5.000 m44 = 0
Exerccio: Escrever um algoritmo para achar o produto de menor custo entre n matrizes, usando programao dinmica.
33/53
PD Exemplo
Programao Dinmica
#define Maxn 10 int main(int argc, char *argv[]) { int i, j, k, h, n, temp; int b[Maxn+1]; int m[Maxn][Maxn]; printf(Numero de matrizes n: ); scanf(%d, &n); getchar(); printf(Dimensoes das matrizes: ); for (i = 0; i <= n; i++) scanf(%d, &b[i]); for (i = 0; i < n; i++) m[i][i] = 0; for (h = 1; h <= n-1; h++) { for (i = 1; i <= n-h; i++) { j = i+h; m[i-1][j-1] = INT_MAX; for (k = i; k <= j-1; k++) { temp = m[i-1][k-1] + m[k][j-1] + b[i-1] * b[k] * b[j]; if (temp < m[i-1][j-1]) m[i-1][j-1] = temp; } printf(m[%d][%d] = %d\n, i-1, j-1, m[i-1][j-1]); } putchar(\n); } return 0; } Joo Lus G. Rosa c 2011 - SCC-211: XI. Programao Dinmica
34/53
PD Exemplo
Sumrio
35/53
PD Exemplo
Flight Planner (10337)

Calculating the minimal cost for a ight involves calculating an optimal ight-altitude depending on wind-strengths changing with different altitudes. Its not enough just to ask for the route with optimal wind-strength, because due to the mass of a plane you need a certain amount of fuel to rise. Moreover due to safety regulations its forbidden to y above a certain altitude and you cant y under zero-level. In order to simplify the problem for now, we assume that for each 100 miles of ight you have only three possibilities: to climb one mile, to hold your altitude or to sink one mile. Climb ight requires 60 units of fuel, holding your altitude requires 30 units and sinking requires 20 units.
36/53
PD Exemplo

In the case of headwind you need more fuel while you can save fuel ying with tailwind. Wind strength w will satisfy the condition 10 w 10, where negative wind strength is meant to be headwind and positive wind strength is tailwind. For one unit of tailwind you can save one unit of fuel each 100 miles; each unit of headwind will cost an extra unit of fuel. For example to climb under conditions of wind strength w = 5, you need 65 units of fuel for this 100 miles. Given the wind strengths on different altitudes for a way from here to X , calculate the minimal amount of fuel you need to y to X .
PD Exemplo

Input:
The rst line of the input le contains the number N of test cases in the le. The rst line of each test case contains a single integer X , the distance to y, with 1 X 100000 miles and X is a multiple of 100. Notice that its not allowed to y higher than 9 miles over zero and that you have to decide whether to climb, hold your altitude or to sink only for every 100 miles. For every mile of allowed altitude (starting at altitude 9 down to altitude 0) there follow X /100 wind strengths, starting with the wind strength at your current position up to the wind strength at position X 100 in steps of 100 miles. Test cases are separated by one or more blank lines.
38/53
PD Exemplo
Output:
For each test case output the minimal amount of fuel used ying from your current position (at altitude 0) to X (also at altitude 0), followed by a blank line.
39/53
PD Exemplo

Sample Input
Sample Output
120 354 Joo Lus G. Rosa c 2011 - SCC-211: XI. Programao Dinmica 40/53
PD Exemplo
Material do Stephen Halim
Os prximos 19 slides contm material de Stephen Halim disponveis em [4].
41/53
M ti ti Motivation
Howtosolvethis:10337 (FlightPlanner)?
Unit:1milealtitudeand 1(x100)milesdistance Givenwindspeedmap Fuel F lcost: t {climb li b (+60), ( 60) hold (+30),sink (+20)} windspeedwsp[alt][dis] Computemin fuelcost from(0,0)to(0,X=4)!
1 1 1 1 | 9 1 1 1 1 | 8 1 1 1 1 | 7 1 1 1 1 | 6 1 1 1 1 | 5 1 1 1 1 | 4 1 1 1 1 | 3 1 1 1 1 | 2 1 9 9 1 | 1 1 -9 -9 1 | 0 ======================== 0 1 2 3 4 (x100)
CS3233 CompetitiveProgramming, StevenHalim,SoC,NUS
C Complete l t S Search? h?(1)

Firstguess:
Docompletesearch/bruteforce/backtracking Findallpossible flightpathsand picktheonethatyieldtheminimumfuelcost

RecurrenceoftheCompleteSearch
f fuel l(alt, ( lt min3(60 30 20 di ) = dis) - wsp[alt][dis] + fuel(alt + 1, dis + 1), - wsp[alt][dis] + fuel(alt , dis + 1), - wsp[alt][dis] + fuel(alt - 1, dis + 1))
Stopwhenwereachfinalstate(basecase): alt=0anddis =X,i.e.fuel(0,X)=0 Pruneinfeasiblestates(alsobasecases):

alt<0oralt>9ordis >X!,i.e.returnINF*
Answeroftheproblemisfuel(0,0)
C Complete l t S Search h S Solutions l ti (1)

Solution1
1 1 1 1 | 9 1 1 1 1 | 8 1 1 1 1 | 7 1 1 1 1 | 6 1 1 1 1 | 5 1 1 1 1 | 4 1 1 1 1 | 3 1 1 1 1 | 2 1 9 9 1 | 1 1 -9 -9 1 | 0 ======================== 0 1 2 3 4 (x100) 29+ 39+ 39+ 29=136
Solution2
1 1 1 1 | 9 1 1 1 1 | 8 1 1 1 1 | 7 1 1 1 1 | 6 1 1 1 1 | 5 1 1 1 1 | 4 1 1 1 1 | 3 1 1 1 1 | 2 1 9 9 1 | 1 1 -9 -9 1 | 0 ======================== 0 1 2 3 4 (x100) 29+ 39+ 69+ 19=156

Solution3
1 1 1 1 | 9 1 1 1 1 | 8 1 1 1 1 | 7 1 1 1 1 | 6 1 1 1 1 | 5 1 1 1 1 | 4 1 1 1 1 | 3 1 1 1 1 | 2 1 9 9 1 | 1 1 -9 -9 1 | 0 ======================== 0 1 2 3 4 (x100) 29+ 69+ 11+ 29=138
Solution4
1 1 1 1 | 9 1 1 1 1 | 8 1 1 1 1 | 7 1 1 1 1 | 6 1 1 1 1 | 5 1 1 1 1 | 4 1 1 1 1 | 3 1 1 1 1 | 2 1 9 9 1 | 1 1 -9 -9 1 | 0 ======================== 0 1 2 3 4 (x100) 59+ 11+ 39+ 29=138

Solution5
1 1 1 1 | 9 1 1 1 1 | 8 1 1 1 1 | 7 1 1 1 1 | 6 1 1 1 1 | 5 1 1 1 1 | 4 1 1 1 1 | 3 1 1 1 1 | 2 1 9 9 1 | 1 1 -9 -9 1 | 0 ======================== 0 1 2 3 4 (x100) 29+ 69+ 21+ 19=138
Solution6
1 1 1 1 | 9 1 1 1 1 | 8 1 1 1 1 | 7 1 1 1 1 | 6 1 1 1 1 | 5 1 1 1 1 | 4 1 1 1 1 | 3 1 1 1 1 | 2 1 9 9 1 | 1 1 -9 -9 1 | 0 ======================== 0 1 2 3 4 (x100) 59+ 21+ 11+ 29=120(OPT)

Solution7
1 1 1 1 | 9 1 1 1 1 | 8 1 1 1 1 | 7 1 1 1 1 | 6 1 1 1 1 | 5 1 1 1 1 | 4 1 1 1 1 | 3 1 1 1 1 | 2 1 9 9 1 | 1 1 -9 -9 1 | 0 ======================== 0 1 2 3 4 (x100) 59+ 21+ 21+ 19=120(OPT)
Solution8
1 1 1 1 | 9 1 1 1 1 | 8 1 1 1 1 | 7 1 1 1 1 | 6 1 1 1 1 | 5 1 1 1 1 | 4 1 1 1 1 | 3 1 1 1 1 | 2 1 9 9 1 | 1 1 -9 -9 1 | 0 ======================== 0 1 2 3 4 (x100) 59+ 51+ 19+ 19=148

Howlargeisthesearchspace?
Maxdistanceis100,000miles Eachdistancestepis100miles Thatmeanswehave1,000 distancecolumns! Branchingfactorperstepis3 3(climb (climb,hold hold,sink) Thatmeanscompletesearchcanendup performingO(31,000)operations Toomanyfor3stimelimit/
O l Overlapping i S Sub b P Problem bl I Issue

InsimpleO(31,000)CompleteSearchsolution, weobserve b many overlapping l i sub bproblems bl !
Many yways y toreachcoordinate(alt, ( ,dis) )
INF 2 INF INF
INF
0 0 1 2
DPt tothe th Rescue R (1)

DP=DynamicProgramming
Programminghereisnotwritingcomputercode, butatabularmethod! Aprogrammingparadigmthatyoumustknow!
Andhopefully, hopefully master master
DPt tothe th Rescue R (2)

UseDPwhentheproblemexhibits:
Optimalsubstructure
Optimal p solutiontotheoriginal g p problemcontains optimalsolutiontosubproblems
ThisissimilarastherequirementofGreedyalgorithm
Overlappingsubproblems
Numberofdistinctsubproblemsareactuallysmall small Buttheyarerepeatedlycomputed
ThisisdifferentfromDivideandConquer
DPS Solution l ti (1)

Recurrence*oftheCompleteSearch
f fuel l(alt, ( lt min3(60 30 20 di dis) ) = - wsp[alt][dis] + fuel(alt + 1, dis + 1), - wsp[alt][dis] + fuel(alt , dis + 1), - wsp[alt][dis] + fuel(alt - 1, dis + 1))
Subp problemfuel(alt, ( ,dis) )canbeoverlapping pp g!

Thereareonly10altand1,000dis=10,000 states Alot l of ftimesaved dif fthese h arenotrecomputed! d!
ExponentialO(31,000)topolynomialO(10*1,000)!
alt > 2 not shown 2
1 1 1 0
1 1 1 1
1 1 2
DPS Solution l ti (2)
1 0
40 19 29 0 3 4
Createa2Dtableofsize10*(X/100)
Save Space!
Set1forunexploredsubproblems(memset) Storethecomputationvalueofsubproblem
2
Simplyreusewhen itisneededagain!
INF INF INF
INF
0 0 1 2
DPS Solution l ti Implementation I l t ti (1)

TherearetwowaystoimplementDP:
TopDown BottomUp
TopDown(Demo):
Recursionaspernormal+memoizationtable
Itisjustasimplechangefrombacktracking (completesearch)solution!
T R Turn Recursion i i into t M Memoization i ti

initializememotableinmainfunction(memset?) return_value _ recursive_function() _ (){ ifalreadycalculated,simplyreturntheresult calculate l l the h result l using i recursion i savetheresultinthememotable returntheresult }
DPS Solution l ti Implementation I l t ti (2)

Anotherway:BottomUp(Demo):
Figureouttheorder inwhichthetableisfilled
Recurrencerelationmustbemodifiedabit!
fuel(alt, min3(20 30 60 dis) = - wsp[alt + 1][dis - 1] + fuel(alt + 1, dis - 1), - wsp[alt ][dis - 1] + fuel(alt , dis - 1), - wsp[alt - 1][dis - 1] + fuel(alt - 1, dis - 1))
Thenfillinthetableusingloops!
BothDPvariantsusetable!
Vi li ti Visualization
fuel(alt, min3(20 30 60 dis) = - wsp[alt + 1][dis - 1] + fuel(alt + 1, dis - 1), - wsp[alt ][dis - 1] + fuel(alt , dis - 1), - wsp[alt - 1][dis - 1] + fuel(alt - 1, dis - 1))
2 1 0
0 0
59 29 1 2
110
0 0
1 1 1 1 | 9 1 1 1 1 | 8 1 1 1 1 | 7 1 1 1 1 | 6 1 1 1 1 | 5 1 1 1 1 | 4 1 1 1 1 | 3 1 1 1 1 | 2 1 9 9 1 | 1 1 -9 -9 1 | 0 ======================== 0 1 2 3 4 (x100)
Tips: (on-the-fly)
We can reduce one storage dimension by only keeping 2 recent columns at a time But the time p y is complexity unchanged: O(10 * X / 100)
1 0
59 80 29 68 1 2 3 4
2 1 0
0 0
110 131
59 80 101 29 68 91 1 2 3 4
2 1 0
0 0
110 131
59 80 101 29 68 91 120 1 2 3 4
T Down Top D orBottom B tt Up? U ?

TopDown
Pro:
Naturaltransformation fromnormalrecursion Onlycomputesub problemswhennecessary
BottomUp
Pro:
Fasterifmanysub problemsarevisited: norecursivecalls! Cansavememoryspace^
Cons:
Sloweriftherearemany subproblemsdueto recursivecalloverhead UseexactlyO(states) tablesize( (MLE?) )
Cons:
Notsointuitive? IfthereareXstates, b tt upvisits/fills bottom i it /fill th the valueofalltheseXstates
IfOptimal O ti lSolution(s) S l ti ( )areNeeded N d d

Althoughnotoften,sometimesthisisasked! AswebuildtheDPtable, recordwhichoptionistakenineachcell!
Usually,thisinformationisstoredindifferenttable Then,dorecursivescan(s)tooutputsolution
Sometimes,therearemorethanonesolutions!
Demo
2 1 0
0 0
110 131
59 80 101 29 68 91 120 1 2 3 4
Apndice
Exerccios para Nota Referncias
Exerccios para Nota
Optimal Binary Search Tree (10304) Vampires (11500)
42/53
Apndice
Optimal Binary Search Tree (10304)

Given a set S = (e1 , e2 , ..., en ) of n distinct elements such that e1 < e2 < ... < en and considering a binary search tree of the elements of S , it is desired that higher the query frequency of an element, closer will it be to the root. The cost of accessing an element ei of S in a tree (cost (ei )) is equal to the number of edges in the path that connects the root with the node that contains the element. Given the query frequencies of the elements of S , (f (e1 ), f (e2 , ..., f (en )), we say that the total cost of a tree is the following summation: f (e1 ) cost (e1 ) + f (e2 ) cost (e2 ) + ... + f (en ) cost (en ) In this manner, the tree with the lowest total cost is the one with the best representation for searching elements of S . Because of this, it is called the Optimal Binary Search Tree.
Apndice
Input
The input will contain several instances, one per line. Each line will start with a number 1 n 250, indicating the size of S . Following n, in the same line, there will be n non-negative integers representing the query frequencies of the elements of S : f (e1 ), f (e2 ), ..., f (en ). 0 f (ei ) 100. Input is terminated by end of le.
Output
For each instance of the input, you must print a line in the output with the total cost of the Optimal Binary Search Tree.
44/53
Apndice
Sample Input
1 5 3 10 10 10 3 5 10 20
Sample Output
0 20 20
45/53
Apndice
Vampires (11500)
The Problem
Felipinho is thrilled with his new RPG game, about wars between clans of vampires. In this game he plays a vampire that repeatedly comes into combat against vampires from other clans. Such battles are won or lost based on some characteristics of the opponents, with the help of a standard six-faced dice. For simplicity, we will consider only the ght between two vampires, Vampire 1 and Vampire 2. Each vampire has a vital energy (denoted respectively by EV1 and EV2 ). Besides, an attack force AT and a damage capacity D are also given.
46/53
Apndice
Vampires (11500)
The Problem (cont.)
The combat is fought in turns, in the following way. At each turn, the dice is rolled; if the result value is less than or equal to AT , Vampire 1 wins the turn, otherwise Vampire 2 wins. The winner then sucks the value D from the losers vital energy. That is, D points are subtracted from the losers vital energy and added to the winners vital energy. The combat continues until one of the ghters has EV less than or equal to zero. For example, suppose EV1 = 7, EV2 = 5, AT = 2 and D = 4. The dice is rolled and the result value is 3. Then, Vampire 2 wins the turn, and therefore 4 points are subtracted from EV1 and added to EV2 . The new values for the vital energies would be EV1 = 3 and EV2 = 9. Notice that, if in the next turn Vampire 2 wins again, the combat ends.
Apndice
Vampires (11500)
The Problem (cont.)

The values of AT and D are constant throughout the combat; only EV1 and EV2 vary. Despite loving the game, Felipinho thinks that the combats are too long, and suspects that, given the initial values of EV1 , EV2 , AT and D , it is possible to determine the probability of one of the players winning the combat, and that could help shorten the combat time. Felipinho has asked your help to verify his suspicion.
48/53
Apndice
Vampires (11500)
The Input
The input contains several test cases. Each test case is given in one single line, containing four integers EV1 , EV2 , AT and D separated by spaces (1 EV1 , EV2 10, 1 AT 5 and 1 D 10). The end of input is indicated by one line containing only four zeros, separated by spaces.
The Output
For each test case in the input, your program must print a single line. The line must contain a real number representing, in terms of percentages, the probability that Vampire 1 wins the combat. The result must be printed as a real number with exactly one decimal gure.
Apndice
Vampires (11500)
Sample Input
1 1 8 7 0 1 2 5 5 0 3 1 3 2 0 1 1 1 4 0
Sample Output
50.0 3.2 61.5 20.0
50/53
Apndice
Referncias I
[1] Aho, A. V., Hopcroft. J. E., Ullman, J. D. The Design and Analysis of Computer Algorithms. Addison-Wesley, 1974. [2] Cormen, T. H., Leiserson, C. E., Rivest, R. L., Stein, C. Algoritmos - Teoria e Prtica. Ed. Campus, Rio de Janeiro, Segunda Edio, 2002. [3] Halim, S., Halim, F. Competitive Programming - Increasing the Lower Bound of Programming Contests. Lulu, 2010.
51/53
Apndice
Referncias II
[4] Halim, S. CS3233 - Competitive Programming - Week 04 Problem Solving Paradigms (Dynamic Programming 1) Supporting Material - Competitive Programming: http://sites.google.com/site/stevenhalim/ home/material [5] Horowitz, E., Sahni, S. Rajasekaran, S. Computer Algorithms. Computer Science Press, 1998. [6] Munari Junior, Pedro Augusto Paradigmas e Tcnicas de Projeto de Algoritmos. SCE-181 Introduo Cincia da Computao II. Slides. Cincia de Computao. ICMC/USP, 2007.
Apndice
Referncias III
[7] Skiena, Steven S.; Revilla, Miguel A. Programming Challenges - The Programming Contest Training Manual - chapter 11. Springer, 2003. [8] Ziviani, Nivio Projeto de Algoritmos - com implementaes em Java e C++. Thomson, 2007.
53/53

SCC211 Cap 11

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

SCC211 Cap 11

Enviado por

Direitos autorais:

Formatos disponíveis

Paradigmas de Resoluo de Problemas Programao Dinmica

SCC-211 - Captulo 11 Programao Dinmica

Paradigmas de Resoluo de Problemas Programao Dinmica

Joo Lus G. Rosa c 2011 - SCC-211: XI. Programao Dinmica

Paradigmas de Resoluo de Problemas Programao Dinmica

Busca Completa (backtracking ) Algoritmos diviso-e-conquista Algoritmos gulosos

Busca Completa (backtracking) Diviso e Conquista Busca Gulosa Programao Dinmica

Joo Lus G. Rosa c 2011 - SCC-211: XI. Programao Dinmica

Paradigmas de Resoluo de Problemas Programao Dinmica

Busca Completa (backtracking ) Algoritmos diviso-e-conquista Algoritmos gulosos

Joo Lus G. Rosa c 2011 - SCC-211: XI. Programao Dinmica

Paradigmas de Resoluo de Problemas Programao Dinmica

Busca Completa (backtracking ) Algoritmos diviso-e-conquista Algoritmos gulosos

Joo Lus G. Rosa c 2011 - SCC-211: XI. Programao Dinmica

Paradigmas de Resoluo de Problemas Programao Dinmica

Busca Completa (backtracking ) Algoritmos diviso-e-conquista Algoritmos gulosos

Algoritmos tentativa-e-erro [8]

Algoritmos tentativa e erro no seguem regra xa de computao:

Joo Lus G. Rosa c 2011 - SCC-211: XI. Programao Dinmica

Paradigmas de Resoluo de Problemas Programao Dinmica

Busca Completa (backtracking ) Algoritmos diviso-e-conquista Algoritmos gulosos

Joo Lus G. Rosa c 2011 - SCC-211: XI. Programao Dinmica

Paradigmas de Resoluo de Problemas Programao Dinmica

Busca Completa (backtracking ) Algoritmos diviso-e-conquista Algoritmos gulosos

Joo Lus G. Rosa c 2011 - SCC-211: XI. Programao Dinmica

Paradigmas de Resoluo de Problemas Programao Dinmica

Busca Completa (backtracking ) Algoritmos diviso-e-conquista Algoritmos gulosos

Joo Lus G. Rosa c 2011 - SCC-211: XI. Programao Dinmica

Paradigmas de Resoluo de Problemas Programao Dinmica

Busca Completa (backtracking ) Algoritmos diviso-e-conquista Algoritmos gulosos

Os algoritmos utilizam recurso para dividir e combinar. Processo recursivo :

Joo Lus G. Rosa c 2011 - SCC-211: XI. Programao Dinmica

Paradigmas de Resoluo de Problemas Programao Dinmica

Busca Completa (backtracking ) Algoritmos diviso-e-conquista Algoritmos gulosos

Algoritmos diviso-e-conquista [8]

Joo Lus G. Rosa c 2011 - SCC-211: XI. Programao Dinmica

Paradigmas de Resoluo de Problemas Programao Dinmica

Busca Completa (backtracking ) Algoritmos diviso-e-conquista Algoritmos gulosos

Diviso-e-conquista: anlise do exemplo [8]

Joo Lus G. Rosa c 2011 - SCC-211: XI. Programao Dinmica

Paradigmas de Resoluo de Problemas Programao Dinmica

Busca Completa (backtracking ) Algoritmos diviso-e-conquista Algoritmos gulosos

Diviso-e-conquista: anlise do exemplo [8]

Adicionando lado a lado, obtm-se: f (n ) = = = = 2i 1 f (n/2i 1 ) + 2i 1 f (2) + 2i 2 2i 1 + 2i 2 3n 2 2

Joo Lus G. Rosa c 2011 - SCC-211: XI. Programao Dinmica

Paradigmas de Resoluo de Problemas Programao Dinmica

Busca Completa (backtracking ) Algoritmos diviso-e-conquista Algoritmos gulosos

Joo Lus G. Rosa c 2011 - SCC-211: XI. Programao Dinmica

Paradigmas de Resoluo de Problemas Programao Dinmica

Busca Completa (backtracking ) Algoritmos diviso-e-conquista Algoritmos gulosos

Joo Lus G. Rosa c 2011 - SCC-211: XI. Programao Dinmica

Paradigmas de Resoluo de Problemas Programao Dinmica

Busca Completa (backtracking ) Algoritmos diviso-e-conquista Algoritmos gulosos

Paradigmas de Resoluo de Problemas Programao Dinmica

Busca Completa (backtracking ) Algoritmos diviso-e-conquista Algoritmos gulosos

Algoritmo guloso genrico:

Se (S tem soluo) ento retorna S Seno no existe soluo

Joo Lus G. Rosa c 2011 - SCC-211: XI. Programao Dinmica

Paradigmas de Resoluo de Problemas Programao Dinmica

Busca Completa (backtracking ) Algoritmos diviso-e-conquista Algoritmos gulosos

Caractersticas dos Algoritmos Gulosos [8]

Paradigmas de Resoluo de Problemas Programao Dinmica

Busca Completa (backtracking ) Algoritmos diviso-e-conquista Algoritmos gulosos