Universidade Federal de Minas Gerais

Instituto de Cincias Exatas

Departamento de Cincia da Computao

PROJETO E ANLISE DE ALGORITMOS

Trabalho: disponvel em:
http://www.dcc.ufmg.br/ruiter/paatp2

Ruiter Braga Caldas

Professor - Nivio Ziviani

Belo Horizonte
10 de maio de 2004

Sumrio
1 O Problema da Mochila

2 Soluo usando Backtracking

3 Soluo usando Programao Dinmica

1.1
1.2
1.3

Provar que o Problema da Mochila NP-Completo . . . . . . . . . .

Mostrar que o Problema est em NP . . . . . . . . . . . . . . . . . .
Reduo Polinomial . . . . . . . . . . . . . . . . . . . . . . . . . . . .

2
2
2

4 Soluo usando o Mtodo Guloso

10

5 Comparao entre os Mtodos

11

6 Estruturas de Dados

15

A Cdigo Fonte

19

B Tabelas com tempos de execuo

27

5.1

Resposta para os Conjuntos de Dados . . . . . . . . . . . . . . . . . . 13

B.1 Mtodo Guloso . . .

B.1.1 Conjunto I . .
B.1.2 Conjunto II .
B.1.3 Conjunto III .
B.1.4 Conjunto IV .
B.2 Mtodo Dinmico . .
B.2.1 Conjunto I . .
B.2.2 Conjunto II .
B.2.3 Conjunto III .
B.2.4 Conjunto IV .
B.3 Mtodo Backtracking
B.3.1 Conjunto I . .
B.3.2 Conjunto II .
B.3.3 Conjunto III .
B.3.4 Conjunto IV .

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

C Tabelas com Utilidade Acumulada

C.1
C.2
C.3
C.4

Conjunto
Conjunto
Conjunto
Conjunto

I
I
I
I

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

27
27
28
29
30
31
31
33
34
35
36
36
37
38
39

39
39
41
42
43

1 O Problema da Mochila
O problema da Mochila (knapsack problem ) pode ser enunciado da seguinte forma:
Dados um nmero m 0, um inteiro positivo n e, para cada i em {1, . . . , n}, um
nmero vi 0 e um nmero wi 0, encontrar um subconjunto S de {1, . . . , n} que
P
maximize v(S) sob a restrio w(S) m. Onde, v(S) denota a soma iS vi e,
P
analogamente, w(S) denota a soma iS wi .
Os nmeros vi e wi podem ser interpretados como utilidade e peso respectivamente
de um objeto i. O nmero m pode ser interpretado como a capacidade de uma
mochila, ou seja, o peso mximo que a mochila comporta. O objetivo do problema
ento encontrar uma coleo de objetos, a mais valiosa possvel, que respeite a
capacidade da mochila.
Este problema vem sendo estudado deste o trabalho de D.G. Dantzig[5], devido a
sua utilizao imediata na Indstria e na Gerencia Financeira, porm foi mais enunciado por razes tericas, uma vez que este freqentemente ocorre pela relaxao
de vrios problemas de programao inteira. Toda a famlia de Problemas da
Mochila requer que um subconjunto de tens sejam escolhidos, de tal forma que o
somatrio das suas utilidades seja maximizado sem exceder a capacidade da mochila.
Diferentes tipos de problemas da Mochila ocorrem dependendo da distribuio de
tens e Mochilas como citado em [5]:
No problema da Mochila 0/1 (0/1 Knapsack Problem ), cada tem pode ser escolhido no mximo uma vez, enquanto que no problema da Mochila Limitado (Bounded Knapsack Problem ) temos uma quantidade limitada para cada tipo de tem.
O problema da Mochila com Mltipla Escolha (Multiple-choice Knapsack Problem )
ocorre quando os tens devem ser escolhidos de classes disjuntas, e se vrias Mochilas so preenchidas simultaneamente temos o problema da Mochila Mltiplo (Multiple Knapsack Problem ). A forma mais geral o problema da Mochila com multirestries (Multi-constrained Knapsack Problem ) o qual basicamente um problema
de Programao Inteira Geral com Coecientes Positivos.
Todos os problemas da Mochila pertencem a famlia NP-Hard [5], signicando que
muito improvvel que possamos desenvolver algoritmos polinomiais para este problema. Porm, a despeito do tempo para o pior caso de todos os algoritmos terem
tempo exponencial, diversos exemplos de grandes instncias podem ser resolvidos
de maneira tima em frao de segundos. Estes resultados surpreendentes vem de
vrias dcadas de pesquisa que tem exposto as propriedades estruturais especiais do
Problema da Mochila, que tornam o problema to relativamente fcil de resolver.
Neste trabalho todos os algoritmos apresentados resolvem o Problema da Mochila
0/1, que consiste em escolher n tens, tais que o somatrio das utilidades maximizado sem que o somatrio dos pesos extrapolem a capacidade da Mochila. Isto
pode ser formulado como o seguinte problema de maximizar :

M aximizar

n
X

uj x j

j=1

Sujeito

n
X

pj xj M

j=1

xj {0, 1}, j = 1 . . . n
1

onde xj uma varivel binria igual a 1 se j deve ser includo na mochila e 0 caso
contrrio.

1.1 Provar que o Problema da Mochila NP-Completo

Para provar que um problema
acordo com [6], que:

pertence a N P -Completo necessrio provar, de

o mesmo pertence a classe N P , apresentando em algoritmo no-determinista

em tempo polinomial ou mostrando que uma dada soluo pode ser vericada
em tempo polinomial.
Apresentar um reduo em tempo polinomial de um problema N P -completo
para o mesmo.

1.2 Mostrar que o Problema est em NP

Para provar que o Problema da Mochila 0/1 pertence a classe N P vamos apresentar
um algoritmo no-determinista que resolva o problema em tempo polinomial.
KnapsackND(cM, uM, n, P [1..n], U [1..n], X[1..n])

1
2
3
4
5
6

for i 1ton
do

X[i] escolhe(0, 1);

Pn

if ( n1 P [i] X[i] > cM )OR(

then return Insucesso
else return Sucesso

U [i] X[i] < uM )

O procedimento KnapsackN D uma algoritmo No-Determinista para o problema

de deciso da Mochila. As linhas de 1-3 atribui o valor 0/1 para o vetor soluo
X[i], 0 i n. Na linha 4 feito um teste para vericar se a atribuio do pesos
vivel e no ultrapassa a capacidade da Mochila cM e se o resultado da Utilidade
pelo menos uM . Uma soluo com sucesso encontrada se as restries so satisfeitas. A complexidade de tempo deste procedimento O(n). Se m o tamanho da
entrada usando uma representao binria, o tempo O(m)[4].

1.3 Reduo Polinomial

Vamos apresentar uma reduo polinomial a partir de outro problema conhecido
como NP -Completo para o problema da Mochila.
Antes de faz-lo vamos dar uma verso de um problema de deciso para o Problema
da Mochila 0/1. O problema de Otimizao difere do problema de Deciso somente na funo de Otimizao. Assim a verso de Deciso para o problema da
Mochila a seguinte:
Entrada: um conjunto de n tens, tal que todo i tem utilidade ci e peso wi , uma
mochila tem capacidade W e um valor positivo C .
Questo: Existe um subconjunto S {1, ..., n} de tens, tais que o peso total no
mximo W :
X
wi W
iS

e o valor da utilidade total pelo menos C :

c(S) =

ci C?

iS

Para provar que a verso de deciso do problema da Mochila N P -completo vamos

fazer uma reduo polinomial a partir do problema Maximum Subset Sum
Soluo: A verso do problema de deciso para Maximum Subset Sum denida
como apresentada em [3]:
Entrada: Um conjunto nito A, um tamanho inteiro positivo si para cada elemento
i A, e um inteiro positivo B .
Questo: Existe uma subconjunto A0 A tal que
X

si = B?

iA0

Como podemos notar, Maximum Subset Sum um caso especial do problema de

Otimizao do Problema da Mochila 0/1 com ci = wi , como citado em [2].
A reduo completa como se apresenta a seguir:
Dados uma instncia do problema Subset Sum, reduziremos esta para uma instncia do Problema da Mochila 0/1 da seguinte forma :

U = A, wi = ci = si , W = C = B
Esta reduo feita em tempo polinomial, desde que todas as atribuies so executadas em tempo polinomial. Desta forma uma, resposta para uma instncia do
problema da Mochila corresponde a uma resposta para o problema Maximum Subset Sum.

Uma resposta "sim"para uma instncia do Problema da Mochila 0/1

signica que existe um subconjunto S 0 U tal que
X

wi W and

iS 0

ci C

iS 0

Isto signica, usando a nossa transformao, que existe um subconjunto A0 A

tal que
X
B
si B.
iA0

Isto ,

si = B.

iA0

Assim, por denio, uma resposta "sim"para problema Subset Sum.

Um resposta "No"para o Problema da Mochila 0/1, signica que tal

conjunto no existe. O que , exatamente, uma resposta negativa para o
problema Subset Sum.
Assim mostramos que:

o problema da Mochila est em N P e,

existe uma reduo polinomial a partir do problema Maximum Subset Sum
para o Problema da Mochila 0/1.
Com isso provamos que Problema da Mochila 0/1 N P -Completo.
3

2 Soluo usando Backtracking

