SPACE-FOR-TIME

TRADE-OFFS
SPACE-FOR-TIME TRADE-OFFS

INPUT ENHANCEMENT
o Counting Sort
o Horspool-Booyer-Moore
PRESTRUCTURING
o Hashing
o rvore B
DYNAMIC PROGRAMMING
o Coin-Row
o Change-Making
o Collecting Coins
INPUT ENHANCEMENT
Input Enhancement aplicado compararao de
strings
Horspool-Boyer-Moore
HORSPOOL-BOYER-MOORE
Problema: Dada uma string de tamanho M
chamada de pattern e uma string de tamanho
N chamando text. O problema requer
encontrar uma ocorrncia do pattern em text.
Algoritmo: Posiciona o pattern no inicio de
text, faz a comparao e em seguida desloca
o pattern pra direita para a prxima tentativa.
Com algumas restries no tamanho do
deslocamento.
A Comparao de cada caractere do pattern
com os caracteres de text ocorre da direita
pra esquerda.
O ltimo caractere alinhado do pattern
chamado de C.
HORSPOOL-BOYER-MOORE
CONDIES DO DESLOCAMENTO
CASO 1: O deslocamento de tamanho M caso
no haja C em pattern.
CASO 2: Caso haja um C em pattern mas que
no seja o nico. O deslocamento deve alinhar O
C mais direita de pattern com o text.
CASO 3: Se C o ltimo caractere de pattern e
o nico, o deslocamento igual a M.
CASO 4: Se C o ltimo caractere de pattern
mas ainda h outros Cs, o C mais direita entre
os outros M-1 caracteres de pattern deve ser
alinhado com o C de text.
HORSPOOL-BOYER-MOORE
TABELA DE DESLOCAMENTO

DESLOCAMENTO =
M, caso C no esteja entre os M-1 primeiros
caracteres de pattern
ou
A posio do C mais direita entre os M-1
primeiros caracteres de pattern subtrada de
M, caso contrrio


HORSPOOL-BOYER-MOORE
ALGORITMO DA TABELA DE DESLOCAMENTO

Entrada: um pattern P[0..m-1] e um alfabeto de
possveis caracteres .
Sada: Table[0..size-1] indexada com os
caracteres do alfabeto e preenchida com os
valores dos deslocamentos.

for i 0 to size 1 do Table[i]m
for j 0 to m 2 do Table[P[j ]]m 1 j
return Table
HORSPOOL-BOYER-MOORE
Entrada: um pattern P[0..m-1] e um text T[0..n-1]
Sada: o Index do texto onde a combinao se inicia ou -1 caso
no haja combinaes.

ShiftTable(P [0..m 1]) //gera a tabela de deslocamento
i m 1 //posio do caractere final de pattern
while i n 1 do
k0 //numero de caracteres que combinam
while k m 1 and P[m 1 k]= T [i k] do
kk + 1
if k = m
return i m + 1
else i i + Table[T [i]]
return 1
HORSPOOL-BOYER-MOORE
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
B A R B E
R
J I M S A W M E I N A B A R B E R S H O P
CARACTERE
C
A B C D E F ... R ... Z
DESLOCAMEN
TO
4 2 6 6 1 6 6 3 6 6 6
DYNAMIC
PROGRAMMING
Um caso especial de Space-for-Time Trade-
Off
Exemplo I
COIN-ROW PROBLEM
COIN-ROW PROBLEM
COIN-ROW PROBLEM
COIN-ROW PROBLEM
F(n) o maior valor possvel encontrado.
Encontramos e dividimos todas as selees
possveis em 2 grupos, caso a ltima moeda
esteja ou no inclusa, assim, F(n)


COIN-ROW PROBLEM
F(n) o maior valor possvel encontrado.
Encontramos e dividimos todas as selees
possveis em 2 grupos, caso a ltima moeda
esteja ou no inclusa, assim, F(n)

= c
n
+ F(n - 2)
ou
= F(n 1)


COIN-ROW PROBLEM
Assim, o problema pode ser expresso como:

F(n) = max{ c
n
+ F(n 2), F(n 1) } para n > 1,
F(0) = 0, F(1) = c
1

COIN-ROW PROBLEM
Entrada: Vetor C com os valores das moedas
Sada: Valor mximo que pode ser escolhido

F[0] = 0; F[1] = C[1]
para i de 2 at n faa
F[i] = max( C[i] + F[i - 2], F[ i 1 ] )
retorne F[n]
COIN-ROW PROBLEM
INDEX
0 1 2 3 4 5 6
C
5 1 2 10 6 2
F
0 5 5 7 15 15 17
Exemplo II
Change-making problem
CHANGE-MAKING PROBLEM
Se n o valor do troco, e d
1
...d
m
, onde d
1
= 1,
representa cada moeda disponvel, possvel o
obter o valor de n adicionando d
j
n d
j
para j =
1...m, assim temos:


