Análise dos algoritmos da Mochila fracionária e

Escalonador de Tarefas
Áveles Filho
1Estudantes de Ciência da Computação – Universidade da Amazônia (UNAMA)
Caixa Postal 287 – 66060-902 –Belém – PA – Brasil

aveles.filho@gmail.com

Abstract. This article aims to implement two algorithms: fractional Backpack

and Task Scheduler for performance analysis, testing and function with
entries in several different programming languages.
Resumo. Este artigo tem como objetivo implementar 2 algoritmos: Mochila
fracionária e Escalonador de Tarefas, para análise de performance, teste e
funcionalidade com entradas variadas em diversas linguagens de
programação .
.

1. Introdução

Para resolver um problema, um algoritmo guloso escolhe, em cada iteração,

o objeto mais "apetitoso" que vê pela frente. (A definição de "apetitoso" é
estabelecida a priori.) O objeto escolhido passa a fazer parte da solução que
o algoritmo constrói.

Um algoritmo guloso é "míope": ele toma decisões com base nas

informações disponíveis na iteração corrente, sem olhar as consequências
que essas decisões terão no futuro. Um algoritmo guloso jamais se
arrepende ou volta atrás: as escolhas que faz em cada iteração são
definitivas.

Embora algoritmos gulosos pareçam obviamente corretos, a prova de sua

correção é, em geral, muito sutil. Para compensar, algoritmos gulosos são
muito rápidos e eficientes. (É preciso dizer, entretanto, que os problemas
que admitem soluções gulosas são um tanto raros.)

2. Algoritmos gulosos
 Tipicamente algoritmos gulosos são usados para a resolução de problemas
de otimização, esses tipos de algoritmos buscam encontrar a solução ótima
para o problema, tendo como característica a escolha de um elemento que
irá compor essa solução ótima e só depois o subproblema será resolvido.
Uma característica semelhante à programação dinâmica é a existência de
uma subestrutura ótima.

Esses algoritmos sempre fazem a escolha parecer a “melhor” usando em

cada iteração um critério guloso, dando a ilusão de encontrar a solução
global para o problema. Em um algoritmo guloso uma escolha que foi feita
nunca é revista, ou seja, não há qualquer tipo de backtracking.

Em geral é fácil projetar ou descrever um algoritmo guloso. O difícil é

provar que ele funciona.

3. Mochila Fracionária.
3.1. Implementação
O algoritmo da mochila fracionária foi implementada na linguagem de
programação java para desktop.
3.2. Entradas
As entradas Poderão ser descritas de duas formas, a primeira pelo próprio
programa, setando as variáveis logo quando declaradas, e a segunda através de
uma classe visual do Java, chamada Swing, na qual há a interatividade com o
usuário e permite setar o conteúdo dessas variáveis a partir do que o usuário
digitar na interface.

Figura1. Entradas de dados através do swing do Java

3.3. Método Principal
O método principal servirá apenas para criar a(s) lista(s) com as informações
que precisaremos para resolver o problema, e para apresentar a resposta
utilizando uma dessas listas.
Assim, teremos quatro listas, sendo uma para cálculos para gerar a resposta que
seria a lista produtos, que receberá o peso dos produtos em unidades de peso,
junto com o seu preço total. Duas lista, resposta e ordem, será para apresentar a
resposta final ao rodar o programa, onde a primeira terá os produtos ordenados
com a melhor relação custo benefício em ordem crescente, e a segunda lista terá
a ordem em que foram inseridos na mochila. A última lista terá apenas o texto de
apresentação da resposta, para ser mostrado na classe visual ou no console da
IDE de programação Java, conforme figura2.

Figura 2. Método Principal

3.4. Classe Mochila
A Classe mochila recebá os valores através de parâmetros e calculará a relação
custo-benefício, adicionando em duas lista a relação e os dados de cada produto
conforme figura 3 abaixo.
 Figura 3. Estrutura de dados e cálculos para o início do algoritmo.
Tais dados são inseridos na instância de uma classe dados criada para a solução
do problema, tal classe contem a ordem de inserção do produto que é um inteiro,
o valor que é real, e a quantidade, sendo real também. É setado esses valores de
parâmetros vindos da classe mochila.

Figura 4. Classe Dados

O algoritmo faz a ordenação em ordem crescente da relação custo-benefício na
lista relação.

Figura 5. Método para ordenação de uma lista

Após termos a ordenação sobre a relação, fazemos a ordenação da lista sobre os
dados inseridos na lista lista, criando uma classe comparator, que tem a função
de comparar valores e retorna verdadeiro ou falso, caso consiga a ordenação
retornará verdadeira, no caso contrário não, mostrado na figura abaixo.

Figura 6. Classe comparator e ordenação da lista lista