Backtracking uma estratgia para sistematicamente examinar a lista de possveis
solues. A idia do backtracking eliminar a vericao explcita de uma boa
parte dos possveis candidatos. Para tanto, o problema deve respeitar as restries
que maximizam/minimizam alguma funo de otimizao. Os seguintes passos so
respeitados:
1. Denir um espao de soluo para o problema. Este espao de soluo deve
incluir pelo menos uma soluo tima para o problema.
2. Organizar o espao de soluo de forma que seja facilmente pesquisado. A
organizao tpica uma rvore.
3. Proceder a busca em profundidade.
Backtracking uma estratgia que se aplica em problemas cuja soluo pode ser
denida a partir de uma seqncia de n decises, que podem ser modeladas por
uma rvore que representa todas as possveis seqncias de deciso. De fato, se
existir mais de uma disponvel para cada uma das n decises, a busca exaustiva
da rvore exponencial. A ecincia desta estratgia depende da possibilidade de
limitar a busca, ou seja, podar a rvore, eliminando as sub-rvores que no levam a
nenhuma soluo. As solues so representadas por n-tuplas ou vetores de soluo
(v1 , v2 , . . . , vn ). Cada vi escolhido a partir de um conjunto nito de opes Si . O
algoritmo inicia com um vetor vazio e em cada etapa o vetor extendido com um
novo valor formando um novo vetor que pode representar uma soluo parcial do
problema. Na avaliao de um vetor (v1 , . . . , vi ), se for constatado que ele no pode
representar uma soluo parcial, o algoritmo faz o backtracking, eliminando o ltimo
valor do vetor, e continua tentando extender o vetor com outros valores alternativos.
Implementamos o algoritmo descrito em [4], este problema possui espao de soluo
consistindo de 2n maneiras distintas de atribuir zero ou um para o vetor de soluo
X . Este algoritmo faz uso de uma funo limite para ajudar a eliminar alguns
ns sem fazer a expanso deles. Uma boa funo limite para este problema obtida
usando um limite superior com o valor da melhor soluo vivel obtida pela expanso
de um n ativo e qualquer dos seus descendentes. Se este limite superior no for
maior que valor da melhor soluo encontrada at o momento, ento este n pode
ser eliminado. A funo limite funciona da seguinte forma: Se num n Z qualquer,
o valor de xi ,1 i k j foi determinado, ento um limite superior para Z pode ser
obtido pela relaxao do requisito de xi = 0 ou xi = 1 por 0 xi 1 para os ns
k + 1 i n e usando um algoritmo guloso para resolver o problema da relaxao.
A funo Limite determina um limite superior sobre a melhor soluo obtida pela
expanso de um n Z no nvel k + 1 do espao de estados.

Limite(ut, pt, k, M )

1
2
3
4
5
6
7
8
9

b ut
c pt
for i k + 1 to n

do

c c + P (i)
if c < M
then b b + U (i)
else return (b + (1 (c M )/P (i)) U (i))
return b

O algoritmo seguinte implementa o mtodo de Backtracking:

Metodo_Backtracking(M, n, P, I, pf, if, X)

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
26
27
28

pc ic 0
k1
if 1
while 1 = 1

do

while (k n)&(pc + P (k) M )

do

pc pc + P (k)
ic ic + I(k)
Y (k) 1
k k+1
if k > n
then if ic
pf pc
kn
XY
else Y (k) 0
while Limite(ic, pc, k, M ) if

do

while (k 6= 0)&(Y (k) 6= 1)

do
k k1

if k = 0
then return

Y (k) 0
pc pc P (k)
ic ic I(k)
k k+1

O ordem de complexidade de espao para este algoritmo O(2n ) de acordo com

[4]. Da funo Limite segue que o limite para um n lho esquerda vivel de
um n Z o mesmo para Z . Ento a funo Limite no precisa ser usada sempre
que o algoritmo faz um movimento para o lho a esquerda de um n. Desde que
o algoritmo tentar fazer um movimento para a esquerda sempre que houver uma
5

escolha entre esquerda e direita, a funo Limite ser chamada somente depois de
uma srie de movimento com sucesso para os lhos a esquerda. Quando if 6= 1,
P
X(i), 1 i n tal que ni=1 I(i)X(i) = if . No while nas linhas 6 a 11 movimentos
sucessivos so feitos para lhos a esquerda vivel. Y (i) = 1, 1 i n o caminho
P
Pk1
para o n corrente. pc = k1
i=1 P (i)Y (i) e ic =
i=1 I(i)Y (i). Se na linha 12, k > n
ento ic > if indicando que o caminho para esta folha terminou na ltima vez que
a funo Limite foi usada. Se k n ento P (i) no cabe e um movimento para um
lho direita deve ser feito. Ento Y (k) marcado como 0 na linha 17. Se na linha
18, Limite n, ento o caminho corrente terminou e ele no pode levar a uma
soluo melhor que a encontrada at o momento. Nas linhas 20 a 22, retornamos ao
longo do caminho para o n mais recente a partir do qual um movimento no tentado
pode ser feito. Se no existe este caminho ento o algoritmo termina na linha 23-24.
Caso contrrio Y (k), pc e ic so apropriadamente atualizados para corresponder a
um movimento para a direita. O limite para este novo n calculado. O processo
de retorno das linhas 18 a 27 continua at que um movimento feito para um lho
a direita a partir do qual exista uma possibilidade de obter uma soluo com valor
maior que if . Considerando o seguinte exemplo para o problema da Mochila: A
n
U
P

1
11
1

2
21
11

3
31
21

4
33
23

5
43
33

6
53
43

7
55
45

8
65
55

Figura 1: Exemplo para o Backtracking

rvore mostra as vrias escolhas que so feitas para o vetor de soluo parcial Y .
O i-simo nvel da rvore corresponde a uma atribuio 0 ou 1 para Y (i), quando
inclui ou exclui o Peso P (i). Os dois nmeros no n so o peso corrente (pc ) e
a importncia corrente (ic ). O ns que no contem nmeros tem peso e utilidade
idntico aos pais. O nmero de fora do n a direita o limite do n. O limite dos
ns a esquerda so os mesmos dos pais. A varivel if do algoritmo atualizada em
cada n A, B, C e D. Cada vez que if atualizada, o vetor soluo nal X tambm
atualizado. Ao terminar if = 159 e X=(1,1,1,0,1,1,0,0). Dos 29 1 = 511 ns do
espao de estados da rvore somente 33 so gerados.

3 Soluo usando Programao Dinmica

Uma soluo tima baseada no mtodo guloso denida por uma seqncia de decises locais timas, como pode ser visto na prxima seo. Quando o mtodo guloso
no funciona, uma possvel sada seria a gerao de todas as possveis seqncias de
decises. E a melhor seqncia seria ento escolhida, como no caso do Backtracking
acima. Essa soluo de ordem exponencial e, portanto, ineciente. Programao
dinmica uma tcnica que tem como objetivo diminuir o nmero de seqncias geradas. A programao dinmica trata o nmero de combinaes da seguinte forma:
Vamos considerar n tens, dentre os quais devemos escolher r. Para escolher os r
tens, podemos proceder de duas formas:
1. Escolher o primeiro tem. Escolher depois r 1 tens dos n 1 tens restantes.
6

Figura 2: rvore gerada pelo Algoritmo Guloso

2. No escolher o primeiro tem. Ento devemos escolher r tens dos n 1 tens
restantes

n
Est soluo pode ser traduzida da seguinte forma: nr = n1
+ r1
Se usarmos
r1
uma estratgia de diviso e conquista para implementar esta soluo obteremos
um algoritmo com complexidade O(2n ), sendo o maior problema desta abordagem o
nmero de vezes que o mesmo problema resolvido. Uma outra abordagem seria usar
uma tabela para armazenar as solues que vo se repetir, e essa a idia principal da
programao dinmica. Usando esta abordagem para o problema podemos melhor
a complexidade deste problema para O(n2 ). Sendo o projeto de uma algoritmo
baseado em Programao Dinmica dividido em duas partes:

1. Identicao

determinar uma soluo por diviso e conquista.

Analisar e vericar que o tempo de execuo exponencial.
Mesmo sub-problema resolvido vrias vezes.
2. Construo

Pegar a parte do algoritmo de diviso e conquista que corresponde

parte da conquista e substituir as chamadas recursivas por uma olhada
na tabela.
Em vez de retornar um valor, armazen-lo na tabela.
Usar o caso base do algoritmo de diviso e conquista para inicializar a
tabela.
Determinar o padro de preenchimento da tabela.
Denir um lao que utiliza o padro para preencher os demais valores da
tabela.
7

Figura 3: Instncia para o Algoritmo de Programao Dinmica

Vamos apresentar um exemplo do problema da Mochila onde a utilizao da programao dinmica permite encontrar a soluo tima. Sejam n tens de tamanhos
s1, s2, . . . , sn, conforme a Figura 3. A idia vericar se existe um subconjunto
desses tens cujo tamanho total seja exatamente S . Numa soluo por diviso e
conquista, devemos ter problemas menores da mesma natureza. Podemos Generalizar para a situao em que temos i tens e o tamanho total j . Para saber se
retornamos verdadeiro, temos que analisar duas possibilidades:
1. O i-simo tem usado para completar o tamanho j .
2. O i-simo item no usado e, portanto j alcanado at os i 1 primeiros
tens.
Devemos usar uma tabela t[n, S] para armazenar t, caso seja possvel completar S
com os n elementos. Caso no seja possvel, preenchemos com f . Pelo denido
acima uma clula t[i, j] deve ser preenchida com t se uma das duas situaes
verdadeira:t[i 1, j si ] ou T [i 1, j]. O padro de preenchimento seria ento o
mesmo apresentado na Figura 4

Figura 4: Padro de preenchimento da tabela

Sendo assim a tabela nal teria o formato da Figura 5:
O algoritmo utilizado na implementao foi extrado de:

http://www.mpi-sb.mpg.de/ rybal/armc-live-termin/node5.html
http://www-cse.uta.edu/ holder/courses/cse2320/lectures/l15/node12.html
http://www.cse.uni.edu/ goddard/Courses/CSCE310J

Figura 5: Formato Final da Tabela

Metodo_Dinmico(v[1..n], w[1..n], n, W )

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

for w 0 to W
do

c[0, w] 0
for i 1 to n

do

c[i, 0] = 0
for i 1 to n

do

for w 1 to W
do
if w[i] w
then
if v[i] + c[i 1, w w[i]] > c[i 1, w]
then

c[i, w] = v[i] + c[i 1, w w[i]]

else c[i, w] = c[i 1, w]
else c[i, w] = c[i 1, w]

Podemos deduzir a complexidade deste algoritmo atravs da manipulao que executada em cada lao, sendo que os dois laos iniciais so apenas para inicializar a
tabela, sendo o lao da linha 1 a 3 da ordem O(W ), onde W a capacidade da
Mochila, e o lao da linha 4 a 6 da ordem O(n), onde n o nmero de tens. Os
laos seguintes realizam a construo da tabela, o lao da linha 7 a 17 executa O(n)
e o lao da linha 9 a 17 executa O(W ) vezes, sendo este algoritmo da ordem de
O(n W ). O algoritmo acima encontra apena o maior valor possvel que pode ser
alocado na Mochila, para saber quais os tens que tornam este valor mximo outro
algoritmo foi implementado:

Backtrace(n, W )

1
2
3
4
5
6
7
8
9

in
jM
while ((i > 0)&(j > 0))
do if (c[i, j] <> c[i 1, j])
then X[i] 1
j j w[i]
i
else X[i] 0
i

4 Soluo usando o Mtodo Guloso

O mtodo Guloso a tcnica de projeto mais simples que pode ser aplicada a uma
grande variedade de problemas. A grande maioria destes problemas possui n entradas e requerido obter um subconjunto que satisfaa alguma restrio. Qualquer
subconjunto que satisfaa esta restrio chamado de soluo vivel. Queremos
ento encontrar uma soluo vivel que maximize ou minimize uma dada funo
objetivo. Uma soluo vivel que satisfaa a funo objetivo chamada de soluo
tima. Existem maneiras bvias de determinar uma soluo vivel, mas no necessariamente uma soluo tima[4]. O mtodo Guloso sugere que podemos construir
uma algoritmo que trabalhe em estgios, considerando uma entrada por vez. Em
cada estgio, uma deciso tomada considerando se uma entrada particular uma
soluo tima. Isto conseguido considerando as entradas numa ordem determinada por algum processo de seleo. Se a incluso da prxima entrada na soluo
tima construda parcialmente resultar numa soluo invivel, ento esta entrada
no ser adicionada a soluo parcial. O processo de seleo em si baseada em
alguma medida de otimizao. Esta medida pode ou no ser a funo objetivo. Na
verdade vrias medidas de otimizao diferentes podem aplicveis para um determinado problema. Muitas destas, entretanto, resultaro em algoritmos que geraro
soluo sub-timas.
O algoritmo escolhido para esta implementao usa a estratgias gulosas mais interessante, de acordo com [4], este estratgia faz uma negociao entre a taxa em que
a utilidade decresce e o peso usado. Em cada passo ser includo um objeto que
tem a maior utilidade pro unidade de peso usado. Isto signica que o objeto ser
considerado na ordem decrescente da Maior Utilidade sobre o Peso (U (i)/P (i)). Se
os objetos estiverem ordenado numa ordem decrescente de Utilidade sobre o Peso
(U (i)/P (i) U (i + 1)/P (i + 1)) o algoritmo abaixo, extraido de [4] e adaptado a
partir da linha 9 a 13 para resolver o problema da Mochila 0/1, resolve o problema
da Mochila usando a estratgia gulosa. Sem considerar o tempo de ordenao da
entrada, que na implementao foi usado o algoritmo do quicksort extrado do livro
[6], o algoritmo abaixo executa a estratgia gulosa em tempo O(N ). Esse algoritmo
realiza os seguintes passos:

o vetor soluo X inicializado;

a capacidade utilizada da mochila armazenado em cum;
10

 O primeiro lao F OR, da linha 3 a 8, colocando cada tem na mochila, subtraindo o peso do tem do valor de cum. Isso feito at que a cum no comporte
o prximo peso. Neste ponto todos os tem de maior relao U (i)/P (i) foram
colocado na Mochila.
O segundo lao F OR, da linha 9 a 13, muda de estratgia e procura nos tens
restantes aquele(s) que possua um peso que caiba no valor restante de cum
para preencher o espao da Mochila.
Metodo_Guloso(U [1..n], P [1..n], M, n)

1
2
3
4
5
6
7
8
9
10
11
12
13

X0
cum M
for i 1 to n

do

if P (i) > cum

then Exit;

X(i) 1;
cum cum P (i)
for j i to n

do

if P (j) <= cum

then X(i) 1;

cum cum P (j)

Apesar de muito muito interessante a estratgia gulosa no produz sempre solues

timas, e existem situaes bem simples que o algoritmo levado a escolher um tem
de maior relao U (i)/P (i) que no faz parte da soluo tima, como no seguinte
exemplo extrado de [1], com n = 3 e M = 50:
n
U
P
U/P
X

1
60
10
6
0

2
100
20
5
0

3
120
30
4
0

Sempre que o algoritmo guloso for usado o tem nmero 1 ser colocado na Mochila,
devido ao seu valor maior que os demais, sendo que este tem no leva a uma soluo.
Sendo que o valor timo neste exemplo 220, e os tens 2 e 3:
n
U
P
U/P
X

1
60
10
6
1

2
100
20
5
1

3
120
30
4
0

Max
160
30

n
U
P
U/P
X

1
60
10
6
1

2
100
20
5
0

3
120
30
4
1

Max
180
40

n
U
P
U/P
X

1
60
10
6
0

2
100
20
5
1

3
120
30
4
1

5 Comparao entre os Mtodos

Neste trabalho zemos os teste considerando a correlao entre os Pesos e as Utilidades que foram gerados aleatoriamente, conforme citado em [4] e [5]. Os testes
11

Max
220
50

foram divididos em:

Dados No-Correlacionados - nas instncias no existe correlao entre os

Pesos e as Utilidade de um item. Tais instncias ilustram as situaes onde
razovel admitir que a Utilidade no depende dos Peso, por exemplo quando
estamos fazendo uma mudana no caminho: coisas pequenas podem ser mais
valiosas que alguns tens volumosos. Instncias no correlacionadas so mais
fceis de resolver, pois existe uma grande variao ente os pesos, tornando mais
fcil obter uma Mochila cheia. Fica mais fcil eliminar numerosas variveis
pelo teste do limite ou por relaes de dominncia.
Instncias com Correlao Fraca - aqui a Utilidade altamente correlacionada
com o Peso. Tipicamente a Utilidade difere do Peso por uma faixa pequena.
Tais instncias so mais realistas em gerenciamento, desde que o retorno de um
investimento geralmente proporcional ao investimento somado com alguma
variao. Uma alta correlao signica que mais difcil eliminar variveis
pelo teste de limite. Apesar deste fato instncias correlacionadas fracamente
so mais fceis de resolver pois existe uma grande faixa de variao de Pesos,
tornando mais fcil preencher a Mochila e chegando mais perto da soluo
tima.
Instncias com Correlao Forte - Tais instncias correspondem a situaes da
vida real onde o retorno uma funo linear do investimento mais (ou menos)
alguma parte imprecisa em cada projeto. Este tipo de correlao difcil de
resolver por duas razes: 1) Todos os tens que esto prximo do item de
parada tem pesos similares, signicando que muito difcil combina-los de
maneira a encher a Mochila. 2) Existe uma grande perda relativa quando
removemos tens de pequeno peso para alocar um item de peso maior. Assim
alta correlao so utilizadas para para avaliar a capacidade do algoritmo para
resolver problemas difceis.
Para os experimentos foram usados quatro conjuntos de dados fornecidos pelo colega "David Menoti Gomes". Os conjuntos foram utilizados porque foram gerados
seguindo a orientao da referncia [4]. Sendo os dois primeiros conjuntos de dados
baseado na distribuio de dados no-correlacionados, sendo:
1. (I) Pesos e Utilidades distribudos na faixa de [1-1000];
2. (II) Pesos e Utilidades distribudos na faixa de [1-100];
O terceiro conjunto de dados o conjunto altamente correlacionado, sendo os pesos
distribudos na faixa de [1-100] e a utilidade o peso acrescido de uma valor constante, U = P + 10 (III).
O quarto conjunto de dados fracamente correlacionado, sendo os pesos distribudos
na faixa de [1-100] e a utilidade calculada como como U = 1, 1 P (IV).
Os experimentos seguiram a seguinte estratgia:

Para cada n foram feitas 5 execues, cada uma com 10 amostras, onde a
distribuio dos pesos e utilidades como denido anteriormente
n 10, 20, 30, 40, 50, 100, 200, 300, 400, 500
.
12

 Cada execuo possui uma capacidade da Mochila na faixa de

M 10%, 20%, 30%, 40%, 50%
do valor do total dos pesos.

Foram gerados arquivos com as respostas, formatados da seguinte maneira:

(Capacidade da Mochila,Media dos tempos, Maior tempo da amostra, Desvio
padro, No. Elementos).
Para cada mtodo foram gerados 10 arquivos de sada para cada conjunto de
dados, sendo cada sada para um valor de n com cinco execues variando a
capacidade da Mochila, sendo cada execuo feita 10 vezes.
Os tempos esto em segundos.

5.1 Resposta para os Conjuntos de Dados

Os testes foram divididos de acordo com os conjunto dos dados e para os conjuntos
foram gerados grcos comparativos para cada valor dos

n (10, 20, 30, 40, 50, 100, 200, 300, 400, 500)
elementos e para capacidade da mochila variando de

M (10, 20, 30, 40, 50)

do valor total dos pesos. Todos os grcos esto apresentados em anexo, apresentaremos alguns para apresentar os fatos encontrados nas execues. Foram gerados
tabelas para cada n, sendo que cada tabela apresenta o valor mdio do tempo de
resposta, o maior tempo gasto e o desvio padro da amostra, as tabelas tambm
esto em anexo.
Sendo que o tempo de execuo do algoritmo Guloso tem se mostrado bastante
competitivo quando aplicado aos conjuntos de dados I e II, como podemos observar
na gura 10, onde no existe correlao entre os Pesos e Utilidades. O algoritmo de
Backtracking tambm possui um tempo mdio bastante competitivo em relao ao
guloso. Neste caso ele sempre apresenta o valor timo juntamente com o algoritmo
dinmico, podemos vericar esta comparao na gura 7 . Sendo que quando os dados comeam a car correlacionados, como ocorre nos conjuntos III e IV, o mtodo
guloso ainda mantm uma grande competitividade no tempo de execuo, porm
ele no apresenta sempre o valor timo, todas as tabelas esto em Anexo. Podemos
vericar na tabela 8 a seguir com os valores acumulados das utilidades para uma
execuo dos trs algoritmo no conjunto de dados III, para n = (50, 100, 200, 400),
podemos notar que para este conjunto de dados, a partir de 200 elementos o algoritmo de backtracking no consegue responder num espao de tempo inferior a 10s,
e a execuo foi abortada:
Isto tambm pode ser notado na tabela 9 da execuo para o conjunto de dados
IV para n = (50, 100, 200, 400), sendo que neste caso o Backtracking no consegue
responder a partir de 100 elementos, tendo que ser abortado:
13

Comparacao entre os Metodos para n = 100