CHANGE-MAKING PROBLEM
Se n o valor do troco, e d
1
..d
m
, onde d
1
= 1,
representa cada moeda disponvel, possvel o
obter o valor de n adicionando d
j
n d
j
para j =
1..m, assim temos:

F(n) = min { F( n - d
j
) + 1 } para n > 0,

F[0] = 0

j:nd
j
CHANGE-MAKING PROBLEM
Entrada: inteiro positivo n e um vetor de moedas D[1..m]
Sada: Menor numero de moedas que somam n

F[0] = 0
para i de 1 at n faa
temp = ; j = 1
enquanto j m e i D[j] faa
temp = min( F[i D[j]], temp )
j = j + 1;
F[i] = temp + 1
retorne F[n]

CHANGE-MAKING PROBLEM
n
0 1 2 3 4 5 6
F
0
F[0] = 0
ENTRA N = 6 E VETOR DE MOEDAS = 1, 3 E 4
CHANGE-MAKING PROBLEM
n
0 1 2 3 4 5 6
F
0 1
F[1] = min{F[1 1]} + 1 = 1
ENTRA N = 6 E VETOR DE MOEDAS = 1, 3 E 4
CHANGE-MAKING PROBLEM
n
0 1 2 3 4 5 6
F
0 1 2
F[2] = min{F[2 1]} + 1 = 2
ENTRA N = 6 E VETOR DE MOEDAS = 1, 3 E 4
CHANGE-MAKING PROBLEM
n
0 1 2 3 4 5 6
F
0 1 2 1
F[3] = min{F[3 1], F[3 3]} + 1 = 1
ENTRA N = 6 E VETOR DE MOEDAS = 1, 3 E 4
CHANGE-MAKING PROBLEM
n
0 1 2 3 4 5 6
F
0 1 2 1 1
F[4] = min{F[4 1], F[4 3], F[4 4]} + 1 = 1
ENTRA N = 6 E VETOR DE MOEDAS = 1, 3 E 4
CHANGE-MAKING PROBLEM
n
0 1 2 3 4 5 6
F
0 1 2 1 1 2
F[5] = min{F[5 1], F[5 3], F[5 4]} + 1 = 2
ENTRA N = 6 E VETOR DE MOEDAS = 1, 3 E 4
CHANGE-MAKING PROBLEM
n
0 1 2 3 4 5 6
F
0 1 2 1 1 2 2
F[6] = min{F[6 1], F[6 3], F[6 4]} + 1 = 2
ENTRA N = 6 E VETOR DE MOEDAS = 1, 3 E 4
Exemplo
COLLECTING-COIN
PROBLEM
COLLECTING-COIN PROBLEM

Sendo F(i,j) o nmero mximo de moedas que o rob pode
pegar e levar clula (i,j). Ele pode alcanar a clula (i,j)
tanto pela clula (i-1, j) quanto pela clula (i, j-1). O mximo
de moedas que ele pode levar at essas clulas F(i-1, j) e
F(i, j-1) = 0 e considerando ainda a existncia ou no de uma
moda na clula (i,j). temos que:

COLLECTING-COIN PROBLEM
Sendo F(i,j) o nmero mximo de moedas que o rob pode
pegar e levar clula (i,j). Ele pode alcanar a clula (i,j)
tanto pela clula (i-1, j) quanto pela clula (i, j-1). O mximo
de moedas que ele pode levar at essas clulas F(i-1, j) e
F(i, j-1) = 0 e considerando ainda a existncia ou no de uma
moda na clula (i,j). temos que:

F(i, j) = max{F(i 1, j ), F(i, j 1)} + c
ij
para 1 i n, 1 j m
F(0, j) = 0 para 1 j m para F(i, 0) = 0 for 1 i n,

Onde c
ij
= 1 caso haja uma moeda na clula (i,j), 0 caso
contrrio

COLLECTING-COIN PROBLEM
Entrada: Matriz[n, m] com elementos iguais a 1 ou 0.
Sada: Numero mximo de moedas que podem ser levadas at
a
celula (n, m)

F[1, 1] = C[1, 1];
para j de 2 at m faa F[1, j] = F[1, j 1]+ C[1, j]
para i = 2 at n faa
F[i, 1] = F[i 1, 1] + C[i, 1]
para j = 2 at m faa
F[i, j ] = max(F [i 1, j], F[i, j 1]) + C[i, j ]
return F[n, m]
COLLECTING-COIN PROBLEM

*
* *
* *
* *
* *
0 0 0 0
1

1
0 1 1 2 2 2
0 1 1 3 3 4
0 1 2 3 3 5
1 1 2 3 4 5

*
* *
* *
* *
* *