Algorithm 1: Pseudo código do algoritmo recursivo da mochila, onde

o segundo operador de indexação do vetor v representa o peso se for 0

e o valor se for 1, a tabela de memorização é preenchida com -1
1 Mochila (indice, peso);
Input : O indice atual do vetor e o peso atual.
Output: O maior valor que é possı́vel obter a partir de indice com
peso.
2 if memo[indice][peso] 6= −1 then
3 return memo[indice][peso];
4 if indice ≥ tamanho(v) then
5 return 0;
6 ans ← 0
7 if peso ≥ v[indice][0] then
8 ans ← M ochila(indice + 1, peso − v[indice][0]) + v[indice][1]
9 return memo[indice][peso] = max(ans, M ochila(indice + 1, peso))

1
 Algorithm 2: Pseudo código do algoritmo recursivo para obter o
tamanho da maior subsequencia comum (LCS) entre as strings s e t. A
tabela de memorização é preenchida com -1
1 LCS (i, j);
Input : i é o ı́ndice de uma string e j é o ı́ndice da outra.
Output: O tamanho da maior subsequencia comum mais longa a partir
dos ı́ndices i e j.
2 if i ≥ tamanho(s) ou j ≥ tamanho(t) then
3 return 0;
4 if memo[i][j] 6= −1 then
5 return memo[i][j];
6 ans ← 0
7 if s[i] = t[j] then
8 ans ← LCS(i + 1, j + 1)
9 else
10 ans ← max(LCS(i + 1, j), LCS(i, j + 1))
11 return memo[i][j] = ans

Algorithm 3: Pseudo código da solução do problema Caminhos dos

Presentes, onde a, b e c são os 3 vetores que representam os caminhos.
A tabela de memorização é preenchida com -1
1 solve (i, j);
Input : i é o do vetor referente ao trecho do caminho, j é o indicador
de qual caminho pertenço, a, b ou c.
Output: O maior valor possı́vel partindo do trecho i, na pista j.
2 if i ≥ tamanho(a) then
3 return 0;
4 if memo[i][j] 6= −1 then
5 return memo[i][j];
6 if j = 1 then
7 ans ←
max(solve(i + 1, 0) + a[i], solve(i + 1, 1) + b[i], solve(i + 1, 2) + c[i])
8 else if j = 2 then
9 ans ← max(solve(i + 1, 1) + b[i], solve(i + 1, 2) + c[i])
10 else
11 ans ← max(solve(i + 1, 0) + a[i], solve(i + 1, 1) + b[i])
12 return memo[i][j] = ans

2
 Algorithm 4: Pseudo código da solução do problema Jogo dos cartões.
A tabela de memorização é preenchida com -1
1 solve (i, j, jogada);
Input : i é o ı́ndice inicial do do intervalo considerado, j é o ı́ndice
final do intervalo e jogada é uma variável binária que
representa qual jogador deve jogar.
Output: j é o indicador de qual caminho pertenço: a, b ou c.
2 if i ≥ j then
3 return 0;
4 if memo[i][j][jogada] 6= −1 then
5 return memo[i][j][jogada];
6 if jogada = 1 then
7 ans ← max(solve(i + 1, j, 0) + v[i], solve(i, j − 1, 0) + v[j])
8 else
9 if v[i] ≥ v[j] then
10 ans ← solve(i + 1, j, 1)
11 else
12 ans ← solve(i, j − 1, 1)
13 return memo[i][j][jogada] = ans

3
 Algorithm 5: Pseudo código do algoritmo que resolve o problema
Parque Jurássico
1 MochilaFrac (v, w, n, W );
Input : v e w são os vetores com valores e pesos, n é o tamanho de
ambos os vetores e W é o peso que a mochila suporta
Output: Um vetor indicando a fracão de cada item da mochila que é
possı́vel pegar de modo a maximizar o valor
2
3 Ordene os itens pela razão valor/peso na forma
v1 /w1 ≥ v2 /w2 ≥ v3 /w3 · · · vn /wn
4
5 Seja f [1 · · · n] um vetor
6 capacidade ← W
7 i←1
8 while i ≤ n e capacidade ≥ wi do
9 if lef t[i] ≤ right[j] then
10 arr[k] ← lef t[i + +]
11 else
12 arr[k] ← right[j + +]
13 k ←k+1
14 while i ≤ len1 do
15 arr[k + +] = lef t[i + +]
16 while j ≤ len2 do
17 arr[k + +] = right[j + +]
18 return f

4
Algorithm 6: Pseudo código do algoritmo guloso que resolve o prob-
lema da Mochila fracionário
1 Parque Jurássico (s1, s2);
Input : s1 e s2 são as strings
Output: Retorna a menor string que tenha s1 e s2 como substrings
2
3 lcs = maior subsequencia comum a ambas as strings
4 j←0
5 k←0
6 str ← string vazia
7 for i = 0 até n ≥ tamanho(lcs) do
8 for até j ≥ tamanho(s1) do
9 if lcs[i] 6= s1[j] then
10 str ← str + s1[j]
11 else
12 j ←j+1
13 break
14 for até k ≥ tamanho(s2) do
15 if lcs[i] 6= s2[k] then
16 str ← str + s2[k]
17 else
18 k ←k+1
19 break

20 for até j < tamanho(s1) do

21 str ← str + s1[j]
22 for até k < tamanho(s2) do
23 str ← str + s2[k]
24 return str