Universidade Federal de Minas Gerais

Instituto de Ciências Exatas
Departamento de Ciência da Computação

PROJETO E ANÁLISE DE ALGORITMOS
Trabalho: disponível em:
http://www.dcc.ufmg.br/ruiter/paatp2

Ruiter Braga Caldas
Professor - Nivio Ziviani

Belo Horizonte
10 de maio de 2004

Sumário
1 O Problema da Mochila

1

2 Solução usando Backtracking

4

3 Solução usando Programação Dinâmica

6

1.1
1.2
1.3

Provar que o Problema da Mochila é NP-Completo . . . . . . . . . .
Mostrar que o Problema está em NP . . . . . . . . . . . . . . . . . .
Redução Polinomial . . . . . . . . . . . . . . . . . . . . . . . . . . . .

2
2
2

4 Solução usando o Método Guloso

10

5 Comparação entre os Métodos

11

6 Estruturas de Dados

15

A Código Fonte

19

B Tabelas com tempos de execução

27

5.1

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

B.1 Método Guloso . . .
B.1.1 Conjunto I . .
B.1.2 Conjunto II .
B.1.3 Conjunto III .
B.1.4 Conjunto IV .
B.2 Método Dinâmico . .
B.2.1 Conjunto I . .
B.2.2 Conjunto II .
B.2.3 Conjunto III .
B.2.4 Conjunto IV .
B.3 Método 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

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

2

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

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 número m ≥ 0, um inteiro positivo n e, para cada i em {1, . . . , n}, um
número vi ≥ 0 e um número wi ≥ 0, encontrar um subconjunto S de {1, . . . , n} que
P
maximize v(S) sob a restrição w(S) ≤ m. Onde, v(S) denota a soma i∈S vi e,
P
analogamente, w(S) denota a soma i∈S wi .
Os números vi e wi podem ser interpretados como utilidade e peso respectivamente
de um objeto i. O número m pode ser interpretado como a capacidade de uma
mochila, ou seja, o peso máximo que a mochila comporta. O objetivo do problema
é então encontrar uma coleção de objetos, a mais valiosa possível, que respeite a
capacidade da mochila.
Este problema vem sendo estudado deste o trabalho de D.G. Dantzig[5], devido a
sua utilização imediata na Indústria e na Gerencia Financeira, porém foi mais enunciado por razões teóricas, uma vez que este freqüentemente ocorre pela relaxação
de vários problemas de programação inteira. Toda a família de Problemas da
Mochila requer que um subconjunto de ítens sejam escolhidos, de tal forma que o
somatório das suas utilidades seja maximizado sem exceder a capacidade da mochila.
Diferentes tipos de problemas da Mochila ocorrem dependendo da distribuição de
ítens e Mochilas como citado em [5]:
No problema da Mochila 0/1 (0/1 Knapsack Problem ), cada ítem pode ser escolhido no máximo 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 Múltipla Escolha (Multiple-choice Knapsack Problem )
ocorre quando os ítens devem ser escolhidos de classes disjuntas, e se várias Mochilas são preenchidas simultaneamente temos o problema da Mochila Múltiplo (Multiple Knapsack Problem ). A forma mais geral é o problema da Mochila com multirestrições (Multi-constrained Knapsack Problem ) o qual é basicamente um problema
de Programação Inteira Geral com Coecientes Positivos.
Todos os problemas da Mochila pertencem a família NP-Hard [5], signicando que
é muito improvável que possamos desenvolver algoritmos polinomiais para este problema. Porém, a despeito do tempo para o pior caso de todos os algoritmos terem
tempo exponencial, diversos exemplos de grandes instâncias podem ser resolvidos
de maneira ótima em fração de segundos. Estes resultados surpreendentes vem de
várias décadas de pesquisa que tem exposto as propriedades estruturais especiais do
Problema da Mochila, que tornam o problema tão relativamente fácil de resolver.
Neste trabalho todos os algoritmos apresentados resolvem o Problema da Mochila
0/1, que consiste em escolher n ítens, tais que o somatório das utilidades é maximizado sem que o somatório 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 variável binária igual a 1 se j deve ser incluído na mochila e 0 caso
contrário.

1.1 Provar que o Problema da Mochila é NP-Completo
Para provar que um problema
acordo com [6], que:

Q

pertence a N P -Completo é necessário provar, de

• o mesmo pertence a classe N P , apresentando em algoritmo não-determinista
em tempo polinomial ou mostrando que uma dada solução pode ser vericada
em tempo polinomial.
• Apresentar um redução 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 não-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);

P

Pn

if ( n1 P [i] ∗ X[i] > cM )OR(
then return Insucesso
else return Sucesso

1

U [i] ∗ X[i] < uM )

O procedimento KnapsackN D é uma algoritmo Não-Determinista para o problema
de decisão da Mochila. As linhas de 1-3 atribui o valor 0/1 para o vetor solução
X[i], 0 ≤ i ≤ n. Na linha 4 é feito um teste para vericar se a atribuição do pesos é
viável e não ultrapassa a capacidade da Mochila cM e se o resultado da Utilidade é
pelo menos uM . Uma solução com sucesso é encontrada se as restrições são satisfeitas. A complexidade de tempo deste procedimento é O(n). Se m é o tamanho da
entrada usando uma representação binária, o tempo é O(m)[4].

1.3 Redução Polinomial
Vamos apresentar uma redução polinomial a partir de outro problema conhecido
como NP -Completo para o problema da Mochila.
Antes de fazê-lo vamos dar uma versão de um problema de decisão para o Problema
da Mochila 0/1. O problema de Otimização difere do problema de Decisão somente na função de Otimização. Assim a versão de Decisão 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 .
Questão: Existe um subconjunto S ⊆ {1, ..., n} de ítens, tais que o peso total é no
máximo W :
X
wi ≤ W
i∈S

2

Com isso provamos que Problema da Mochila 0/1 é N P -Completo. uma resposta negativa para o problema Subset Sum. é uma resposta "sim"para problema Subset Sum. i∈A0 Isto é. 3 .e o valor da utilidade total é pelo menos C : c(S) = X ci ≥ C? i∈S Para provar que a versão de decisão do problema da Mochila é N P -completo vamos fazer uma redução polinomial a partir do problema Maximum Subset Sum Solução: A versão do problema de decisão para Maximum Subset Sum é denida como apresentada em [3]: Entrada: Um conjunto nito A. Desta forma uma. i∈A0 Assim. W = C = B Esta redução é feita em tempo polinomial. e um inteiro positivo B . como citado em [2]. A redução completa é como se apresenta a seguir: Dados uma instância do problema Subset Sum. X si = B. um tamanho inteiro positivo si para cada elemento i ∈ A. Maximum Subset Sum é um caso especial do problema de Otimização do Problema da Mochila 0/1 com ci = wi . por denição. wi = ci = si . Assim mostramos que: • o problema da Mochila está em N P e. exatamente. • Uma resposta "sim"para uma instância do Problema da Mochila 0/1 signica que existe um subconjunto S 0 ∈ U tal que X wi ≤ W and i∈S 0 X ci ≥ C i∈S 0 Isto signica. usando a nossa transformação. que existe um subconjunto A0 ∈ A tal que X B≤ si ≤ B. resposta para uma instância do problema da Mochila corresponde a uma resposta para o problema Maximum Subset Sum. Questão: Existe uma subconjunto A0 ⊆ A tal que X si = B? i∈A0 Como podemos notar. • existe uma redução polinomial a partir do problema Maximum Subset Sum para o Problema da Mochila 0/1. • Um resposta "Não"para o Problema da Mochila 0/1. signica que tal conjunto não existe. reduziremos esta para uma instância do Problema da Mochila 0/1 da seguinte forma : U = A. O que é. desde que todas as atribuições são executadas em tempo polinomial.

o algoritmo faz o backtracking. A função limite funciona da seguinte forma: Se num nó Z qualquer. Os seguintes passos são respeitados: 1. As soluções são representadas por n-tuplas ou vetores de solução (v1 . 4 . se existir mais de uma disponível para cada uma das n decisões. A organização típica é uma árvore. Organizar o espaço de solução de forma que seja facilmente pesquisado. Backtracking é uma estratégia que se aplica em problemas cuja solução pode ser denida a partir de uma seqüência de n decisões. o valor de xi . vi ). A função Limite determina um limite superior sobre a melhor solução obtida pela expansão de um nó Z no nível k + 1 do espaço de estados. Denir um espaço de solução para o problema. . que podem ser modeladas por uma árvore que representa todas as possíveis seqüências de decisão. se for constatado que ele não pode representar uma solução parcial. 3. então um limite superior para Z pode ser obtido pela relaxação do requisito de xi = 0 ou xi = 1 por 0 ≤ xi ≤ 1 para os nós k + 1 ≤ i ≤ n e usando um algoritmo guloso para resolver o problema da relaxação. .1 ≤ i ≤ k já foi determinado. 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 solução parcial do problema. este problema possui espaço de solução consistindo de 2n maneiras distintas de atribuir zero ou um para o vetor de solução X . . eliminando as sub-árvores que não levam a nenhuma solução. Proceder a busca em profundidade. De fato. .2 Solução usando Backtracking Backtracking é uma estratégia para sistematicamente examinar a lista de possíveis soluções. 2. então este nó pode ser eliminado. . a busca exaustiva da árvore é exponencial. . . Na avaliação de um vetor (v1 . Este algoritmo faz uso de uma função limite para ajudar a eliminar alguns nós sem fazer a expansão deles. Uma boa função limite para este problema é obtida usando um limite superior com o valor da melhor solução viável obtida pela expansão de um nó ativo e qualquer dos seus descendentes. Se este limite superior não for maior que valor da melhor solução encontrada até o momento. Este espaço de solução deve incluir pelo menos uma solução ótima para o problema. e continua tentando extender o vetor com outros valores alternativos. A idéia do backtracking é eliminar a vericação explícita de uma boa parte dos possíveis candidatos. v2 . podar a árvore. Cada vi é escolhido a partir de um conjunto nito de opções Si . vn ). A eciência desta estratégia depende da possibilidade de limitar a busca. Para tanto. o problema deve respeitar as restrições que maximizam/minimizam alguma função de otimização. eliminando o último valor do vetor. Implementamos o algoritmo descrito em [4]. . ou seja.