0.7
Guloso
Dinamico
Backtracking

Tempo de Resposta em segundos

0.6

0.5

0.4

0.3

0.2

0.1
10

15

20

25
30
35
40
Numero de Elementos no Vetor para DSET=1

45

50

Figura 6: Conjunto de dados I , n=100

Comparacao entre os Metodos para n = 200
0.55
Guloso
Dinamico
Backtracking

Tempo de Resposta em segundos

0.5

0.45

0.4

0.35

0.3

0.25

0.2

0.15
10

15

20

25
30
35
40
Numero de Elementos no Vetor para DSET=2

45

50

Figura 7: Conjunto de dados II , n=200

No conjunto de dados do tipo I e II o Backtracking consegue responder at
10.000 elementos, j nos conjuntos correlacionados o algoritmo de backtracking no
consegue dar uma resposta quando o valor de n chega a 200 para o conjunto III
e quando n chega a 100 para o conjunto IV. Nestes casos o algoritmo Dinmico
consegue apresentar melhores resultados. Conforme podemos observar nos grcos
gerados para os diversos valores de n, percebemos que os algoritmo so totalmente
dependentes das entradas de dados, sendo que o comportamento de cada algoritmo
pode variar bastante para o mesmo conjunto de dados. Sendo o que se apresenta
melhor o Algoritmo Dinmico, apesar dele levar mais tempo para todas as instncias o mais estvel com relao a respostas em todos os conjunto de dados.
O que podemos concluir das execues que apesar de obtermos implementaes
interessantes para o problema da Mochila, qualquer dos algoritmos construdos no
resolver de maneira satisfatria o problema. Isso j era previsto, uma vez que o
mesmo NP-Completo.

14

DIN

BACK

GUL

2
3
4
5
6
7

10
20
30
40
50

3548.00
6368.00
9018.00
11617.00
14151.00

3548.00 3407.00 50
6368.00 6155.00 50
9018.00 8719.00 50
11617.00 11382.00 50
14151.00 13813.00 50

10
20
30
40
50

7206.00
12839.00
18235.00
23491.00
28658.00

7206.00
12839.00
18235.00
23491.00
28658.00

10
20
30
40
50
10
20
30
40
50

8
9
10
11
12
13

7095.00
12652.00
18025.00
23229.00
28353.00

100
100
100
100
100

14515.00
25872.00
36675.00
47200.00
57529.00

14322.00
25699.00
36453.00
46964.00
57240.00

200
200
200
200
200

29204.00
52097.00
73881.00
95073.00
115910.00

29061.00
51898.00
73570.00
94710.00
115741.00

400
400
400
400
400

14
15
16
17
18
19
20
21
22
23
24
25

Figura 8: Tabela com tempo de execuo para Conjunto de dados III

6 Estruturas de Dados
Para a implementao dos trs mtodos citados acima, foi construda uma nica
estrutura de dados que foi utilizadas nas implementaes. Construmos um nico
vetor que armazena os pesos, as utilidades, uma chave que utilizada na rotina
de ordenao, com o objetivo de manter o vetor na ordem decrescente da relao
Utilidade/Peso, mantemos tambm alguns campos que armazenavam a soluo que
ser atualizada para cada mtodo, esta estrutura contm os seguintes tens:

Um tipo registro (struct) para cada tem, contendo o valor da Importncia, o

Peso, e uma Chave contendo a relao I/P, e trs valores para armazenar o
resultado para cada mtodo, sendo 1-faz parte da soluo, 0-no faz parte da
soluo: ResultG, ResultB, ResultD.
Uma estrutura do chamada Vetor, que um array de tens, para armazenar
os n elementos com suas Utilidades e Pesos.
Na execuo do programa podemos denir se a entrada ser feita via arquivo ou ser
gerada internamente, este controle feito via a varivel LeArquivo. Se LeArquivo =
1 a entrada via arquivo, se LeArquivo = 0 a entrada ser gerada internamente,
atravs do procedimento GeraV etor. Neste caso o valor da capacidade da Mochila
15

DIN

BACK

GUL

2
3
4
5
6
7

10
20
30
40
50

2442.00
4875.00
7298.00
9723.00
12145.00

2442.00 2419.00
4875.00 4850.00
7298.00 7280.00
9723.00 9705.00
12145.00 12122.00

50
50
50
50
50

10
20
30
40
50

5042.00
10051.00
15054.00
20052.00
25045.00

5031.00
10047.00
15051.00
20047.00
25035.00

100
100
100
100
100

10
20
30
40
50

10213.00
20347.00
30471.00
40575.00
50671.00

10212.00
20340.00
30469.00
40571.00
50670.00

200
200
200
200
200

10
20
30
40
50

20284.00
40427.00
60540.00
80626.00
100686.00

20283.00
40427.00
60538.00
80625.00
100686.00

400
400
400
400
400

8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

Figura 9: Tabela com tempo de execuo para Conjunto de dados IV

calculado como metade do total dos pesos, conforme arquivo fonte em anexo.
O valor dos pesos e das utilidades, quando gerados internamente, so gerados numa
faixa controlada pela constante N que pode ser alterada. A capacidade do vetor
denido pela constante M axT am, sendo que este valor o limite e a quantidade
dos objeto na Mochila so denidos pela varivel N oElementos.

16

Comparacao entre os Metodos para n = 100

0.7
Guloso
Dinamico
Backtracking

Tempo de Resposta em segundos

0.6

0.5

0.4

0.3

0.2

0.1
10

15

20

25
30
35
40
Numero de Elementos no Vetor para DSET=1

45

50

Figura 10: Conjunto de dados I , n=100

Comparacao entre os Metodos para n = 100
0.65
Guloso
Dinamico
Backtracking

0.6

Tempo de Resposta em segundos

0.55

0.5

0.45

0.4

0.35

0.3

0.25

0.2
10

15

20

25
30
35
40
Numero de Elementos no Vetor para DSET=2

45

50

Figura 11: Conjunto de dados II , n=100

Referncias
[1] Thomas H. Cormen, Charles E. Leiserson, and Ronald L. Rivest. Introduction
to Algorithms. MIT Press/McGraw-Hill, 1990.
[2] Pierluigi Crescenzi and Viggo Kann. A compendium of NP-optimization problems
http://www.nada.kth.se/ viggo/wwwcompendium/wwwcompendium.html.
[3] Michael R. Garey and David S. Johnson. Computers and Intractability: A Guide
to the Theory of NP-Completeness. W. H. Freeman, 1979.
[4] Ellis Horowitz and Sartaj Sahni. Fundamentals of Computer Algorithms. Computer Science Press, 1978.
[5] David Pisinger. Algorithms fo Knapsack Problems. PhD thesis, Department of
Computer Science, University of Copenhagen, February 1995.

17

Comparacao entre os Metodos para n = 100

3.5
Guloso
Dinamico
Backtracking

Tempo de Resposta em segundos

2.5

1.5

0.5

0
10

15

20

25
30
35
40
Numero de Elementos no Vetor para DSET=3

45

50

Figura 12: Conjunto de dados III , n=100

Comparacao entre os Metodos para n = 100
0.7
Guloso
Dinamico

Tempo de Resposta em segundos

0.6

0.5

0.4

0.3

0.2

0.1
10

15

20

25
30
35
40
Numero de Elementos no Vetor para DSET=4

45

50

Figura 13: Conjunto de dados IV , n=100

[6] Nivio Ziviane. Projeto de Algoritmos: com implementaes em Pascal e C.
Pioneira Thomson Learning, 2ed., 2004.

18

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#define MaxTam 1000 //Tamanho mximo do Vetor

#define N 500
//Maior valor Aleatorio
#define NoElementos 300//Quantidade de Elementos para a Mochila
#define LeArquivo 1
// 1 - via arquivo, 0-Gerado Randomicamente
typedef int Valor;
typedef struct Item {
Valor Importancia;
Valor Peso;
float Chave;
short ResultG;
short ResultB;
short ResultD;
} Item;
typedef int Indice;//Vetor de Registros
typedef Item Vetor[MaxTam+1];
Vetor Origem;

Figura 14: Trecho de cdigo das principais denies

A Cdigo Fonte
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
26
27

/* ======================================================================
2 Trabalho Pratico de PAA - 2004-1
aluno - Ruiter Braga Caldas
Progama que Executa tres metodos para resolver o problema da mochila:
Mtodo Guloso e Backtracking desenvolvidos a aprtir do algoritmo
proposto em - E. Horowitz e S. Sahni, Fundamentals of Computer Algorithms,
Computer Science Press, 1978.
Mtodo Dinmico desenvolvido a partir dos cdigos propostos em:
http://www-cse.uta.edu/~holder/courses/cse2320/lectures/l15/node12.html
http://www.mpi-sb.mpg.de/~rybal/armc-live-termin/node5.html
====================================================================== */
#include <stdlib.h>
#include <stdio.h>
#include <sys/time.h>
#include <limits.h>
#include "time.h"
#define MaxTam 1000
//Tamanho mximo do Vetor
#define N 500
//Maior valor Aleatorio
#define NoElementos 300
//Quantidade de Elementos para a Mochila
#define LeArquivo 1
// 1 - via arquivo, 0 - Gerado Randomicamente
typedef int Valor;
/* ======================================================================
Estrutura tipo Registro que armazena os Pesos, Importancias,
Chave, e Resultados. Os resultados so armazenados de acordo com o metodo
====================================================================== */
typedef struct Item {
Valor Importancia;

19

28
29
30
31
32
33

Valor
float
short
short
short
} Item;

Peso;
Chave;
ResultG;
ResultB;
ResultD;

34
35

typedef int Indice;

36
37
38
39

//Vetor de Registros
typedef Item Vetor[MaxTam+1];
Vetor Origem;

40
41
42
43

//Peso Final do Mtodo Backtracking

float Tpeso,Timportancia;
Indice i, n, k;

44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

//Capacidade da Mochila
int M;
//Arquivos de Entrada e Saida
FILE* fp;
FILE* fs;
/* ======================================================================
Funo QuickSort disponibilizada no livro
do Prof. Nivio Ziviane.(Projeto de Algoritmos/2004).
Foi Alterada para fazer a ordenacao Crescente.
====================================================================== */
void Particao(Indice Esq, Indice Dir, Indice *i, Indice *j, Item *A)
{ Item x, w;
*i = Esq; *j = Dir;
x = A[(*i + *j) / 2];
/* obtem o pivo x */
do
{ while (x.Chave < A[*i].Chave) (*i)++;
while (x.Chave > A[*j].Chave) (*j)--;
if (*i <= *j)
{ w = A[*i]; A[*i] = A[*j]; A[*j] = w;
(*i)++; (*j)--;
}
} while (*i <= *j);
}