E por fim, tendo a ordem dos produtos para colocarmos na mocila, começamos a
encher nossa mochila, atendemos a erros como falta de espaço na mochila ou
falta de produtos para encher a mochila. A mochila a cada inserção terá seu
tamanho diminuito para carregar os produtos até que chegue a zero ou falte
produtos a serem colocados,mostrado na figura 7.

Figura 7. Mochila sendo enchida pelos produtos

 E por último foi criado um método para retornar a ordem das inserções dos
produtos na mochila.

Figura 8. Ordem de inserção dos produtos sendo definida e armazenada na lista ordem
3.5. Saída
A Classe principal receberá da classe mochila os valores através de parâmetros e
calculará a relação custo-benefício, adicionando em duas lista a relação e os dados
de cada produto conforme figura 2 abaixo.

Figura 9. Resultado do algoritmo, em console e usando a classe visual Swing do Java

4. Greedy1(FIFO – First In First Out).

4.1. Implementação
O algoritmo do FIFO foi implementada na linguagem de programação java para
desktop.
4.2. Entradas
As entradas Poderão ser descritas de duas formas, a primeira pelo próprio
programa, setando as variáveis logo quando declaradas, e a segunda através de
uma classe visual do Java, chamada Swing, na qual há a interatividade com o
usuário e permite setar o conteúdo dessas variáveis a partir do que o usuário
digitar na interface.
 Figura10. Entradas de dados através do swing do Java

4.3. Método Principal

O método principal servirá apenas para criar a(s) lista(s) com as informações
que precisaremos para resolver o problema, e para apresentar a resposta
utilizando uma dessas listas.
Assim, teremos duas listas, sendo uma para cálculos para gerar a resposta que
seria a lista processos, que receberá o tempo dos processos em unidades de
tempo. A lista texto será para apresentar a resposta final ao rodar o programa,
onde a aparecerá os processos ordenados em ordem crescente de acordo com a
sua chegada, para ser mostrado na classe visual ou no console da IDE de
programação Java, conforme figura11.

Figura 11. Método Principal

4.4. Classe tarefas
A Classe tarefas recebá os valores através de parâmetros e adicionará na lista de
processos para serem processados e calculados conforme figura 12 abaixo.
 Figura 12. Estrutura de dados e cálculos para o início do algoritmo.
4.5. Saída
A Classe principal receberá da classe tarefas os valores através de parâmetros e
calculará o tempo de execução e a média do tempo de execução, adicionando em
uma lista e apresentando de cada processo conforme figura 13 abaixo.

Figura 13. Resultado do algoritmo, em console e usando a classe visual Swing do Java
 5. Greedy2(Ordem por tempo de execução).
5.1. Implementação
O algoritmo do Greedy2 foi implementada na linguagem de programação java
para desktop.
5.2. Entradas
As entradas Poderão ser descritas de duas formas, a primeira pelo próprio
programa, setando as variáveis logo quando declaradas, e a segunda através de
uma classe visual do Java, chamada Swing, na qual há a interatividade com o
usuário e permite setar o conteúdo dessas variáveis a partir do que o usuário
digitar na interface.

Figura14. Entradas de dados através do swing do Java

5.3. Método Principal

O método principal servirá apenas para criar a(s) lista(s) com as informações
que precisaremos para resolver o problema, e para apresentar a resposta
utilizando uma dessas listas.
Assim, teremos duas listas, sendo uma para cálculos para gerar a resposta que
seria a lista processos, que receberá o tempo dos processos em unidades de
tempo. A lista texto será para apresentar a resposta final ao rodar o programa,
onde a aparecerá os processos ordenados em ordem crescente de acordo com a
sua chegada, para ser mostrado na classe visual ou no console da IDE de
programação Java, conforme figura15.
 Figura 15. Método Principal
5.4. Classe tarefas
A Classe tarefas recebá os valores através de parâmetros e adicionará na lista de
processos para serem processados e calculados, detalhando que os processos serão
ordenados por tempo em ordem crescente, o método sort da classe Collections
fará a ordenação conforme figura 16 abaixo.

Figura 16. Estrutura de dados e cálculos para o início do algoritmo.

5.5. Saída
A Classe principal receberá da classe tarefas os valores através de parâmetros e
calculará o tempo de execução e a média do tempo de execução, adicionando em
uma lista e apresentando de cada processo conforme figura 13 baixo.

Figura 17. Resultado do algoritmo, em console e usando a classe visual Swing do Java

Referencias:
http://www.univercidade.edu/uc/cursos/graduacao/ciencomp/pdf/linha_ic.pdf
http://www.ica.ele.puc-rio.br/compint/index.rails?name=Intelig%C3%AAncia
%20Computacional
http://www.portaldotransito.com.br/category/estatisticas
www.denatran.gov.br/