I. Da função Limite segue que o limite para um nó lho à esquerda viável de um nó Z é o mesmo para Z . P. 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 k←1 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 k←n X←Y else Y (k) ← 0 while Limite(ic. pt. k. Então a função Limite não precisa ser usada sempre que o algoritmo faz um movimento para o lho a esquerda de um nó.Limite(ut. 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 método de Backtracking: Metodo_Backtracking(M. Desde que o algoritmo tentará fazer um movimento para a esquerda sempre que houver uma 5 . pf. n. pc. if. k. M ) ≤ if do while (k 6= 0)&(Y (k) 6= 1) do k ←k−1 if k = 0 then return Y (k) ← 0 pc ← pc − P (k) ic ← ic − I(k) k ←k+1 O ordem de complexidade de espaço para este algoritmo é O(2n ) de acordo com [4].

1. A programação dinâmica trata o número de combinações da seguinte forma: Vamos considerar n ítens. como no caso do Backtracking acima. Y (i) = 1. P X(i). B. Se k ≤ n então P (i) não cabe e um movimento para um lho à direita deve ser feito. retornamos ao longo do caminho para o nó mais recente a partir do qual um movimento não tentado pode ser feito. Nas linhas 20 a 22.0. 6 . Ao terminar if = 159 e X=(1. pc e ic são apropriadamente atualizados para corresponder a um movimento para a direita. C e D. Essa solução é de ordem exponencial e. 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 várias escolhas que são feitas para o vetor de solução parcial Y . a função Limite será chamada somente depois de uma série de movimento com sucesso para os lhos a esquerda. Então Y (k) é marcado como 0 na linha 17. podemos proceder de duas formas: 1. O nós que não contem números tem peso e utilidade idêntico aos pais. Limite ≤ n. 1 ≤ i ≤ n é o caminho P Pk−1 para o nó corrente. A variável if do algoritmo é atualizada em cada nó A. Se na linha 12. Os dois números no nó são o peso corrente (pc ) e a importância corrente (ic ). O limite para este novo nó é calculado. 3 Solução usando Programação Dinâmica Uma solução ótima baseada no método guloso é denida por uma seqüência de decisões locais ótimas. E a melhor seqüência seria então escolhida.0. pc = k−1 i=1 P (i)Y (i) e ic = i=1 I(i)Y (i).escolha entre esquerda e direita. Dos 29 − 1 = 511 nós do espaço de estados da árvore somente 33 são gerados. ineciente.1. quando inclui ou exclui o Peso P (i).1. No while nas linhas 6 a 11 movimentos sucessivos são feitos para lhos a esquerda viável. como pode ser visto na próxima seção. Se na linha 18. O limite dos nós a esquerda são os mesmos dos pais. dentre os quais devemos escolher r. Cada vez que if é atualizada. 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 solução com valor maior que if . O número de fora do nó a direita é o limite do nó. uma possível saída seria a geração de todas as possíveis seqüências de decisões.1. Se não existe este caminho então o algoritmo termina na linha 23-24. Escolher o primeiro ítem. portanto. o vetor solução nal X também é atualizado. Quando o método guloso não funciona. O i-ésimo nível da árvore corresponde a uma atribuição 0 ou 1 para Y (i). então o caminho corrente terminou e ele não pode levar a uma solução melhor que a encontrada até o momento. Escolher depois r − 1 ítens dos n − 1 ítens restantes. Quando if 6= −1. Para escolher os r ítens. Programação dinâmica é uma técnica que tem como objetivo diminuir o número de seqüências geradas. Caso contrário Y (k). 1 ≤ i ≤ n é tal que ni=1 I(i)X(i) = if . k > n então ic > if indicando que o caminho para esta folha terminou na última vez que a função Limite foi usada.0).

Sendo o projeto de uma algoritmo baseado em Programação Dinâmica dividido em duas partes: 1. 2. armazená-lo na tabela. • Determinar o padrão de preenchimento da tabela. • Denir um laço que utiliza o padrão para preencher os demais valores da tabela. e é essa a idéia principal da programação dinâmica. 7 . Identicação • determinar uma solução por divisão e conquista.Figura 2: Árvore gerada pelo Algoritmo Guloso 2. Usando esta abordagem para o problema podemos melhor a complexidade deste problema para O(n2 ). Uma outra abordagem seria usar uma tabela para armazenar as soluções que vão se repetir. • Usar o caso base do algoritmo de divisão e conquista para inicializar a tabela. • Mesmo sub-problema resolvido várias vezes. Então devemos escolher r ítens dos n − 1 ítens restantes ³ ´ ³ ´ ³ ´ n Está solução pode ser traduzida da seguinte forma: nr = n−1 + r−1 Se usarmos r−1 uma estratégia de divisão e conquista para implementar esta solução obteremos um algoritmo com complexidade O(2n ). Construção • Pegar a parte do algoritmo de divisão e conquista que corresponde à parte da conquista e substituir as chamadas recursivas por uma olhada na tabela. • Em vez de retornar um valor. • Analisar e vericar que o tempo de execução é exponencial. Não escolher o primeiro ítem. sendo o maior problema desta abordagem o número de vezes que o mesmo problema é resolvido.

uni. Podemos Generalizar para a situação em que temos i ítens e o tamanho total é j . 2. portanto j é alcançado até os i − 1 primeiros ítens. O padrão de preenchimento seria então o mesmo apresentado na Figura 4 Figura 4: Padrão de preenchimento da tabela Sendo assim a tabela nal teria o formato da Figura 5: O algoritmo utilizado na implementação foi extraído de: • http://www. Numa solução por divisão e conquista. Caso não seja possível.cse. j − si ] ou T [i − 1.edu/ holder/courses/cse2320/lectures/l15/node12. Pelo denido acima uma célula t[i. Sejam n ítens de tamanhos s1. A idéia é vericar se existe um subconjunto desses ítens cujo tamanho total seja exatamente S . . s2. . j].mpg. temos que analisar duas possibilidades: 1. .mpi-sb. Devemos usar uma tabela t[n. .html • http://www. devemos ter problemas menores da mesma natureza. Para saber se retornamos verdadeiro. S] para armazenar t. caso seja possível completar S com os n elementos. O i-ésimo item não é usado e.Figura 3: Instância para o Algoritmo de Programação Dinâmica Vamos apresentar um exemplo do problema da Mochila onde a utilização da programação dinâmica permite encontrar a solução ótima. conforme a Figura 3.de/ rybal/armc-live-termin/node5.html • http://www-cse. preenchemos com f .edu/ goddard/Courses/CSCE310J 8 . O i-ésimo ítem é usado para completar o tamanho j . sn. j] deve ser preenchida com t se uma das duas situações é verdadeira:t[i − 1.uta.

onde n é o número de ítens. sendo o laço da linha 1 a 3 da ordem O(W ). w] else c[i. Os laços seguintes realizam a construção da tabela. para saber quais os ítens que tornam este valor máximo outro algoritmo foi implementado: 9 . w] Podemos deduzir a complexidade deste algoritmo através da manipulação que é executada em cada laço.n].n].. n. w] ← 0 for i ← 1 to n do c[i. w] then c[i. e o laço da linha 4 a 6 da ordem O(n). onde W é a capacidade da Mochila. w − w[i]] else c[i. o laço da linha 7 a 17 executa O(n) e o laço da linha 9 a 17 executa O(W ) vezes. w − w[i]] > c[i − 1.Figura 5: Formato Final da Tabela Metodo_Dinâmico(v[1. sendo que os dois laços iniciais são apenas para inicializar a tabela.. w] = c[i − 1. O algoritmo acima encontra apena o maior valor possível que pode ser alocado na Mochila. 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] = c[i − 1. 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] = v[i] + c[i − 1. w[1. sendo este algoritmo da ordem de O(n ∗ W ).

entretanto.Backtrace(n. Qualquer subconjunto que satisfaça esta restrição é chamado de solução viável. resultarão em algoritmos que gerarão solução sub-ótimas. A grande maioria destes problemas possui n entradas e é requerido obter um subconjunto que satisfaça alguma restrição. j] <> c[i − 1. Uma solução viável que satisfaça a função objetivo é chamada de solução ótima. Em cada passo será incluído um objeto que tem a maior utilidade pro unidade de peso usado. Existem maneiras óbvias de determinar uma solução viável. Esse algoritmo realiza os seguintes passos: • o vetor solução X é inicializado. O método Guloso sugere que podemos construir uma algoritmo que trabalhe em estágios. 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. O processo de seleção em si é baseada em alguma medida de otimização. então esta entrada não será adicionada a solução parcial. Em cada estágio. que na implementação foi usado o algoritmo do quicksort extraído do livro [6]. o algoritmo abaixo executa a estratégia gulosa em tempo O(N ). Esta medida pode ou não ser a função objetivo. Muitas destas. j]) then X[i] ← 1 j ← j − w[i] i−− else X[i] ← 0 i−− 4 Solução usando o Método Guloso O método Guloso é a técnica de projeto mais simples que pode ser aplicada a uma grande variedade de problemas. O algoritmo escolhido para esta implementação usa a estratégias gulosas mais interessante. Isto é conseguido considerando as entradas numa ordem determinada por algum processo de seleção. de acordo com [4]. considerando uma entrada por vez. Sem considerar o tempo de ordenação da entrada. uma decisão é tomada considerando se uma entrada particular é uma solução ótima. resolve o problema da Mochila usando a estratégia gulosa. 10 . W ) 1 2 3 4 5 6 7 8 9 i←n j←M while ((i > 0)&(j > 0)) do if (c[i. extraido de [4] e adaptado a partir da linha 9 a 13 para resolver o problema da Mochila 0/1. mas não necessariamente uma solução ótima[4]. • a capacidade utilizada da mochila é armazenado em cum. Isto signica que o objeto será considerado na ordem decrescente da Maior Utilidade sobre o Peso (U (i)/P (i)). Queremos então encontrar uma solução viável que maximize ou minimize uma dada função objetivo. Se a inclusão da próxima entrada na solução ótima construída parcialmente resultará numa solução inviável. este estratégia faz uma negociação entre a taxa em que a utilidade decresce e o peso é usado. Na verdade várias medidas de otimização diferentes podem aplicáveis para um determinado problema.

da linha 9 a 13. cum ← cum − P (i) for j ← i to n do if P (j) <= cum then X(i) ← 1. M. 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 número 1 será colocado na Mochila. X(i) ← 1. cum ← cum − P (j) Apesar de muito muito interessante a estratégia gulosa não produz sempre soluções ótimas. devido ao seu valor maior que os demais. Neste ponto todos os ítem de maior relação U (i)/P (i) foram colocado na Mochila. como no seguinte exemplo extraído de [1]. subtraindo o peso do ítem do valor de cum. da linha 3 a 8.• O primeiro laço F OR. Metodo_Guloso(U [1. n) 1 2 3 4 5 6 7 8 9 10 11 12 13 X←0 cum ← M for i ← 1 to n do if P (i) > cum then Exit. • O segundo laço F OR. e existem situações bem simples que o algoritmo é levado a escolher um ítem de maior relação U (i)/P (i) que não faz parte da solução ótima.. P [1. 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 Comparação entre os Métodos Neste trabalho zemos os teste considerando a correlação entre os Pesos e as Utilidades que foram gerados aleatoriamente.n]. Sendo que o valor ótimo neste exemplo é 220. colocando cada ítem na mochila. sendo que este ítem não leva a uma solução. muda de estratégia e procura nos ítens restantes aquele(s) que possua um peso que caiba no valor restante de cum para preencher o espaço da Mochila. Os testes 11 Max 220 50 ..n]. conforme citado em [4] e [5]. Isso é feito até que a cum não comporte o próximo peso.

30. Para os experimentos foram usados quatro conjuntos de dados fornecidos pelo colega "David Menoti Gomes". Instâncias não correlacionadas são mais fáceis de resolver. U = P + 10 (III). 20.foram divididos em: • Dados Não-Correlacionados . onde a distribuição dos pesos e utilidades é como denido anteriormente n ∈ 10. cada uma com 10 amostras. Fica mais fácil eliminar numerosas variáveis pelo teste do limite ou por relações de dominância. sendo: 1. desde que o retorno de um investimento geralmente é proporcional ao investimento somado com alguma variação. Os conjuntos foram utilizados porque foram gerados seguindo a orientação da referência [4]. • Instâncias com Correlação Forte . Tipicamente a Utilidade difere do Peso por uma faixa pequena. 2) Existe uma grande perda relativa quando removemos ítens de pequeno peso para alocar um item de peso maior.Tais instâncias correspondem a situações da vida real onde o retorno é uma função linear do investimento mais (ou menos) alguma parte imprecisa em cada projeto. (I) Pesos e Utilidades distribuídos na faixa de [1-1000].aqui a Utilidade é altamente correlacionada com o Peso. 40. Assim alta correlação são utilizadas para para avaliar a capacidade do algoritmo para resolver problemas difíceis. 12 . sendo os pesos distribuídos na faixa de [1-100] e a utilidade é o peso acrescido de uma valor constante. O terceiro conjunto de dados é o conjunto altamente correlacionado. tornando mais fácil obter uma Mochila cheia. Sendo os dois primeiros conjuntos de dados baseado na distribuição de dados não-correlacionados. 100. Apesar deste fato instâncias correlacionadas fracamente são mais fáceis de resolver pois existe uma grande faixa de variação de Pesos. O quarto conjunto de dados é fracamente correlacionado. tornando mais fácil preencher a Mochila e chegando mais perto da solução ótima. 500 . Uma alta correlação signica que é mais difícil eliminar variáveis pelo teste de limite. Tais instâncias são mais realistas em gerenciamento. 200. 1 ∗ P (IV). 300. Os experimentos seguiram a seguinte estratégia: • Para cada n foram feitas 5 execuções. (II) Pesos e Utilidades distribuídos na faixa de [1-100]. signicando que é muito difícil combina-los de maneira a encher a Mochila. 2. 400. • Instâncias com Correlação Fraca . 50. Este tipo de correlação é difícil de resolver por duas razões: 1) Todos os ítens que estão próximo do item de parada tem pesos similares. sendo os pesos distribuídos na faixa de [1-100] e a utilidade calculada como como U = 1. Tais instâncias ilustram as situações onde é razoável admitir que a Utilidade não depende dos Peso. pois existe uma grande variação ente os pesos.nas instâncias não existe correlação entre os Pesos e as Utilidade de um item. por exemplo quando estamos fazendo uma mudança no caminhão: coisas pequenas podem ser mais valiosas que alguns ítens volumosos.

200. 50) do valor total dos pesos. e a execução foi abortada: Isto também pode ser notado na tabela 9 da execução para o conjunto de dados IV para n = (50. Sendo que quando os dados começam a car correlacionados. Maior tempo da amostra. 40. todas as tabelas estão em Anexo.• Cada execução possui uma capacidade da Mochila na faixa de M ∈ 10%. 20. 500) elementos e para capacidade da mochila variando de M ∈ (10. onde não existe correlação entre os Pesos e Utilidades. 200. Podemos vericar na tabela 8 a seguir com os valores acumulados das utilidades para uma execução dos três algoritmo no conjunto de dados III. sendo cada execução feita 10 vezes. sendo que neste caso o Backtracking não consegue responder a partir de 100 elementos. O algoritmo de Backtracking também possui um tempo médio bastante competitivo em relação ao guloso. como ocorre nos conjuntos III e IV. Foram gerados tabelas para cada n. Todos os grácos estão apresentados em anexo. sendo que cada tabela apresenta o valor médio do tempo de resposta. 5. • Foram gerados arquivos com as respostas. sendo cada saída para um valor de n com cinco execuções variando a capacidade da Mochila. No. o maior tempo gasto e o desvio padrão da amostra. as tabelas também estão em anexo.Media dos tempos. formatados da seguinte maneira: (Capacidade da Mochila. 400). • Os tempos estão em segundos.1 Resposta para os Conjuntos de Dados Os testes foram divididos de acordo com os conjunto dos dados e para os conjuntos foram gerados grácos comparativos para cada valor dos n ∈ (10. apresentaremos alguns para apresentar os fatos encontrados nas execuções. 40. Neste caso ele sempre apresenta o valor ótimo juntamente com o algoritmo dinâmico. podemos notar que para este conjunto de dados. a partir de 200 elementos o algoritmo de backtracking não consegue responder num espaço de tempo inferior a 10s. 50. podemos vericar esta comparação na gura 7 . 100. 300. 20. para n = (50. 100. porém ele não apresenta sempre o valor ótimo. 100. 50% do valor do total dos pesos. 30%. tendo que ser abortado: 13 . 200. 30. o método guloso ainda mantém uma grande competitividade no tempo de execução. 30. como podemos observar na gura 10. Elementos). 20%. Desvio padrão. • Para cada método foram gerados 10 arquivos de saída para cada conjunto de dados. 40%. 400). 400. Sendo que o tempo de execução do algoritmo Guloso tem se mostrado bastante competitivo quando aplicado aos conjuntos de dados I e II.

1 10 15 20 25 30 35 40 Numero de Elementos no Vetor para DSET=1 45 50 Figura 6: Conjunto de dados I .3 0. Isso já era previsto. apesar dele levar mais tempo para todas as instâncias é o mais estável com relação a respostas em todos os conjunto de dados. sendo que o comportamento de cada algoritmo pode variar bastante para o mesmo conjunto de dados.Comparacao entre os Metodos para n = 100 0. n=200 No conjunto de dados do tipo I e II o Backtracking consegue responder até 10. Sendo o que se apresenta melhor é o Algoritmo Dinâmico. 14 .15 10 15 20 25 30 35 40 Numero de Elementos no Vetor para DSET=2 45 50 Figura 7: Conjunto de dados II .4 0.000 elementos.2 0. uma vez que o mesmo é NP-Completo. Nestes casos o algoritmo Dinâmico consegue apresentar melhores resultados.2 0.3 0. já nos conjuntos correlacionados o algoritmo de backtracking não 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. percebemos que os algoritmo são totalmente dependentes das entradas de dados.25 0.45 0. n=100 Comparacao entre os Metodos para n = 200 0.7 Guloso Dinamico Backtracking Tempo de Resposta em segundos 0. qualquer dos algoritmos construídos não resolverá de maneira satisfatória o problema.5 0. Conforme podemos observar nos grácos gerados para os diversos valores de n.35 0.4 0. O que podemos concluir das execuções é que apesar de obtermos implementações interessantes para o problema da Mochila.5 0.6 0.55 Guloso Dinamico Backtracking Tempo de Resposta em segundos 0.

Se LeArquivo = 1 a entrada é via arquivo.00 200 200 200 200 200 29204.00 50 6368.00 115741.00 50 10 20 30 40 50 7206.00 10 20 30 40 50 10 20 30 40 50 8 9 10 11 12 13 7095. e uma Chave contendo a relação I/P.00 11382.00 12652.00 28658.00 12839.00 57240.00 73881.00 36675. com o objetivo de manter o vetor na ordem decrescente da relação Utilidade/Peso.00 18235.00 95073.00 23491.00 3548.00 100 100 100 100 100 14515.00 23491.00 3407.00 50 11617. que é um array de Ítens. esta estrutura contém os seguintes ítens: • Um tipo registro (struct) para cada ítem. se LeArquivo = 0 a entrada será gerada internamente.00 47200. ResultD.00 7206.00 400 400 400 400 400 14 15 16 17 18 19 20 21 22 23 24 25 Figura 8: Tabela com tempo de execução para Conjunto de dados III 6 Estruturas de Dados Para a implementação dos três métodos citados acima. através do procedimento GeraV etor.00 94710.00 14151. Construímos um único vetor que armazena os pesos.00 6368. Na execução do programa podemos denir se a entrada será feita via arquivo ou será gerada internamente.00 14322.00 25872. uma chave que é utilizada na rotina de ordenação.00 12839.00 9018. sendo 1-faz parte da solução. as utilidades. para armazenar os n elementos com suas Utilidades e Pesos.00 29061.00 18025.00 8719.00 28658.DIN 1 BACK GUL 2 3 4 5 6 7 10 20 30 40 50 3548.00 52097.00 13813.00 50 14151.00 50 9018. e três valores para armazenar o resultado para cada método.00 57529.00 73570.00 115910.00 25699. o Peso. ResultB.00 23229.00 28353.00 46964. contendo o valor da Importância.00 18235. Neste caso o valor da capacidade da Mochila 15 .00 51898.00 36453. mantemos também alguns campos que armazenavam a solução que será atualizada para cada método. 0-não faz parte da solução: ResultG. foi construída uma única estrutura de dados que foi utilizadas nas implementações. • Uma estrutura do chamada Vetor.00 11617.00 6155. este controle é feito via a variável LeArquivo.

00 7298.00 40427.00 20283.00 4875.00 20047.00 15051.00 4850.00 12122.00 9723.00 60538.00 60540.00 80625.00 20052.00 20340. sendo que este valor é o limite e a quantidade dos objeto na Mochila são denidos pela variável N oElementos.00 40575. conforme arquivo fonte em anexo.00 5031.00 25035.00 100 100 100 100 100 10 20 30 40 50 10213.00 10212.00 40427.00 100686.00 25045.00 10051.00 50670.00 30469.00 100686.00 7298.00 80626.00 40571.00 10047.00 200 200 200 200 200 10 20 30 40 50 20284. são gerados numa faixa controlada pela constante N que pode ser alterada.00 2442.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 execução para Conjunto de dados IV é calculado como metade do total dos pesos.00 12145.00 9705.DIN 1 BACK GUL 2 3 4 5 6 7 10 20 30 40 50 2442. quando gerados internamente.00 15054.00 20347. A capacidade do vetor é denido pela constante M axT am.00 4875.00 12145.00 7280.00 9723.00 2419. O valor dos pesos e das utilidades.00 50 50 50 50 50 10 20 30 40 50 5042.00 30471. 16 .00 50671.

Algorithms fo Knapsack Problems. MIT Press/McGraw-Hill.5 0.kth.7 Guloso Dinamico Backtracking Tempo de Resposta em segundos 0. 1978. A compendium of NP-optimization problems http://www. Rivest.1 10 15 20 25 30 35 40 Numero de Elementos no Vetor para DSET=1 45 50 Figura 10: Conjunto de dados I . Computers and Intractability: A Guide to the Theory of NP-Completeness.3 0. Department of Computer Science. 17 .2 10 15 20 25 30 35 40 Numero de Elementos no Vetor para DSET=2 45 50 Figura 11: Conjunto de dados II . and Ronald L. n=100 Referências [1] Thomas H.nada. Computer Science Press. PhD thesis.Comparacao entre os Metodos para n = 100 0. n=100 Comparacao entre os Metodos para n = 100 0. February 1995.25 0.2 0. Fundamentals of Computer Algorithms.45 0. Johnson.4 0. Freeman. [2] Pierluigi Crescenzi and Viggo Kann.35 0. 1990.65 Guloso Dinamico Backtracking 0.6 0.html. [4] Ellis Horowitz and Sartaj Sahni. Cormen.se/ viggo/wwwcompendium/wwwcompendium.3 0.6 Tempo de Resposta em segundos 0. Charles E. [3] Michael R. Introduction to Algorithms.4 0. H. University of Copenhagen. Leiserson. W. 1979. [5] David Pisinger.5 0. Garey and David S.55 0.

n=100 [6] Nivio Ziviane.2 0.Comparacao entre os Metodos para n = 100 3. n=100 Comparacao entre os Metodos para n = 100 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 .5 0.7 Guloso Dinamico Tempo de Resposta em segundos 0.5 Guloso Dinamico Backtracking Tempo de Resposta em segundos 3 2.5 1 0. Projeto de Algoritmos: com implementações em Pascal e C.4 0..6 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 . 18 . 2ed. Pioneira Thomson Learning.5 2 1.3 0. 2004.

Sahni.de/~rybal/armc-live-termin/node5. Os resultados são armazenados de acordo com o metodo ====================================================================== */ typedef struct Item { Valor Importancia.mpg.h> #include <limits.Gerado Randomicamente typedef int Valor. Valor Peso. 19 . Fundamentals of Computer Algorithms. } Item.uta.html http://www.h> #include <stdio. Computer Science Press. typedef int Indice. 0-Gerado Randomicamente typedef int Valor. Vetor Origem.html ====================================================================== */ #include <stdlib.E. Figura 14: Trecho de código das principais denições A Código 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 .edu/~holder/courses/cse2320/lectures/l15/node12. Importancias. typedef struct Item { Valor Importancia. /* ====================================================================== Estrutura tipo Registro que armazena os Pesos. float Chave. Horowitz e S.via arquivo. Método Dinâmico desenvolvido a partir dos códigos propostos em: http://www-cse.via arquivo.Ruiter Braga Caldas Progama que Executa tres metodos para resolver o problema da mochila: Método Guloso e Backtracking desenvolvidos a aprtir do algoritmo proposto em . short ResultB. 1978.h> #include "time.2004-1 aluno .mpi-sb. short ResultG. short ResultD.h" #define MaxTam 1000 //Tamanho máximo do Vetor #define N 500 //Maior valor Aleatorio #define NoElementos 300 //Quantidade de Elementos para a Mochila #define LeArquivo 1 // 1 . Chave.h> #include <sys/time. 0 .//Vetor de Registros typedef Item Vetor[MaxTam+1]. e Resultados.1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 #define MaxTam 1000 //Tamanho máximo do Vetor #define N 500 //Maior valor Aleatorio #define NoElementos 300//Quantidade de Elementos para a Mochila #define LeArquivo 1 // 1 .

Chave > A[*j]. Item *A) { Item x.Chave) (*j)--. ResultG. A). j. Chave. 40 41 42 43 //Peso Final do Método Backtracking float Tpeso. j. A). k.28 29 30 31 32 33 Valor float short short short } Item. Item *A) { Indice i. while (x. FILE* fs. } } while (*i <= *j). Indice *n) { Ordena(1. A). A). w.Chave) (*i)++. Vetor Origem.(Projeto de Algoritmos/2004). Dir. if (i < Dir) Ordena(i. //Arquivos de Entrada e Saida FILE* fp. &i. A[*i] = A[*j]. *n. Indice Dir. *i = Esq. 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. Nivio Ziviane. n. } 68 69 70 71 72 73 74 75 76 77 void Ordena(Indice Esq. if (*i <= *j) { w = A[*i]. ====================================================================== */ void Particao(Indice Esq. Foi Alterada para fazer a ordenacao Crescente. Indice *i. A[*j] = w. /* ====================================================================== Função QuickSort disponibilizada no livro do Prof. ResultB. Dir. Indice Dir.Chave < A[*i].Timportancia. Indice i. x = A[(*i + *j) / 2]. &j. ResultD. (*j)--. (*i)++. Peso. *j = Dir. } 20 . 34 35 typedef int Indice. if (Esq < j) Ordena(Esq. Particao(Esq. Indice *j. 36 37 38 39 //Vetor de Registros typedef Item Vetor[MaxTam+1]. /* obtem o pivo x */ do { while (x. } void QuickSort(Item *A.

return (int)(low + k).Peso. } /* ====================================================================== Função que faz a impressão dos Pesos e Importancias no Métod Guloso A impressão é dirigida pelo Valor de ResultG ====================================================================== void ImprimeGuloso(Item *V.(The Art and Science of C) ====================================================================== int RandomInteger (int low. k = d * (high . Indice *n) {int Tp. i++) { if (V[i]. Tp=0. } } /* ====================================================================== Função que faz a impressão dos Pesos e Imports.V[i]. double Tp. i <= *n. Ti=0. Tp=0. no Métod Backtracking A impressão é dirigida pelo Valor de ResulB ====================================================================== void ImprimeBack(Item *V. int Ti.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 código foi copiado da biblioteca random de Eric Roberts. i++) { if (V[i]."%d %d\n"." %d %d\n".low + 1). double d. Indice *n) { int Tp. i++) { 21 */ */ */ */ . double Ti) { for (i = 1.Importancia). i <= *n.Importancia). for (i = 1. Indice *n.ResultB) fprintf(fs. } } /* ====================================================================== Função que faz a impressão dos Pesos e Importancias no Métod Dinâmico A impressão é dirigida pelo Valor do ResulD ====================================================================== void ImprimeDinamico(Item *V. for (i = 1. d = (double) rand () / ((double) RAND_MAX + 1). int high) { double k.V[i]. i <= *n.V[i]. int Ti.V[i]. Ti=0.Peso.ResultG) fprintf(fs.

ResultD) fprintf(fs.Peso = RandomInteger(1.A[i].Importancia). for (i = 1. 22 .Peso <= CM) { CM = CM . pesoTotal = pesoTotal + A[i]. i++) Destino[i]. O valor de M eh a metade do total dos pesos.ResultB = 0.Chave =(double)A[i].ResultG = 1. A[i]. A[i]." %d %d\n". CM=M. } /* ====================================================================== Executa o Metodo Guloso ====================================================================== */ void Guloso(Vetor A.j. A[i]. 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[].ResultB = Fonte[i]. while (j <= n) { if (A[j].Importancia / (double)A[i].Peso.V[i].N). i++) { A[i]. CM.Item *Destino.ResultG = 1.int *M) { int i.ResultG = 0. } j=i+1. faz o calculo da Chave=Importancia/Peso e Iniciaiza os Resultados.Importancia = RandomInteger(1.ResultD = 0. i <= n. A[i]. Indice n. i <= *n. A[i]. i <= n. ====================================================================== */ void GeraVetor(Vetor A.Peso.Peso > CM){ break. int M) { int i.A[j]. //Calcula o Valor da Mochila com 1/2 Pesos *M=pesoTotal*1/2. Indice n.128 129 130 131 } } if (V[i]. pesoTotal=0. i++) { if (A[i]. A[j].Peso.V[i]. } /* ====================================================================== Função que Gera Randomicamente o Vetor com os Pesos e Importancias.Peso. for (i = 1.Peso. Indice *n) { for (i = 1. Valor pesoTotal. } A[i].}.N). CM = CM .

while (Bound(A. cp = cp + A[k]. } void BKnap(float M.&n). *fp = -1. float w.M)/A[i].cp. CopiaDois(Y. Y[n]. float *fp) { int k. 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].Importancia.Importancia).Importancia. k = 1.Peso))*A[i].A. for (i = k + 1. *fw = cw. float M) { float b. cp = 0. float *fw. } if (k > n) { *fp = cp.0. i++) { c = c + A[i]. int k. k = n.Peso) <= M )) { cw = cw + A[k]. 203 204 205 206 207 cw = 0.c.cw. i <= n. k = k + 1.cp.float p.k. if (c <= M){ b = b + A[i]. Vetor A.Peso. Y[k]= 1. c = w.0. Indice n. b = p. } else Y[k]=0.Peso.M) <= *fp) { while (k != 0 && Y[k] != 1) 23 .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. } return(b). } } /* ====================================================================== Executa o Metodo Dinâmico ====================================================================== */ //funcao Limite para o método float Bound(Vetor A. } else return (b + (1 -((c . float cw.

}.Importancia + a[i-1][c-A[i].1. Indice i. c <= M. cp = cp . } else { a[i][c] = a[i-1][c]. //Inicializa Coluna for(i = 0. }//while (Bound) k = k + 1.Importancia.Importancia + a[i-1][c-A[i]. int M) { int j.Peso <= c) { if ((A[i]. Indice n. //Inicializa Linha for(c = 0.A[k]. Y[k] = 0.sizeof(int *)). //IniciaMatriz for (i = 0. if ( k == 0 ) return.Peso]) > a[i-1][c] ) { a[i][c] = A[i]. sizeof(int)).A[k]. c++)a[0][c] = 0. j++) a[i][j] = -1. int **a. cw = cw .228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 { k = k . for(i = 1. i <= n. i++)a[i][0] = 0. for( i=0. i++) { for (c = 1. }//while(1) } /* ====================================================================== Executa o Metodo Dinâmico ====================================================================== */ void Dinamico(Item *A. } } 24 . } } else { a[i][c] = a[i-1][c]. 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. i<n+1. i++ ) a[i] = (int *) calloc( M+1. i++) for (j = 0.Peso.Peso]. i <= n. int c. c++) { if (A[i]. i <= n. c <= M. j <= M.

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

ImprimeBack(Origem. } if (argc == 1) fprintf(stderr.n. &M). while(!feof(fp) && i <=n) { /* */ fscanf(fp. showTimes(). 26 . &Origem[i]. switch (*argv[1]){ case 'G'://Chama Metodo Guloso fprintf(stderr. "%d". //Abre o Arquivo de Saida if ((fs = fopen("saidab". "Backtracking\n").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. Origem[i].&M). } } } else { //Numero de elementos do Vetor n=NoElementos. BKnap(M. startTimer(). "w")) == NULL) fprintf(stderr. case 'B'://Chama Metodo Backtracking fprintf(stderr. fscanf(fp. "Guloso\n").0. else{ //Ordena em Orden Crescente de Imp/Peso QuickSort(Origem. startTimer().n. finishTimer().Peso).Importancia). &n). Importancia // e Calcula a Capacidade da Mochila GeraVetor(Origem.n.&Timportancia).Origem.&Tpeso. i++.Tpeso. "w")) == NULL) fprintf(stderr. "%d".&n).Importancia / (double)Origem[i]. &Origem[i]. // Gera o Vetor com os Pesos."ERRO: Precisa Informar um Metodo (G/B/D) \n"). "ERRO na Abertura do Arquivo de Saida\n").&n).0.Timportancia). showTimes(). Guloso(Origem.M). "ERRO na Abertura do Arquivo de Saida\n"). finishTimer(). fscanf(fp. ImprimeGuloso(Origem. Timportancia = 0.&n. "%d". //Abre o Arquivo de Saida if ((fs = fopen("saidag". break. "%d". Tpeso = 0.Peso.Chave =(double)Origem[i].

"ERRO na Abertura do Arquivo de Saida\n"). case 'D'://Chama Metodo Dinâmico fprintf(stderr.000 1.000 0.500 1. 396 B Tabelas com tempos de execução B.422 0.411 0.589 0.700 0. &n).436 0.247 0.059 0.000 1.519 0.500 0. startTimer().118 0.000 1.333 0.224 0. Dinamico(Origem. n.278 0. "Dinamico\n").1.233 0.000 1.589 0.059 0.354 0.000 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."ERRO: Método Não informado (G/B/D) \n").177 0.236 0.024 0.306 0. "w")) == NULL) fprintf(stderr.256 0.500 0.436 0.153 0.344 0.000 1. finishTimer().059 0. //Abre o Arquivo de Saida if ((fs = fopen("saidad".000 1.489 0.622 0.256 0.511 0.767 0.367 0.489 0. default :fprintf(stderr.400 max 0.600 1. ImprimeDinamico(Origem.236 0.000 1.511 0.1 Método Guloso B.500 0.530 0. break.000 1. }} fclose(fp).000 desv.667 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 . 0.000 1.000 1.000 1.378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 } break.141 0. return 0.342 0. fclose(fs).422 0.035 0.306 0. showTimes().000 1.000 1.244 0. M).000 1.

035 0.106 0.422 0.900 0.000 1.306 0.422 0.456 0.500 0.354 0.059 0.059 0. 0.311 0.900 0.165 0.433 0.800 0.511 0.401 0.322 0.024 0.059 0.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.489 0.500 1.700 0.244 0.035 0.684 0.500 1.344 0.047 0.035 0.667 0.533 0.600 0.000 1.000 1.000 1.495 0.012 0.600 0.400 0.700 0.106 0.719 0.400 0.1.000 1.000 1.024 0.212 0.700 0.500 0.356 0.500 0.444 0.767 0.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.000 1.071 0.600 0.500 0.411 0.000 1.578 max 0.322 0.600 1.047 0.900 0.601 0.300 0.600 0.047 0.012 0.035 0.433 0.401 n 10 10 10 10 10 20 20 20 20 20 30 30 30 30 30 40 40 40 28 .318 0.000 0.625 0.130 0.047 0.700 0.356 0.511 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.244 0.900 0.411 0.094 0.700 0.700 0.256 0.244 0.047 0.259 0.500 0.035 0.233 0.500 0.000 0.424 0.400 0.000 1.644 0.289 0.000 1.433 0.244 0.600 0.800 0.118 0.000 0.118 0.012 0.800 0.900 0.000 desv.700 0.667 0.000 1.500 0.000 1.233 0.389 0.322 0.107 0.478 0.256 0.700 0.059 0.501 0.700 0.130 0.106 0.500 0.519 0.489 0.400 0.367 0.

047 0.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.306 0.422 0.489 0.511 0.059 0.401 0.047 0.500 0.000 0.000 0.000 0.700 0.333 0.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.222 0.478 0.233 0.278 0.700 1.165 0.024 0.600 0.244 0.289 0.071 0.000 1.378 0.500 0.047 0.367 0.012 0.800 0.800 0.600 0.222 0.094 0.400 0.256 0.132 0.700 0.500 0.356 0.500 0.244 0.722 0.024 0.094 0.700 0.700 0.489 0.400 0.000 1.600 0.318 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.578 0.322 0.800 1.500 1.500 0.700 0.000 1.600 0.141 0.524 0.024 0.489 0.000 1.024 0.000 1.000 1.000 0.024 0. 0.500 0.130 0.283 0.071 0.1.024 0.000 1.578 0.556 0.456 0.300 0.047 n 10 10 10 10 10 20 20 20 20 20 30 30 30 30 29 .411 0.082 0.500 0.233 0.000 1.600 0.267 0.356 0.467 0.000 1.059 0.224 0.000 1.522 0.600 0.600 0.012 0.082 0.035 0.306 0.422 0.289 0.500 0.600 1.448 0.210 0.306 0.388 0.000 0.035 0.236 0.500 desv.244 0.433 0.035 0.024 0.422 0.236 0.467 0.467 0.278 0.600 0.342 0.800 0.522 0.378 0.071 0.600 0.059 0.035 0.411 0.059 0.400 0.244 max 0.

0.422 0.467 0.322 0.800 0.322 0.000 1.800 0.099 0.278 0.071 0.000 0.400 0.700 0.000 1.700 0.212 n 10 10 10 10 10 20 20 20 20 20 30 .489 0.141 0.800 0.900 0.130 0.233 0.130 0.322 0.400 max 0.094 0.700 0.500 0.024 0.500 0.059 0.411 0.024 0.489 0.467 0.000 0.000 1.460 0.500 0.082 0.082 0.433 0.000 1.411 0.411 0.800 0.000 0.300 0.000 1.000 1.212 0.556 1.625 0.600 0.289 0.600 0.024 0.600 0.511 0.311 0.000 1.800 0.212 0.367 0.130 0.071 0.522 0.567 0.000 1.400 0.222 0.500 0.500 0.600 0.593 0.495 0.212 0.400 0.000 1.177 0.456 0.500 0.500 1.636 0.400 0.000 1.035 0.500 0.500 0.118 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.024 0.012 0.000 desv.047 0.900 0.256 0.400 0.012 0.478 0.400 0.1.422 0.600 1.613 0.578 0.400 0.522 0.024 0.519 0.000 1.400 0.306 0.106 0.267 0.344 0.141 0.233 0.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.106 0.000 1.500 0.567 0.071 0.448 0.667 0.400 0.613 0.322 0.035 0.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.000 1.267 0.035 0.000 0.222 0.625 0.700 0.900 0.695 0.000 1.

900 0.256 0.244 0.500 1.333 0.071 0.047 0.047 0.1 Conjunto I 1 2 3 4 5 M 10 20 30 40 media 0.367 0.482 max 1.311 0.130 0.600 1.047 0.648 0.000 0.071 0.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.333 0.000 1.165 0.236 0.071 0.000 1.130 0.2 Método Dinâmico B.024 0.035 0.012 0.012 0.422 0.000 0.000 1.500 0.000 0.623 desv.000 1.311 0.700 0.600 0.000 1.424 0.700 0.322 0.511 0.034 0.800 0.500 0.047 0.222 0.400 0.508 0.500 0.600 0.046 0.000 1.024 0. 0.236 0.024 0.361 0.311 0.2.247 0.422 0.900 0.689 0.400 0.600 0.000 1.633 0.012 0.278 0.000 0.267 0.900 0.600 0.044 0.407 0.522 0.356 0.118 0.349 0.400 0.035 0.678 0.700 0.522 0.600 0.800 0.600 0.570 0.600 0.400 1.768 0.311 0.700 0.342 0.153 0.600 0.731 0.324 0.433 0.500 0.267 0.700 0.700 0.000 1.344 0.306 0.113 n 10 10 10 10 31 .224 0.059 0.322 0.234 0.283 0.244 0.000 1.356 0.344 0.444 0.267 0.247 0.000 0.700 0.344 0.457 0.012 0.489 0.047 0.118 0.153 0.700 0.082 0.389 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.

023 0.514 0.967 0.856 0.119 0.303 1.711 0.389 0.692 0.279 0.134 0.125 0.373 0.417 0.227 0.061 0.211 0.509 0.009 0.430 0.304 0.076 0.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.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 .556 0.225 0.944 0.233 0.982 0.570 0.158 0.006 0.672 0.683 0.068 0.271 0.235 0.052 0.045 0.010 0.130 0.089 0.336 0.000 0.194 0.976 0.045 0.989 1.032 0.388 0.864 1.678 0.784 0.448 0.478 0.590 0.675 0.383 1.031 0.721 0.524 0.252 0.528 0.629 0.474 0.029 0.179 0.432 0.330 0.122 0.636 0.171 0.760 0.693 0.977 0.001 0.500 0.090 0.256 0.083 0.322 0.157 0.030 0.211 0.214 0.005 0.136 0.620 0.654 0.635 0.323 0.025 0.253 0.445 0.026 0.351 0.518 0.976 0.012 0.959 0.319 0.026 0.492 0.008 0.250 0.024 0.014 0.466 0.911 1.018 0.154 0.637 0.044 0.555 0.961 1.239 0.029 0.203 0.006 0.112 0.685 0.031 0.028 0.217 0.011 0.616 0.007 0.011 0.002 0.370 0.210 0.274 0.111 0.027 0.351 0.230 0.160 0.010 0.015 0.

124 0.717 0.275 0.678 0.555 0.508 0.254 0.016 0.016 0.815 0.930 0.314 0.011 0.115 0.490 0.104 0.173 0.227 0.016 0.537 0.051 0.015 0.612 0.302 0.488 0.374 0.115 0.481 0.000 0.463 0.230 0.630 1.124 0.930 0.099 0.677 0.021 0.395 0.994 0.000 0.079 0.007 0.225 0.508 0.084 0.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.004 0.337 0.173 0.687 0.237 0.508 0.175 0.034 0.660 0.225 0.367 0.B.165 0.221 0. 0.243 0.552 0.931 0.045 0.355 0.293 0.226 0.380 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 .050 0.245 0.009 0.756 0.912 0.005 0.027 0.170 0.183 0.258 0.435 0.299 max 0.2.299 0.108 0.007 0.360 0.003 0.450 0.634 0.226 0.625 0.026 0.001 0.202 0.645 0.258 0.010 0.238 0.000 0.019 0.003 0.005 0.001 0.514 0.052 0.713 0.042 0.475 0.378 0.012 0.464 0.118 0.692 0.025 0.544 0.015 0.353 0.953 0.001 0.149 0.008 0.670 0.397 0.213 0.283 0.990 desv.305 0.015 0.191 0.712 0.015 0.132 0.013 0.000 0.001 0.460 0.368 0.651 0.399 0.039 0.539 0.040 0.600 0.865 0.968 0.611 0.609 0.

910 0.017 0.213 0.239 0.015 0.402 0.141 0.402 0.881 0.665 0.250 0.783 0.501 0.472 0.209 0.742 0.004 0.175 0.532 0.640 0.002 0.625 0.019 0.042 0.419 0.147 0.668 0.612 0.50 51 40 0.067 0.006 0.467 0.675 0.095 0.817 0.317 0.273 0.485 0.163 0.382 0.862 max 0.254 0.622 0.033 0.524 0.502 0.000 0.629 0.088 0.532 0.663 0.239 0.930 0.545 0.259 0.720 0.000 0.001 0.578 0.352 0.426 0.099 0.230 0.268 0.582 0.209 0.219 0.157 0.489 0.509 0.533 0.000 0.037 0.006 0.214 0.005 500 B.061 0.750 0.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.520 0.043 0.524 0.141 0.171 0.136 0.054 0.001 0.908 desv.600 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 .267 1.547 0.003 0.124 0. 0.2.008 0.382 0.172 0.718 0.001 0.451 0.008 0.008 0.000 0.014 0.998 0.000 0.530 0.953 0.225 0.001 0.700 0.021 0.033 0.045 0.010 0.179 0.983 0.015 0.119 0.210 0.274 0.001 0.106 0.004 500 50 0.644 0.232 0.302 0.427 0.243 0.071 0.290 0.367 0.430 0.049 0.022 0.135 0.167 0.113 0.180 0.032 0.

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.472 0.160 0.062 0.299 0.389 0.002 0.084 0.372 0.060 0.021 0.345 0.144 0.033 0.559 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 .006 0.175 0.176 0.011 0.521 0.165 0.010 0.505 0.012 0.821 0.356 0.009 0.836 0.712 0.519 0.183 0.760 0.090 0.020 0.113 0.002 400 500 500 500 500 500 B.283 0.000 0.585 0.198 0. 0.46 47 48 49 50 51 50 10 20 30 40 50 0.570 0.002 0.665 0.001 0.143 0.261 0.112 0.171 0.420 0.960 0.016 0.971 0.231 0.125 0.171 0.640 0.2.277 0.389 0.027 0.334 0.347 0.590 0.534 0.400 0.007 0.256 0.520 0.691 0.050 0.109 0.061 0.066 0.108 0.960 0.001 0.676 0.674 0.065 0.517 0.972 0.002 0.025 0.007 0.025 0.999 0.275 0.074 0.232 0.410 0.046 0.638 0.644 desv.000 0.136 0.227 0.597 max 0.239 0.700 0.480 0.573 0.096 0.980 0.412 0.301 0.218 0.517 0.166 0.337 0.059 0.677 0.229 0.436 0.009 0.119 0.112 0.210 0.206 0.260 0.795 0.012 0.210 0.241 0.146 0.007 0.509 0.129 0.476 0.115 0.630 0.140 0.850 0.004 0.312 0.721 0.012 0.209 0.389 0.023 0.

082 0.337 0.044 0.001 0.130 0.522 0.830 1.414 0.431 0.148 max 0.297 0.996 0.107 0.237 0.003 0.548 0.000 1.001 0.513 0.495 0.667 0.460 0.660 0.244 0.800 0.541 0.011 0.42 43 44 45 46 47 48 49 50 51 10 20 30 40 50 10 20 30 40 50 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 .220 0.216 0.644 0.530 0.900 0.271 0.051 0.019 0.197 0.493 0.135 0.578 0.606 0.370 0.000 0.800 0.218 0.002 0.189 0.015 0.168 0.672 0.690 0.183 0.506 0.670 0.283 0.000 0.450 0.133 0.654 0.200 0.000 0.221 0.637 0.660 0.454 0.025 0.679 0.049 0.224 desv.177 0.113 0.005 0.568 0.856 0.037 0.010 0.643 0.158 0.067 0.3 Método Backtracking B.800 0.506 0.595 0.890 0.900 1.900 1.310 0.800 0.258 0.500 0.900 1.027 0. 0.003 400 400 400 400 400 500 500 500 500 500 B.381 0.024 0.634 0.900 0.000 1.247 0.156 0.430 0.332 0.171 0.487 0.444 0.3.383 0.000 1.130 0.047 0.900 0.106 0.082 0.178 0.181 0.650 0.206 0.889 0.000 0.455 0.111 0.700 0.900 0.328 0.172 0.143 0.000 1.900 1.000 0.112 0.522 0.280 0.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.534 0.522 0.

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.337 0.289 0.057 0.490 0.132 0.900 1.300 0.000 1.377 0.378 0.437 0.800 0.480 0.130 0.481 0.271 0.085 0.515 0.600 0.600 0.064 0.033 0.343 0.281 0.860 0.900 0.368 0.211 0.490 0.722 0.187 0.000 1.900 1.106 0.310 0.497 0.000 1.000 0.930 0.239 0.599 0.252 0.266 0.141 0.000 0.224 0.050 0.130 0.513 0.078 0.900 1. 0.967 0.322 0.422 0.700 0.210 0.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.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 .127 0.541 0.177 0.285 0.296 0.048 0.326 0.333 0.207 0.004 0.800 0.068 0.317 0.617 0.007 0.220 0.381 0.800 1.432 0.600 0.884 0.394 max 0.345 0.448 0.392 0.508 0.582 0.900 0.000 1.220 0.683 0.143 0.164 0.295 0.276 0.018 0.390 0.622 0.800 0.533 0.700 0.035 0.481 0.016 0.299 0.611 0.800 0.602 0.145 0.456 0.019 0.123 0.563 0.390 0.000 0.467 0.269 0.3.196 0.220 0.161 0.115 0.920 0.209 0.194 0.355 0.540 desv.650 0.194 200 300 300 300 300 300 400 400 400 400 400 500 500 500 500 500 B.410 0.800 1.057 0.059 0.733 0.000 0.616 0.000 0.693 0.380 0.286 0.126 0.643 0.

016 0.413 0.006 0.385 0.291 0.108 0.041 0.990 0.326 0.310 0.200 0.391 0.348 0.525 0.787 0.026 0.169 0.055 0.700 1.569 0.396 0.335 0.356 0.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.020 0.700 0.800 0.000 0.763 0.559 0.602 0.860 0.452 0.723 0.511 0.004 0.246 0.373 0.445 0.520 0.332 0.501 0.688 0.081 0.235 0.219 0.287 0.780 0.101 0.002 0.242 0.022 0.033 0.950 0.916 0.194 0.153 0.3.600 0.203 0.046 0.291 0.152 0.000 0.840 0.355 0.446 0.256 0.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.123 0. 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 .450 0.990 0.423 0.338 0.753 0.322 0.226 0.282 0.367 0.305 0.154 0.352 0.470 0.220 0.970 0.126 0.280 0.960 0.489 0.117 0.434 0.397 0.406 max 0.239 0.603 0.930 0.505 0.909 0.516 0.097 0.900 1.394 0.356 0.000 1.343 0.550 0.000 0.395 0.700 1.469 0.313 0.645 0.387 0.736 desv.295 0.800 0.364 0.398 0.155 0.770 0.495 0.035 0.427 0.309 0.025 200 200 200 200 200 300 300 300 300 300 400 400 400 400 400 500 500 500 500 500 B.840 0.568 0.000 0.235 0.961 0.800 0.650 0.046 0.297 0.144 0.970 0.324 0.273 0.378 0.552 0.

094 100 3.00 33096.395 0.00 Guloso 13463.530 0.400 1.00 31148.028 0.462 0.800 0.000 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.812 0.000 1.474 0.218 7.00 32207.469 0.00 20 39 .086 0.300 1.623 2.553 desv.00 34319.00 34319.274 0.850 0.3.358 0.299 0.00 25955.035 0.496 0.00 20 20 48454.00 26288.888 200 B.143 0.159 0.012 0.435 0.447 0. 0.00 10 10 10 10 10 7 8 9 10 33096.373 0.447 0.420 0.050 0.900 0.800 0.274 0.417 0.00 Back.00 20314.00 33893.970 0.189 0.588 max 1.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.111 0.503 0.00 20503.400 0.106 0.910 0.900 0.1 Conjunto I 1 2 3 4 5 6 10 20 30 40 50 Dinamico 14276.306 0.002 0.474 0.716 0.331 0.00 31148.142 0.337 0.342 0.841 1.754 0.906 11.027 0.649 0.800 0.234 0.000 0.004 100 41.026 0.528 0.910 0. 14276.375 0.00 48454.28 29 30 31 32 20 30 40 50 10 0.730 0.883 0.890 0.405 0.773 0.697 42.197 11.030 0.00 31122.700 0.318 0.754 0.130 0.314 1.740 1.121 0.498 100 1.000 0.270 0.222 0.00 20503.479 0.00 26288.085 0.512 0.021 108.00 47708.181 100 1.144 0.

00 81565.00 1094717.00 126150.00 94349.00 467250.00 1651357.00 573983.00 76761.00 851705.00 224695.00 1117518.00 40 108874.00 133837.00 225225.00 837932.00 907682.00 696382.00 661586.00 276070.00 40 88281.00 1435879.00 319273.00 88281.00 1290594.00 837633.00 108874.00 108189.00 66220.00 695955.00 59331.00 46244.00 225225.00 1651514.00 983043.00 105237.00 573983.00 105394.00 173403.00 318824.00 300 300 300 300 300 10 20 30 40 50 636679.00 155956.00 108386.00 983043.00 1176953.00 1435879.00 40 126150.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 .00 353836.00 1437342.00 636239.00 1437606.00 1094717.00 353349.00 173403.00 1117518.00 1437606.00 735671.00 467250.00 159587.00 696382.00 159117.00 140701.00 94082.00 907330.00 200 200 200 200 200 10 20 30 40 50 491996.00 134295.00 907682.00 353836.00 134295.00 1176508.00 661586.00 100 100 100 100 100 10 20 30 40 50 329200.00 275470.00 661056.00 40 10 20 30 40 50 74270.00 66220.00 155182.00 60735.00 20 13 14 15 16 17 18 10 20 30 40 50 46778.00 125697.10 11 12 30 59570.00 851705.00 1651514.00 81565.00 74270.00 466546.00 1094409.00 329200.00 80927.00 491996.00 1290068.00 1117112.00 59570.00 155956.00 108386.00 1176953.00 636679.00 87548.00 573761.00 40 141115.00 68721.00 328781.00 30 30 30 30 30 10 20 30 40 50 61772.00 276070.00 319273.00 107406.00 1290594.00 94349.00 851307.00 69157.00 61772.00 20 50 76959.00 173076.00 400 400 400 400 400 10 20 30 40 837932.00 141115.00 735181.00 491460.00 46778.00 73779.00 982816.00 50 50 50 50 50 10 20 30 40 50 159587.00 105394.00 1435541.00 735671.00 20 40 69157.00 65214.00 76959.

00 5377.00 11194.00 37847.00 46482.00 37893.00 46526.00 67436.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 73981.00 13785.00 37893.00 20 20 20 20 20 10 20 30 40 50 5153.00 8751.00 66397.00 83481.00 14074.00 30 7268.00 40 14074.00 3083.00 17681.00 2044.00 4355.00 3462.60 50 1832626.00 30 83481.00 5443.00 24188.00 8826.00 11243.00 13785.00 11243.00 15914.00 16965.00 33975.00 10411.00 6291.00 57248.00 32672.00 34010.00 7072.00 5153.00 66397.00 17646.00 5480.00 40 8194.00 6349.00 200 200 200 200 200 1 2 3 4 5 6 7 8 9 10 11 12 2885.00 8186.00 30 10 20 30 40 50 5443.00 3462.00 11213.00 1832218.00 4302.00 10141.00 29518.00 300 67374.00 29518.00 46954.00 7268.00 46526.2 Conjunto I 10 20 30 40 50 Dinamico Back.00 30 10141.00 12383.00 24188.00 13734.00 500 C.00 2083.00 6985.00 20 67436.00 29450.00 10 10 10 10 10 10 20 30 40 50 2885.00 1295.00 5480.00 50 50 50 50 50 10 20 30 40 50 16965.00 5431.00 12358.00 30 11243.00 3448.00 2609.00 Guloso 1277.00 66372.00 6349.00 7883.00 1832626.00 16893.00 30 8826.00 3016.00 300 83448.00 2609.00 8194.00 11243.00 300 41 .00 4355.00 10101.00 40 10455.00 24129.00 73936.00 14047.00 3083.00 7831.00 32631.00 2854.00 57293.00 10455.00 40 10 20 30 40 50 7883.00 34010.00 17681.00 46922.00 57293.00 73981. 1295.00 2536.00 15880.00 100 100 100 100 100 10 20 30 40 50 32672.00 2083.00 40 12383.00 5059.00 7197.00 15914.

00 13813.00 11613.00 81070.00 7339.00 183215.00 5349.00 11192.00 91525.00 1223.00 7397.00 6368.00 10 1623.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 145819.00 5506.00 112920.00 5674.00 11613.00 3935.00 2840.00 8771.00 638.00 141619.00 10 2674.00 96708.47 48 40 96750.00 30 30 30 30 30 10 20 30 40 50 2859.00 130763.00 2338.00 9011.00 1223.00 300 50 108015.00 130727.00 10 10 20 30 40 50 1380.00 4476.00 91576.00 400 10 20 30 40 50 81070.00 145795.00 7206.00 164132.00 7339.00 107981.00 3407.00 5691.00 400 130763.00 100 536.00 164171.00 4918.00 2680.00 638.00 10 1125.00 8719.00 55 56 57 58 59 60 81031.00 108015.00 400 112954.00 115021.00 9018.00 400 91576.00 50 11617.00 2313.00 2530.00 96750.00 50 9018.00 3671.00 5691.00 115021.00 63933.00 Guloso 5031.00 3935.00 400 145819.00 63963.00 9170.00 3419. 5042.00 141652.00 5674.00 4656.00 5042.00 9011.00 2530.00 1243.00 14151.00 112954.00 11617.00 20 20 20 20 20 10 20 30 40 50 2166.00 2840.00 2166.00 500 500 500 500 500 C.00 7243.00 164171.00 50 6368.00 4656.00 9513.00 50 14151.00 7095.00 3620.00 5165.00 100 42 .00 10 2110.00 1787.00 5165.00 2041.00 9513.00 7019.00 183215.3 Conjunto I 10 10 20 30 40 50 Dinamico Back.00 2859.00 2313.00 183186.00 7397.00 11382.00 1380.00 114992.00 3620.00 3548.00 1787.00 141652.00 300 49 50 51 52 53 54 10 20 30 40 50 63963.00 6155.00 10 20 30 40 50 3548.

00 57529.00 4709.00 2259.00 28353.00 36675.00 73881.00 100 100 100 100 14515.00 Guloso 396.00 146195.00 65315.00 71334.00 765.00 2999.00 25699.00 2342.00 3107.00 145895.00 10 20 30 40 50 12839.00 1300.00 52097.00 1755.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 .00 7835.00 71023.00 1873.00 445. 445.00 119524.00 18025.00 36453.00 943.00 4709.00 4678.00 28658.00 38885.00 115910.00 4998.00 25872.00 23491.00 14322.00 92992.00 4968.00 2002.00 1873.00 73570.00 39047.00 119814.00 55128.00 1404.00 87036.00 3141.00 29061.00 23491.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.00 2342.00 55396.00 36632.00 46964.00 115741.00 6236.00 1004.00 3998.4 Conjunto I 10 20 30 40 50 Dinamico Back.00 2999.00 12652.00 23229.00 1550.00 932.00 1404.00 7794.00 18235.00 20 20 20 20 20 10 20 30 40 50 1572.00 2002.00 94710.00 47200.00 932.00 65513.00 3141.00 51898.00 400 400 400 400 400 10 20 30 40 50 36710.00 6273.00 6273.00 95073.00 57240.00 1921.00 18235.00 92724.00 7835.00 3924.00 86856.00 28658.00 4998.00 10 10 10 10 10 10 20 30 40 50 1004.34 35 36 37 20 30 40 50 12839.00 300 300 300 300 300 10 20 30 40 50 29204.00 3998.00 1572.00 21708.00 200 200 200 200 200 10 20 30 40 50 21859.00 2917.

00 9723.00 7755.00 2419.00 60540.00 10051.00 7298.00 500 500 500 500 500 25 26 27 28 29 30 2442.00 75714.00 12145.00 10 20 30 40 50 20284.00 80626.00 100686.00 100 10047.00 100834.00 29978.00 25045.00 100686.00 4875.00 9705.00 74659.00 100 15051.00 74663.00 12122.00 100 10212.00 25368.00 7783.00 9683.00 50556.00 200 40571.00 20347.00 40427.00 44888.00 40 40 40 40 40 10 20 30 40 50 2442.00 400 400 400 400 400 10 20 30 40 50 25368.00 5031.00 100 25035.00 12145.00 15054.00 40575.00 200 10 20 30 40 50 15045.00 5826.00 59783.00 5841.00 40427.00 100 20047.00 200 20340.00 15043.00 59782.00 50671.00 200 50670.20 21 22 23 24 10 20 30 40 50 1953.00 20283.00 80625.00 7298.00 125928.00 50556.00 3900.00 7280.00 9721.00 29979.00 3900.00 10 20 30 40 50 10 20 30 40 50 5042.00 1913.00 60538.00 125928.00 100834.00 7783.00 75714.00 44890.00 20052.00 1953.00 30471.00 3838.00 200 30469.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 .00 9721.00 4850.00 10213.00 4875.00 5841.00 9723.

Sign up to vote on this title
UsefulNot useful