68
69
70
71
72
73
74
75
76
77

void Ordena(Indice Esq, Indice Dir, Item *A)

{ Indice i, j;
Particao(Esq, Dir, &i, &j, A);
if (Esq < j) Ordena(Esq, j, A);
if (i < Dir) Ordena(i, Dir, A);
}
void QuickSort(Item *A, Indice *n)
{ Ordena(1, *n, A);
}

20

78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

/* ======================================================================
O cdigo foi copiado da biblioteca random
de Eric Roberts.(The Art and Science of C)
======================================================================
int RandomInteger (int low, int high)
{
double k;
double d;
d = (double) rand () / ((double) RAND_MAX + 1);
k = d * (high - low + 1);
return (int)(low + k);
}
/* ======================================================================
Funo que faz a impresso dos Pesos e Importancias no Mtod Guloso
A impresso dirigida pelo Valor de ResultG
======================================================================
void ImprimeGuloso(Item *V, Indice *n)
{ int Tp;
int Ti;
Tp=0;
Ti=0;
for (i = 1; i <= *n; i++)
{
if (V[i].ResultG)
fprintf(fs," %d %d\n",V[i].Peso,V[i].Importancia);
}
}
/* ======================================================================
Funo que faz a impresso dos Pesos e Imports. no Mtod Backtracking
A impresso dirigida pelo Valor de ResulB
======================================================================
void ImprimeBack(Item *V, Indice *n, double Tp, double Ti)
{
for (i = 1; i <= *n; i++)
{
if (V[i].ResultB)
fprintf(fs,"%d %d\n",V[i].Peso,V[i].Importancia);
}
}
/* ======================================================================
Funo que faz a impresso dos Pesos e Importancias no Mtod Dinmico
A impresso dirigida pelo Valor do ResulD
======================================================================
void ImprimeDinamico(Item *V, Indice *n)
{int Tp;
int Ti;
Tp=0;
Ti=0;
for (i = 1; i <= *n; i++)
{

21

*/

*/

*/

*/

128
129
130
131

if (V[i].ResultD)
fprintf(fs," %d %d\n",V[i].Peso,V[i].Importancia);

132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177

void CopiaDois(int Fonte[],Item *Destino, Indice *n)

{ for (i = 1; i <= *n; i++)
Destino[i].ResultB = Fonte[i];
}
/* ======================================================================
Funo que Gera Randomicamente o Vetor com os Pesos e Importancias,
faz o calculo da Chave=Importancia/Peso e Iniciaiza os Resultados.
O valor de M eh a metade do total dos pesos.
====================================================================== */
void GeraVetor(Vetor A, Indice n,int *M)
{ int i;
Valor pesoTotal;
pesoTotal=0;
for (i = 1; i <= n; i++) {
A[i].Importancia = RandomInteger(1,N);
A[i].Peso = RandomInteger(1,N);
A[i].ResultG = 0;
A[i].ResultB = 0;
A[i].ResultD = 0;
pesoTotal = pesoTotal + A[i].Peso;
A[i].Chave =(double)A[i].Importancia / (double)A[i].Peso;};
//Calcula o Valor da Mochila com 1/2 Pesos
*M=pesoTotal*1/2;
}
/* ======================================================================
Executa o Metodo Guloso
====================================================================== */
void Guloso(Vetor A, Indice n, int M)
{ int i,j, CM;
CM=M;
for (i = 1; i <= n; i++)
{
if (A[i].Peso > CM){
break;
}
A[i].ResultG = 1;
CM = CM - A[i].Peso;
}
j=i+1;
while (j <= n)
{
if (A[j].Peso <= CM)
{
CM = CM - A[j].Peso;
A[j].ResultG = 1;

22

178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202

}
j=j+1;

}
}
/* ======================================================================
Executa o Metodo Dinmico
====================================================================== */
//funcao Limite para o mtodo
float Bound(Vetor A,float p, float w, int k, float M)
{
float b,c;
b = p;
c = w;
for (i = k + 1; i <= n; i++)
{
c = c + A[i].Peso;
if (c <= M){ b = b + A[i].Importancia;
}
else return (b + (1 -((c - M)/A[i].Peso))*A[i].Importancia);
}
return(b);
}
void BKnap(float M, Indice n, Vetor A, float *fw, float *fp)
{ int k, Y[n];
float cw,cp;

203
204
205
206
207

cw = 0.0;
cp = 0.0;
k = 1;
*fp = -1;

208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227

while (1)
{
while (( k <= n ) && ( (cw + A[k].Peso) <= M ))
{
cw = cw + A[k].Peso;
cp = cp + A[k].Importancia;
Y[k]= 1;
k = k + 1;
}
if (k > n)
{ *fp = cp;
*fw = cw;
k = n;
CopiaDois(Y,A,&n);
}
else Y[k]=0;
while (Bound(A,cp,cw,k,M) <= *fp)
{
while (k != 0 && Y[k] != 1)

23

228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246

{
k = k - 1;
};
if ( k == 0 ) return;
Y[k] = 0;
cw = cw - A[k].Peso;
cp = cp - A[k].Importancia;
}//while (Bound)
k = k + 1;
}//while(1)

}
/* ======================================================================
Executa o Metodo Dinmico
====================================================================== */
void Dinamico(Item *A, Indice n, int M)
{ int j;
int c;
int **a;
Indice i;

247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277

a = (int **) calloc(n+1,sizeof(int *));

for( i=0; i<n+1; i++ )
a[i] = (int *) calloc( M+1, sizeof(int));
//IniciaMatriz
for (i = 0; i <= n; i++)
for (j = 0; j <= M; j++) a[i][j] = -1;
//Inicializa Linha
for(c = 0; c <= M; c++)a[0][c] = 0;
//Inicializa Coluna
for(i = 0; i <= n; i++)a[i][0] = 0;
for(i = 1; i <= n; i++)
{
for (c = 1; c <= M; c++)
{
if (A[i].Peso <= c)
{
if ((A[i].Importancia + a[i-1][c-A[i].Peso]) > a[i-1][c] )
{
a[i][c] = A[i].Importancia + a[i-1][c-A[i].Peso];
}
else
{
a[i][c] = a[i-1][c];
}
}
else
{
a[i][c] = a[i-1][c];
}
}

24

278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298

}
//Calcula os elementos que fazem parte da Resposta
i=n;
j=M;
while ((i > 0) && (j > 0))
{
if (a[i][j] != a[i-1][j])
{
A[i].ResultD = 1;
j=j-A[i].Peso;
i--;
}
else{
A[i].ResultD = 0;
i--;
}
}
for( i=0; i < n+1; i++ )
free(a[i]);
free(a);
}

299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327

/* ======================================================================
Funo Principal. Deve receber como chamada a primeira letra do Metodo
G - Guloso, B - Backtracking, D - Dinamico.
A varivel LeArquivo deve ser setada antes:
1 - Le os dados do arquivo chamado avaliacao.tp2
0 - Gera os dados num vetor de Pesos e Importancias
Quando os dados sao gerados, a quantidade de elementos no vetor de
pesos/importancias fica determinada pela variavel NoElementos=200.
O peso da Mochila( M ) fica determinado pela metade das soma dos pesos
gerados.
O tamanho do maior vetor eh determinado pela varivel MaxTam=1000
O faixa de valore para os pesos/importancias eh determinado pela
variavel N=500.
====================================================================== */
int main(int argc, char * argv[])
{
srand((int)time(NULL));
//Inicializa a Capacidade da Mochila
M=0;
//Verifica se a entrada sera via Arquivo ou Geracao Randomica
if (LeArquivo)
{
if ((fp = fopen("avaliacao.tp2", "r")) == NULL)
fprintf(stderr, "ERRO na Abertura do Arquivo de Entrada\n");
else
{
printf("Arquivo de Entrada aberto com Sucesso.\n");
i = 1 ;

25

328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377

//Le o numero de elementos do Vetor

fscanf(fp, "%d", &n);
fscanf(fp, "%d", &M);
while(!feof(fp) && i <=n)
{
/* */
fscanf(fp, "%d", &Origem[i].Peso);
fscanf(fp, "%d", &Origem[i].Importancia);
Origem[i].Chave =(double)Origem[i].Importancia /
(double)Origem[i].Peso;
i++;
}

}
}
else
{
//Numero de elementos do Vetor
n=NoElementos;
// Gera o Vetor com os Pesos, Importancia
// e Calcula a Capacidade da Mochila
GeraVetor(Origem,n,&M);
}
if (argc == 1) fprintf(stderr,"ERRO: Precisa Informar um Metodo (G/B/D) \n");
else{
//Ordena em Orden Crescente de Imp/Peso
QuickSort(Origem,&n);
switch (*argv[1]){
case 'G'://Chama Metodo Guloso
fprintf(stderr, "Guloso\n");
startTimer();
Guloso(Origem,n,M);
finishTimer();
showTimes();
//Abre o Arquivo de Saida
if ((fs = fopen("saidag", "w")) == NULL)
fprintf(stderr, "ERRO na Abertura do Arquivo de Saida\n");
ImprimeGuloso(Origem,&n);
break;
case 'B'://Chama Metodo Backtracking
fprintf(stderr, "Backtracking\n");
Tpeso = 0.0;
Timportancia = 0.0;
startTimer();
BKnap(M,n,Origem,&Tpeso,&Timportancia);
finishTimer();
showTimes();
//Abre o Arquivo de Saida
if ((fs = fopen("saidab", "w")) == NULL)
fprintf(stderr, "ERRO na Abertura do Arquivo de Saida\n");
ImprimeBack(Origem,&n,Tpeso,Timportancia);

26

378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395

break;
case 'D'://Chama Metodo Dinmico
fprintf(stderr, "Dinamico\n");
startTimer();
Dinamico(Origem, n, M);
finishTimer();
showTimes();
//Abre o Arquivo de Saida
if ((fs = fopen("saidad", "w")) == NULL)
fprintf(stderr, "ERRO na Abertura do Arquivo de Saida\n");
ImprimeDinamico(Origem, &n);
break;
default :fprintf(stderr,"ERRO: Mtodo No informado (G/B/D) \n");
}}
fclose(fp);
fclose(fs);
return 0;

396

B Tabelas com tempos de execuo

B.1 Mtodo Guloso
B.1.1 Conjunto I
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

M
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20

media
0.256
0.278
0.244
0.256
0.422
0.667
0.333
0.511
0.589
0.622
0.344
0.489
0.511
0.500
0.489
0.767
0.411
0.233
0.422
0.367
0.589
0.400

max
0.700
0.500
0.500
0.600
1.000
1.000
1.000
1.000
1.000
1.000
1.000
1.000
1.000
1.000
1.000
1.000
1.000
0.500
1.000
1.000
1.000
1.000

desv.
0.059
0.024
0.059
0.059
0.236
0.354
0.141
0.519
0.436
0.342
0.153
0.306
0.118
0.530
0.306
0.247
0.224
0.035
0.236
0.177
0.436
0.212

n
10
10
10
10
10
20
20
20
20
20
30
30
30
30
30
40
40
40
40
40
50
50

27

24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50

0.300
0.411
0.311
0.322
0.233
0.244
0.322
0.244
0.289
0.400
0.389
0.400
0.444
0.367
0.344
0.478
0.456
0.411
0.422
0.511
0.433
0.433
0.501
0.433
0.489
0.644
0.500
0.533

0.500
1.000
1.000
0.500
0.500
0.400
0.500
0.600
0.500
0.600
0.900
0.800
0.700
0.900
0.600
0.700
0.900
0.700
0.800
0.900
0.700
0.700
0.700
0.700
0.700
0.900
0.800
0.700

0.106
0.625
0.118
0.130
0.035
0.047
0.024
0.047
0.094
0.106
0.012
0.106
0.059
0.071
0.047
0.130
0.059
0.012
0.401
0.118
0.035
0.035
0.107
0.035
0.012
0.259
0.000
0.035

50
50
50
100
100
100
100
100
200
200
200
200
200
300
300
300
300
300
400
400
400
400
400
500
500
500
500
500

B.1.2 Conjunto II
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

M
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30

media
0.244
0.256
0.256
0.233
0.322
0.244
0.767
0.667
0.356
0.500
0.489
0.600
0.511
0.667
0.422
0.356
0.400
0.578

max
0.500
0.600
0.500
0.500
1.000
0.600
1.000
1.000
1.000
1.000
1.000
1.000
1.000
1.000
1.000
1.000
1.000
1.000

desv.
0.047
0.059
0.059
0.035
0.719
0.047
0.601
0.354
0.165
0.318
0.306
0.424
0.519
0.495
0.024
0.684
0.212
0.401

n
10
10
10
10
10
20
20
20
20
20
30
30
30
30
30
40
40
40

28

20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50

0.289
0.500
0.411
0.467
0.489
0.578
0.356
0.222
0.233
0.322
0.267
0.278
0.378
0.289
0.300
0.378
0.367
0.333
0.411
0.433
0.356
0.467
0.467
0.422
0.388
0.556
0.456
0.422
0.524
0.478
0.511
0.722

0.700
1.000
1.000
1.000
1.000
1.000
1.000
0.400
0.400
0.500
0.600
0.600
0.600
0.500
0.500
0.600
0.800
0.600
0.600
0.800
0.600
0.700
0.800
0.700
0.600
1.000
0.700
0.600
0.700
0.700
0.800
1.000

0.094
0.318
0.224
0.283
0.306
0.401
0.165
0.024
0.035
0.130
0.071
0.082
0.024
0.012
0.000
0.024
0.071
0.035
0.094
0.035
0.059
0.141
0.071
0.024
0.210
0.059
0.059
0.024
0.132
0.082
0.012
0.236

40
40
50
50
50
50
50
100
100
100
100
100
200
200
200
200
200
300
300
300
300
300
400
400
400
400
400
500
500
500
500
500

B.1.3 Conjunto III

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

M
10
20
30
40
50
10
20
30
40
50
10
20
30
40

media
0.222
0.233
0.244
0.244
0.244
0.578
0.489
0.522
0.422
0.489
0.522
0.256
0.278
0.244

max
0.400
0.500
0.500
0.500
0.500
1.000
1.000
1.000
1.000
1.000
1.000
0.500
0.600
0.500

desv.
0.024
0.035
0.047
0.047
0.047
0.448
0.306
0.342
0.236
0.306
0.236
0.059
0.024
0.047

n
10
10
10
10
10
20
20
20
20
20
30
30
30
30

29

16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50

0.511
0.567
0.522
0.422
0.400
0.400
0.278
0.411
0.311
0.344
0.489
0.222
0.300
0.233
0.222
0.322
0.267
0.289
0.400
0.322
0.322
0.433
0.411
0.367
0.467
0.456
0.400
0.467
0.500
0.478
0.500
0.567
0.489
0.522
0.593
0.556

1.000
1.000
1.000
1.000
1.000
1.000
0.600
1.000
1.000
1.000
1.000
0.400
0.500
0.400
0.400
0.600
0.500
0.500
0.500
0.500
0.500
0.600
0.800
0.600
0.700
0.900
0.600
0.700
0.900
0.700
0.700
0.900
0.800
0.800
0.800
0.800

0.519
0.460
0.130
0.613
0.212
0.212
0.082
0.625
0.118
0.695
0.306
0.024
0.106
0.035
0.024
0.130
0.071
0.094
0.000
0.024
0.024
0.071
0.012
0.035
0.141
0.059
0.000
0.141
0.106
0.082
0.212
0.177
0.012
0.024
0.099
0.059

30
40
40
40
40
40
50
50
50
50
50
100
100
100
100
100
200
200
200
200
200
300
300
300
300
300
400
400
400
400
400
500
500
500
500
500

B.1.4 Conjunto IV
1
2
3
4
5
6
7
8
9
10
11

M
10
20
30
40
50
10
20
30
40
50

media
0.267
0.233
0.256
0.322
0.411
0.400
0.578
0.422
0.667
0.400

max
0.500
0.400
0.500
1.000
1.000
1.000
1.000
1.000
1.000
1.000

desv.
0.071
0.035
0.047
0.130
0.625
0.636
0.448
0.613
0.495
0.212

n
10
10
10
10
10
20
20
20
20
20

30

12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50

0.267
0.489
0.222
0.367
0.322
0.678
0.344
0.600
0.311
0.522
0.344
0.322
0.433
0.267
0.311
0.267
0.278
0.244
0.244
0.356
0.256
0.311
0.422
0.311
0.333
0.444
0.344
0.356
0.511
0.389
0.333
0.522
0.422
0.400
0.633
0.648
0.768
0.689
0.457
0.500

0.500
1.000
0.400
1.000
1.000
1.000
1.000
1.000
1.000
1.000
1.000
1.000
1.000
0.600
1.000
0.500
0.600
0.500
0.400
0.800
0.400
0.600
0.700
0.700
0.600
0.700
0.600
0.600
0.700
0.600
0.500
0.700
0.700
0.600
0.900
0.900
0.900
0.800
0.700
0.700

0.071
0.306
0.024
0.071
0.130
0.342
0.047
0.424
0.118
0.236
0.153
0.130
0.247
0.071
0.731
0.247
0.082
0.047
0.059
0.165
0.047
0.012
0.236
0.118
0.035
0.153
0.047
0.047
0.224
0.012
0.035
0.024
0.024
0.000
0.283
0.570
0.034
0.012
0.046
0.000

30
30
30
30
30
40
40
40
40
40
50
50
50
50
50
100
100
100
100
100
200
200
200
200
200
300
300
300
300
300
400
400
400
400
400
500
500
500
500
500

B.2 Mtodo Dinmico

B.2.1 Conjunto I
1
2
3
4
5

M
10
20
30
40

media
0.407
0.234
0.361
0.482

max
1.000
0.349
0.508
0.623

desv.
0.324
0.044
0.012
0.113

n
10
10
10
10

31

6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50

0.514
0.373
0.760
0.233
0.194
0.252
0.672
0.211
0.330
0.448
0.616
0.210
0.445
0.693
0.856
0.158
0.323
0.556
0.227
0.225
0.160
0.125
0.256
0.388
0.555
0.654
0.518
0.112
0.157
0.214
0.271
0.119
0.235
0.351
0.474
0.590
0.211
0.417
0.637
0.864
1.492
0.322
0.635
0.961
1.303
1.636

0.683
0.466
0.967
0.944
0.250
0.319
0.976
0.253
0.389
0.524
0.721
0.239
0.509
0.784
0.977
0.203
0.351
0.685
0.976
0.982
0.179
0.136
0.279
0.430
0.620
0.711
0.570
0.122
0.171
0.230
0.304
0.130
0.274
0.370
0.500
0.629
0.217
0.432
0.678
0.911
1.959
0.336
0.675
0.989
1.383
1.692

0.044
0.028
0.032
0.111
0.010
0.009
0.154
0.023
0.027
0.031
0.001
0.006
0.045
0.089
0.083
0.026
0.029
0.478
0.134
0.090
0.014
0.011
0.024
0.045
0.068
0.061
0.002
0.011
0.000
0.006
0.007
0.008
0.012
0.018
0.025
0.029
0.015
0.031
0.052
0.076
0.528
0.005
0.010
0.030
0.026
0.059

10
20
20
20
20
20
30
30
30
30
30
40
40
40
40
40
50
50
50
50
50
100
100
100
100
100
200
200
200
200
200
300
300
300
300
300
400
400
400
400
400
500
500
500
500
500

32

B.2.2 Conjunto II
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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

M
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30

media
0.226
0.374
0.481
0.508
0.552
0.450
0.712
0.132
0.175
0.227
0.717
0.191
0.302
0.378
0.475
0.183
0.355
0.537
0.756
0.625
0.258
0.539
0.815
0.115
0.149
0.395
0.237
0.368
0.508
0.651
0.514
0.202
0.165
0.221
0.283
0.118
0.243
0.367
0.490
0.611
0.213
0.435
0.645
0.865
0.108
0.337
0.677
0.299

max
0.360
0.460
0.600
0.670
0.660
0.630
1.000
0.173
0.225
0.275
0.930
0.245
0.397
0.488
0.612
0.230
0.463
0.687
0.931
0.994
0.305
0.609
0.930
0.124
0.170
0.968
0.258
0.399
0.555
0.692
0.544
0.953
0.173
0.238
0.293
0.124
0.254
0.380
0.508
0.634
0.226
0.464
0.678
0.912
0.115
0.353
0.713
0.990

desv.
0.079
0.027
0.084
0.040
0.051
0.042
0.104
0.011
0.015
0.026
0.225
0.005
0.019
0.001
0.003
0.016
0.016
0.021
0.034
0.314
0.013
0.045
0.052
0.009
0.012
0.299
0.015
0.025
0.050
0.039
0.004
0.099
0.001
0.003
0.000
0.005
0.001
0.010
0.015
0.015
0.000
0.007
0.001
0.008
0.000
0.007
0.016
0.207

n
10
10
10
10
10
20
20
20
20
20
30
30
30
30
30
40
40
40
40
40
50
50
50
50
50
100
100
100
100
100
200
200
200
200
200
300
300
300
300
300
400
400
400
400
400
500
500
500

33

50
51

40 0.135 0.141 0.004 500

50 0.171 0.179 0.005 500

B.2.3 Conjunto III

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

M
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40

media
0.239
0.402
0.520
0.578
0.533
0.467
0.622
0.136
0.180
0.230
0.485
0.210
0.317
0.426
0.530
0.175
0.352
0.524
0.625
0.720
0.259
0.532
0.817
0.209
0.147
0.209
0.239
0.382
0.524
0.668
0.501
0.106
0.163
0.219
0.273
0.119
0.243
0.367
0.489
0.612
0.214
0.427
0.644
0.862

max
0.430
0.600
0.750
0.910
0.700
0.640
0.930
0.157
0.213
0.267
1.000
0.268
0.402
0.545
0.663
0.254
0.509
0.742
0.783
0.998
0.302
0.665
0.881
0.953
0.167
0.983
0.274
0.419
0.582
0.718
0.532
0.113
0.172
0.232
0.290
0.124
0.250
0.382
0.502
0.629
0.225
0.451
0.675
0.908

desv.
0.054
0.008
0.021
0.019
0.071
0.004
0.547
0.008
0.015
0.033
0.472
0.017
0.001
0.043
0.045
0.010
0.067
0.088
0.033
0.049
0.015
0.141
0.037
0.095
0.022
0.099
0.014
0.032
0.061
0.042
0.001
0.002
0.001
0.000
0.000
0.000
0.000
0.001
0.006
0.003
0.001
0.006
0.008
0.008

n
10
10
10
10
10
20
20
20
20
20
30
30
30
30
30
40
40
40
40
40
50
50
50
50
50
100
100
100
100
100
200
200
200
200
200
300
300
300
300
300
400
400
400
400

34

46
47
48
49
50
51

50
10
20
30
40
50

0.109
0.337
0.674
0.301
0.136
0.171

0.113
0.347
0.691
0.999
0.140
0.175

0.000
0.004
0.009
0.209
0.002
0.002

400
500
500
500
500
500

B.2.4 Conjunto IV
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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

M
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50

media
0.231
0.389
0.520
0.573
0.712
0.472
0.795
0.144
0.183
0.227
0.389
0.206
0.312
0.436
0.521
0.166
0.345
0.505
0.676
0.700
0.260
0.519
0.836
0.210
0.143
0.112
0.241
0.372
0.517
0.665
0.509
0.108
0.165
0.218
0.275
0.119
0.239
0.356
0.476
0.597

max
0.400
0.480
0.590
0.760
0.850
0.640
0.960
0.176
0.232
0.283
0.980
0.277
0.412
0.559
0.677
0.210
0.420
0.630
0.821
0.972
0.334
0.638
0.960
0.971
0.160
0.125
0.261
0.410
0.570
0.721
0.534
0.112
0.171
0.229
0.299
0.129
0.256
0.389
0.517
0.644

desv.
0.062
0.065
0.074
0.198
0.146
0.066
0.016
0.025
0.020
0.027
0.585
0.023
0.033
0.060
0.059
0.021
0.050
0.061
0.090
0.084
0.025
0.046
0.096
0.115
0.012
0.009
0.000
0.007
0.010
0.002
0.007
0.001
0.001
0.007
0.011
0.002
0.012
0.006
0.012
0.015

n
10
10
10
10
10
20
20
20
20
20
30
30
30
30
30
40
40
40
40
40
50
50
50
50
50
100
100
100
100
100
200
200
200
200
200
300
300
300
300
300

35

42
43
44
45
46
47
48
49
50
51

10
20
30
40
50
10
20
30
40
50

0.216
0.430
0.643
0.856
0.107
0.332
0.667
0.495
0.133
0.168

0.244
0.455
0.660
0.889
0.111
0.337
0.679
0.996
0.135
0.171

0.001
0.011
0.015
0.027
0.003
0.002
0.010
0.530
0.001
0.003

400
400
400
400
400
500
500
500
500
500

B.3 Mtodo Backtracking

B.3.1 Conjunto I
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
26
27
28
29
30
31
32
33
34
35

M
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40

media
0.444
0.500
0.522
0.522
0.522
0.568
0.578
0.644
0.672
0.637
0.606
0.297
0.506
0.634
0.493
0.414
0.383
0.283
0.158
0.328
0.541
0.197
0.221
0.258
0.218
0.247
0.431
0.487
0.454
0.595
0.513
0.506
0.172
0.148

max
0.800
0.800
0.900
1.000
1.000
0.900
1.000
1.000
0.900
0.900
0.800
0.800
0.900
1.000
1.000
1.000
0.900
0.900
0.200
0.900
1.000
0.310
0.460
0.660
0.370
0.450
0.700
0.670
0.690
0.890
0.830
1.000
0.650
0.224

desv.
0.047
0.106
0.024
0.130
0.130
0.178
0.189
0.271
0.183
0.067
0.112
0.534
0.206
0.037
0.113
0.280
0.548
0.654
0.019
0.220
0.381
0.049
0.044
0.082
0.082
0.025
0.181
0.156
0.005
0.143
0.177
0.237
0.051
0.046

n
10
10
10
10
10
20
20
20
20
20
30
30
30
30
30
40
40
40
40
40
50
50
50
50
50
100
100
100
100
100
200
200
200
200

36

36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50

0.196
0.281
0.187
0.220
0.269
0.300
0.207
0.285
0.355
0.515
0.541
0.239
0.490
0.616
0.497
0.733

0.276
0.930
0.390
0.296
0.368
0.390
0.345
0.481
0.432
0.650
0.693
0.326
0.599
0.920
0.884
0.967

0.016
0.161
0.068
0.057
0.033
0.050
0.004
0.078
0.064
0.143
0.132
0.057
0.106
0.322
0.410
0.194

200
300
300
300
300
300
400
400
400
400
400
500
500
500
500
500

B.3.2 Conjunto II
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
26
27
28
29
30
31

M
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50

media
0.422
0.456
0.533
0.467
0.333
0.480
0.508
0.611
0.622
0.643
0.722
0.617
0.310
0.582
0.683
0.602
0.563
0.377
0.317
0.392
0.337
0.286
0.271
0.164
0.252
0.299
0.381
0.481
0.437
0.394

max
0.800
0.700
0.800
0.700
0.600
0.800
1.000
1.000
0.900
1.000
1.000
0.900
0.900
1.000
1.000
1.000
0.800
1.000
0.800
0.900
0.900
1.000
0.800
0.220
0.380
0.490
0.600
0.600
0.860
0.540

desv.
0.130
0.059
0.141
0.177
0.035
0.085
0.220
0.224
0.130
0.378
0.295
0.018
0.127
0.448
0.194
0.210
0.145
0.343
0.513
0.289
0.209
0.123
0.211
0.048
0.019
0.115
0.126
0.266
0.007
0.078

n
10
10
10
10
10
20
20
20
20
20
30
30
30
30
30
40
40
40
40
40
50
50
50
50
50
100
100
100
100
100

37

32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50

0.568
0.501
0.297
0.335
0.153
0.525
0.291
0.203
0.239
0.332
0.220
0.287
0.309
0.445
0.511
0.273
0.367
0.450
0.645
0.688

0.860
0.780
0.950
0.990
0.235
0.970
0.960
0.246
0.348
0.446
0.282
0.469
0.395
0.602
0.753
0.391
0.603
0.552
0.909
0.763

0.097
0.126
0.194
0.219
0.035
0.397
0.144
0.004
0.020
0.081
0.002
0.055
0.046
0.016
0.041
0.117
0.108
0.046
0.280
0.025

200
200
200
200
200
300
300
300
300
300
400
400
400
400
400
500
500
500
500
500

B.3.3 Conjunto III

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
26
27

M
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10

media
0.600
0.516
0.569
0.413
0.427
0.373
0.356
0.378
0.394
0.423
0.355
0.343
0.310
0.322
0.338
0.291
0.434
0.452
0.364
0.356
0.505
0.495
0.256
0.385
0.398
0.406

max
0.900
1.000
0.800
0.700
1.000
1.000
0.800
0.990
0.700
1.000
0.520
0.650
0.700
0.840
0.770
0.470
0.961
0.970
0.787
0.930
0.800
0.840
0.489
0.916
0.723
0.736

desv.
0.000
0.123
0.033
0.226
0.396
0.152
0.154
0.242
0.324
0.305
0.101
0.326
0.026
0.550
0.295
0.169
0.559
0.352
0.006
0.235
0.313
0.387
0.155
0.022
0.200
0.343

n
10
10
10
10
10
20
20
20
20
20
30
30
30
30
30
40
40
40
40
40
50
50
50
50
50
100

38

28
29
30
31
32

20
30
40
50
10

0.342 0.812 0.498 100

1.218 7.314 1.094 100
3.197 11.623 2.181 100
1.906 11.841 1.004 100
41.021 108.697 42.888 200

B.3.4 Conjunto IV
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
26
27

M
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10
20
30
40
50
10

media
0.700
0.234
0.189
0.318
0.274
0.447
0.479
0.469
0.435
0.373
0.447
0.417
0.337
0.512
0.400
0.270
0.474
0.375
0.496
0.420
0.474
0.299
0.395
0.331
0.358
0.588

max
1.000
0.800
0.300
1.000
0.400
1.000
1.000
0.890
0.910
0.730
0.970
0.850
0.773
0.900
0.900
0.716
0.883
0.754
0.800
0.754
0.910
0.649
0.800
0.528
0.740
1.553

desv.
0.106
0.121
0.086
0.002
0.027
0.028
0.012
0.306
0.503
0.026
0.050
0.143
0.462
0.030
0.530
0.159
0.111
0.035
0.144
0.274
0.130
0.085
0.222
0.142
0.405
0.390

n
10
10
10
10
10
20
20
20
20
20
30
30
30
30
30
40
40
40
40
40
50
50
50
50
50
100

C Tabelas com Utilidade Acumulada

C.1 Conjunto I
1
2
3
4
5
6

10
20
30
40
50

Dinamico
14276.00
20503.00
26288.00
31148.00
34319.00

Back.
14276.00
20503.00
26288.00
31148.00
34319.00

Guloso
13463.00
20314.00
25955.00
31122.00
33893.00

10
10
10
10
10

7
8
9

10 33096.00 33096.00 32207.00 20

20 48454.00 48454.00 47708.00 20

39

10
11
12

30 59570.00 59570.00 59331.00 20

40 69157.00 69157.00 68721.00 20
50 76959.00 76959.00 76761.00 20

13
14
15
16
17
18

10
20
30
40
50

46778.00
66220.00
81565.00
94349.00
105394.00

46778.00
46244.00
66220.00
65214.00
81565.00
80927.00
94349.00
94082.00
105394.00 105237.00

30
30
30
30
30

10
20
30
40
50

61772.00
88281.00
108874.00
126150.00
141115.00

61772.00 60735.00 40
88281.00 87548.00 40
108874.00 108189.00 40
126150.00 125697.00 40
141115.00 140701.00 40

10
20
30
40
50

74270.00
108386.00
134295.00
155956.00
173403.00

74270.00
108386.00
134295.00
155956.00
173403.00

73779.00
107406.00
133837.00
155182.00
173076.00

50
50
50
50
50

10
20
30
40
50

159587.00
225225.00
276070.00
319273.00
353836.00

159587.00
225225.00
276070.00
319273.00
353836.00

159117.00
224695.00
275470.00
318824.00
353349.00

100
100
100
100
100

10
20
30
40
50

329200.00
467250.00
573983.00
661586.00
735671.00

329200.00
467250.00
573983.00
661586.00
735671.00

328781.00
466546.00
573761.00
661056.00
735181.00

200
200
200
200
200

10
20
30
40
50

491996.00
696382.00
851705.00
983043.00
1094717.00

491996.00
696382.00
851705.00
983043.00
1094717.00

491460.00
695955.00
851307.00
982816.00
1094409.00

300
300
300
300
300

10
20
30
40
50

636679.00
907682.00
1117518.00
1290594.00
1437606.00

636679.00
907682.00
1117518.00
1290594.00
1437606.00

636239.00
907330.00
1117112.00
1290068.00
1437342.00

400
400
400
400
400

10
20
30
40

837932.00
1176953.00
1435879.00
1651514.00

837932.00
1176953.00
1435879.00
1651514.00

837633.00
1176508.00
1435541.00
1651357.00

500
500
500
500

19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

40

60

50 1832626.00 1832626.00 1832218.00 500

C.2 Conjunto I
10
20
30
40
50

Dinamico Back.
1295.00 1295.00
2083.00 2083.00
2609.00 2609.00
3083.00 3083.00
3462.00 3462.00

Guloso
1277.00
2044.00
2536.00
3016.00
3448.00

10
10
10
10
10

10
20
30
40
50

2885.00
4355.00
5480.00
6349.00
7072.00

2854.00
4302.00
5431.00
6291.00
6985.00

20
20
20
20
20

10
20
30
40
50

5153.00
7268.00
8826.00
10141.00
11243.00

5153.00 5059.00 30
7268.00 7197.00 30
8826.00 8751.00 30
10141.00 10101.00 30
11243.00 11213.00 30

10
20
30
40
50

5443.00
8194.00
10455.00
12383.00
14074.00

5443.00 5377.00 40
8194.00 8186.00 40
10455.00 10411.00 40
12383.00 12358.00 40
14074.00 14047.00 40

10
20
30
40
50

7883.00
11243.00
13785.00
15914.00
17681.00

7883.00
11243.00
13785.00
15914.00
17681.00

7831.00
11194.00
13734.00
15880.00
17646.00

50
50
50
50
50

10
20
30
40
50

16965.00
24188.00
29518.00
34010.00
37893.00

16965.00
24188.00
29518.00
34010.00
37893.00

16893.00
24129.00
29450.00
33975.00
37847.00

100
100
100
100
100

10
20
30
40
50

32672.00
46526.00
57293.00
66397.00
73981.00

32672.00
46526.00
57293.00
66397.00
73981.00

32631.00
46482.00
57248.00
66372.00
73936.00

200
200
200
200
200

1
2
3
4
5
6
7
8
9
10
11
12

2885.00
4355.00
5480.00
6349.00
7072.00

13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

10 46954.00 46954.00
20 67436.00 67436.00
30 83481.00 83481.00

46922.00 300
67374.00 300
83448.00 300

41

47
48

40 96750.00 96750.00 96708.00 300

50 108015.00 108015.00 107981.00 300

49
50
51
52
53
54

10
20
30
40
50

63963.00
91576.00
112954.00
130763.00
145819.00

63963.00 63933.00 400

91576.00 91525.00 400
112954.00 112920.00 400
130763.00 130727.00 400
145819.00 145795.00 400

10
20
30
40
50

81070.00
115021.00
141652.00
164171.00
183215.00

81070.00
115021.00
141652.00
164171.00
183215.00

55
56
57
58
59
60

81031.00
114992.00
141619.00
164132.00
183186.00

500
500
500
500
500

C.3 Conjunto I
10
10
20
30
40
50

Dinamico Back.
5042.00 5042.00
638.00 638.00
1223.00 1223.00
1787.00 1787.00
2313.00 2313.00
2840.00 2840.00

Guloso
5031.00 100
536.00 10
1125.00 10
1623.00 10
2110.00 10
2674.00 10

10
20
30
40
50

1380.00
2530.00
3620.00
4656.00
5691.00

1380.00
2530.00
3620.00
4656.00
5691.00

1243.00
2338.00
3419.00
4476.00
5349.00

20
20
20
20
20

10
20
30
40
50

2166.00
3935.00
5674.00
7339.00
9011.00

2166.00
3935.00
5674.00
7339.00
9011.00

2041.00
3671.00
5506.00
7019.00
8771.00

30
30
30
30
30

10
20
30
40
50

2859.00
5165.00
7397.00
9513.00
11613.00

2859.00 2680.00
5165.00 4918.00
7397.00 7243.00
9513.00 9170.00
11613.00 11192.00

10
20
30
40
50

3548.00
6368.00
9018.00
11617.00
14151.00

3548.00 3407.00 50
6368.00 6155.00 50
9018.00 8719.00 50
11617.00 11382.00 50
14151.00 13813.00 50

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

40
40
40
40
40

26
27
28
29
30
31
32
33

10 7206.00 7206.00

7095.00 100

42

34
35
36
37

20
30
40
50

12839.00
18235.00
23491.00
28658.00

10
20
30
40
50

12839.00
18235.00
23491.00
28658.00

12652.00
18025.00
23229.00
28353.00

100
100
100
100

14515.00
25872.00
36675.00
47200.00
57529.00

14322.00
25699.00
36453.00
46964.00
57240.00

200
200
200
200
200

10
20
30
40
50

21859.00
39047.00
55396.00
71334.00
87036.00

21708.00
38885.00
55128.00
71023.00
86856.00

300
300
300
300
300

10
20
30
40
50

29204.00
52097.00
73881.00
95073.00
115910.00

29061.00
51898.00
73570.00
94710.00
115741.00

400
400
400
400
400

10
20
30
40
50

36710.00
65513.00
92992.00
119814.00
146195.00

36632.00
65315.00
92724.00
119524.00
145895.00

500
500
500
500
500

38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

C.4 Conjunto I
10
20
30
40
50

Dinamico Back.
445.00 445.00
932.00 932.00
1404.00 1404.00
1873.00 1873.00
2342.00 2342.00

Guloso
396.00
765.00
1300.00
1755.00
2259.00

10
10
10
10
10

10
20
30
40
50

1004.00
2002.00
2999.00
3998.00
4998.00

1004.00
2002.00
2999.00
3998.00
4998.00

943.00
1921.00
2917.00
3924.00
4968.00

20
20
20
20
20

10
20
30
40
50

1572.00
3141.00
4709.00
6273.00
7835.00

1572.00
3141.00
4709.00
6273.00
7835.00

1550.00
3107.00
4678.00
6236.00
7794.00

30
30
30
30
30

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

43

20
21
22
23
24

10
20
30
40
50

1953.00
3900.00
5841.00
7783.00
9721.00

1953.00
3900.00
5841.00
7783.00
9721.00

1913.00
3838.00
5826.00
7755.00
9683.00

40
40
40
40
40

10
20
30
40
50

2442.00
4875.00
7298.00
9723.00
12145.00

10
20
30
40
50
10
20
30
40
50

5042.00
10051.00
15054.00
20052.00
25045.00
10213.00
20347.00
30471.00
40575.00
50671.00

5031.00 100
10047.00 100
15051.00 100
20047.00 100
25035.00 100
10212.00 200
20340.00 200
30469.00 200
40571.00 200
50670.00 200

10
20
30
40
50

15045.00
29979.00
44890.00
59783.00
74663.00

15043.00
29978.00
44888.00
59782.00
74659.00

10
20
30
40
50

20284.00
40427.00
60540.00
80626.00
100686.00

20283.00
40427.00
60538.00
80625.00
100686.00

400
400
400
400
400

10
20
30
40
50

25368.00
50556.00
75714.00
100834.00
125928.00

25368.00
50556.00
75714.00
100834.00
125928.00

500
500
500
500
500

25
26
27
28
29
30

2442.00 2419.00
4875.00 4850.00
7298.00 7280.00
9723.00 9705.00
12145.00 12122.00

50
50
50
50
50

31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

300
300
300
300
300

48
49
50
51
52
53
54
55
56
57
58
59

44