Disciplina: Técnicas de programação

Curso: Engenharia da computação

Aula 12 – Algoritmos gulosos

Instituto Federal de São Paulo – Birigui

rafael.joao@ifsp.edu.br
P R O F. R A FA E L S TO F FA L E T T E J O Ã O Atendimento: sala ADM113
Qua 13h00 às 14h00
DATA : 2 4 / 0 4 / 2 0 1 9 Qui 18h30 às 20h30
Função polinomial
Em matemática, função polinomial é uma função que pode ser expressa da forma: em que é um
número inteiro não negativo e os números são constantes, chamadas de coeficientes do
polinômio.

Função polinomial de grau 1: f(x) = x + 6

Função polinomial de grau 2: g(x) = 2x2 + x - 2
Função polinomial de grau 3: h(x) = 5x3 + 10x2 - 6x + 15
Função polinomial de grau 4: p(x) = 20x4 - 15x3+ 5x2 + x - 10
Função polinomial de grau 5: q(x) = 25x5 + 12x4 - 9x3 + 5x2 + x - 1

24/04/2019 2
Problemas P
O problema P é um problema de decisão (ou seja, a resposta pode ser sim ou não), que possa
ser resolvido em tempo polinomial. (problemas tratáveis)
◦ problemas que são resolvidos pelos computadores em um tempo razoável

São chamados assim porque seu tempo de cálculo é descrito por um polinômio no tamanho dos
dados.

Por exemplo, o problema de multiplicar duas matrizes de n fileiras e colunas pode ser resolvido
utilizando menos de n3 multiplicações.

24/04/2019 3
Problemas NP
O problema NP (Non-Deterministic Polynomial time) pode ser provado mas não resolvido em
tempo polinomial.
◦ Dada uma entrada, podemos verificar se ela é uma solução de um problema NP.
◦ Inclui todos os problemas da classe P, mas também muitos outros que se comportam de maneira
intrigante.

Ninguém conseguiu demonstrar que são intratáveis. Estão em uma espécie de limbo
informático: não se sabe se são polinomiais ou se são intratáveis

24/04/2019 4
Problemas NP-completos
Os problemas NP-completo
Subclasse da classe NP na qual são agrupados os problemas mais difíceis da classe NP;

Se para qualquer um dos tais problemas se encontrar um algoritmo polinomial, então todos eles
seriam resolvidos em tempo polinomial

P = NP? A pergunta que existe há 45 anos e vale U$1 Milhão.

A questão de saber se P é igual a NP é uma das questões mais importantes em aberto na ciência da
computação.
Se a resposta for sim, para muitos problemas importantes pode ser que há soluções mais
eficientes.

24/04/2019 5
Problemas NP-completos
criptografia atual depende de um problema é da classe NP;

O mais algoritmo mais eficiente de todos levou 18 meses para decompor em fatores um número
de 200 cifras decimais, que são os habitualmente usados em criptografia.

A segurança das senhas reside justamente nessa dificuldade, HOJE.

Se fosse P=NP, então a decomposição em fatores passaria a ser um problema polinomial e

poderia ser resolvido eficientemente.

24/04/2019 6
Problemas NP Difíceis
Subclasse dos problemas NP-completos;

Problemas quase impossíveis de serem resolvidos;

24/04/2019 7
Algoritmos aproximados
Problemas NP-Difíceis são demorados, complexos de implementar e complexos de se executar;
◦ Taxa de crescimento muito elevada

Algoritmos Aproximados: Proveem uma solução próxima da melhor possível;

◦ Nem sempre precisamos de uma solução ótima, mas sim uma solução.
◦ Melhor uma solução ótima ou uma solução boa e fácil de implementar?

Encontrar uma solução de um problema não polinomial em tempo polinomial.

24/04/2019 8
 Algoritmos gulosos (greedy)
Algoritmos que tomam a decisão aparentemente mais apropriada;
◦ escolha que parece ser a melhor no momento;
◦ decisões apenas com informações disponíveis - não se preocupa com os efeitos futuros das decisões,
◦ A cada iteração tomam a decisão que ”parece” mais satisfatória;

24/04/2019 9
 Algoritmos gulosos (greedy)
Algoritmos que tomam a decisão aparentemente mais apropriada;
◦ escolha que parece ser a melhor no momento;
◦ decisões apenas com informações disponíveis - não se preocupa com os efeitos futuros das decisões,
◦ A cada iteração tomam a decisão que ”parece” mais satisfatória;

Não há reconsideração da tomada de decisão;

◦ Não há backtracking.
◦ Come enquanto houver possibilidade sem pensar no amanhã.

24/04/2019 10
 Algoritmos gulosos (greedy)
Algoritmos que tomam a decisão aparentemente mais apropriada;
◦ escolha que parece ser a melhor no momento;
◦ decisões apenas com informações disponíveis - não se preocupa com os efeitos futuros das decisões,
◦ A cada iteração tomam a decisão que ”parece” mais satisfatória;

Não há reconsideração da tomada de decisão;

◦ Não há backtracking.
◦ Come enquanto houver possibilidade sem pensar no amanhã.

Algoritmos simples e de fácil implementação;

Execução muito rápida.

24/04/2019 11
 Algoritmos gulosos (greedy)
Algoritmos que tomam a decisão aparentemente mais apropriada;
◦ escolha que parece ser a melhor no momento;
◦ decisões apenas com informações disponíveis - não se preocupa com os efeitos futuros das decisões,
◦ A cada iteração tomam a decisão que ”parece” mais satisfatória;
Mas qual o critério de escolha?

Não há reconsideração da tomada de decisão;

◦ Não há backtracking.
◦ Come enquanto houver possibilidade sem pensar no amanhã.

Algoritmos simples e de fácil implementação;

Execução muito rápida.

24/04/2019 12
Algoritmos gulosos (greedy)
Um critério guloso deve ser elaborado previamente à execução do algoritmo

É responsável por uma decisão localmente ótima!

24/04/2019 13
Algoritmos gulosos (greedy)
Um critério guloso deve ser elaborado previamente à execução do algoritmo

É responsável por uma decisão localmente ótima!

Tempo de execução

Quantidade de tarefas realizadas

24/04/2019 14
Algoritmos gulosos (greedy)
Um critério guloso deve ser elaborado previamente à execução do algoritmo

É responsável por uma decisão localmente ótima!

Tempo de execução
Ou seja:

Nem sempre o algoritmo

guloso encontra a melhor
solução possível (ÓTIMA)

Quantidade de tarefas realizadas

24/04/2019 15
Algoritmos gulosos (greedy)
Computar uma solução que maximiza ou minimizar algum objetivo;
◦ Maximizar a quantidade de elementos/tarefas/moedas/itens/…
◦ Minimizar o tempo gasto/tarefas realizadas/custo/...

Dependente de informações;
◦ Maximizar/Minimizar por algoritmos gulosos só é possível se houver informações sobre o domínio.

24/04/2019 16
Algoritmo guloso – Problema do
escalonamento de tarefas
Vamos exemplificar:
◦ Temos que escalonar as tarefas de forma a realizar o máximo de tarefas possíveis durante o expediente
de trabalho;
◦ Só se realiza uma tarefa por vez (São homens que estão trabalhando).

Cada tarefa é composta por um intervalo de tempo [i,f] (início, fim)

◦ T1: [1,4]. Significa que a T1 inicia em 1 e termina em 4;

24/04/2019 17
Tarefas
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
T1
T2
T3
T4
T5
T6
T7
T8
T9
T10
T11

24/04/2019 18
Intervalos disjuntos
Dois intervalos são disjuntos se eles não se sobrepõem;
◦ T1 se sobrepõe a T2 e T3 ;
◦ T2 se sobrepõe a T1, T3 e T4;
◦ T3 se sobrepõe a T1, T2 , T3 e T4;
◦ T4 se sobrepõe a T2 e T3;

◦ T1 e T4 não se sobrepõem. 0 1 2 3 4 5 6
T1
T2
T3
T4

24/04/2019 19
Algoritmo guloso – Problema do
escalonamento de tarefas
Vamos exemplificar:

◦ Temos que escalonar as tarefas de forma a realizar o máximo de tarefas disjuntas possíveis durante o
expediente de trabalho;
◦ MAXIMIZAR a quantidade de tarefas;

Critério guloso:
◦ Tarefas que começam primeiro?
◦ Tarefas que terminam primeiro?
◦ Tarefas maiores?
◦ Tarefas menores?

24/04/2019 20
 Algoritmo guloso – Problema do
escalonamento de tarefas
Critério guloso 1:
◦ Tarefas que se iniciam 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
primeiro; T1
T2
T3
T4
T5
T6
T7
T8
T9
T10
T11

24/04/2019 21
 Algoritmo guloso – Problema do
escalonamento de tarefas
Critério guloso 1:
◦ Tarefas que se iniciam 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
primeiro; T1
T2
◦ Quantidade de tarefas T3
realizadas: T4
T5
T6
Solução: {T3, }
T7
T8
T9
T10
T11

24/04/2019 22
 Algoritmo guloso – Problema do
escalonamento de tarefas
Critério guloso 1:
◦ Tarefas que se iniciam 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
primeiro; T1
T2
◦ Quantidade de tarefas T3
realizadas: T4
T5
T6
Solução: {T3, T8, }
T7
T8
T9
T10
T11

24/04/2019 23
 Algoritmo guloso – Problema do
escalonamento de tarefas
Critério guloso 1:
◦ Tarefas que se iniciam 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
primeiro; T1
T2
◦ Quantidade de tarefas T3
realizadas: 3 T4
T5
T6
Solução: {T3, T8, T11}
T7
T8
T9
T10
T11

24/04/2019 24
 Algoritmo guloso – Problema do
escalonamento de tarefas
Critério guloso 2:
◦ Tarefas que tem a menor 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
duração; T1
T2
T3
T4
T5
T6
T7
T8
T9
T10
T11

24/04/2019 25
 Algoritmo guloso – Problema do
escalonamento de tarefas
Critério guloso 2:
◦ Tarefas que tem a menor 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
duração; T1
T2
◦ Quantidade de tarefas T3
realizadas: 2 T4
T5
T6
Solução: {T4, T11}
T7
T8
T9
T10
T11

24/04/2019 26
 Algoritmo guloso – Problema do
escalonamento de tarefas
Critério guloso 3:
◦ Tarefas que terminam 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
primeiro; T1
T2
T3
T4
T5
T6
T7
T8
T9
T10
T11

24/04/2019 27
 Algoritmo guloso – Problema do
escalonamento de tarefas
Critério guloso 3:
◦ Tarefas que terminam 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
primeiro; T1
T2
T3
T4
T5
T6
T7
T8
T9
T10
T11

24/04/2019 28
 Algoritmo guloso – Problema do
escalonamento de tarefas
Critério guloso 3:
◦ Tarefas que terminam 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
primeiro; T1
T2
T3
T4
T5
T6
T7
T8
T9
T10
T11

24/04/2019 29
 Algoritmo guloso – Problema do
escalonamento de tarefas
Critério guloso 3:
◦ Tarefas que terminam 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
primeiro; T1
T2
T3
T4
T5
T6
T7
T8
T9
T10
T11

24/04/2019 30
 Algoritmo guloso – Problema do
escalonamento de tarefas
Critério guloso 3:
◦ Tarefas que terminam 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
primeiro; T1
T2
◦ Quantidade de tarefas T3
realizadas: 4 T4
T5
T6
Solução: {T1, T4, T8, T11}
T7
T8
T9
T10
T11

24/04/2019 31
 Algoritmo guloso – Problema do
escalonamento de tarefas
Critério guloso 3:
◦ Tarefas que terminam 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
primeiro; T1
T2
◦ Quantidade de tarefas T3
realizadas: 4 T4
T5
T6
Solução: {T1, T4, T8, T11}
T7
T8
T9
Solução ótima!
T10
T11

24/04/2019 32
Algoritmo guloso – Problema do
escalonamento de tarefas
Critério guloso 3:
◦ Tarefas que terminam primeiro;

Algoritmo:
◦ Entrada: Vetor de tarefas;
◦ Saída: Tarefas escalonadas;

◦ Passo 1: Ordenar as tarefas pelo seu término de forma crescente;

◦ Passo 2: Selecionar a primeira tarefa do conjunto ordenado e colocá-la no conjunto de soluções;
◦ Passo 3: Somar o tempo total gasto;
◦ Passo 4: Selecionar a próxima Tarefa no vetor que se inicia após o termino da atual e termina primeiro das
demais;
◦ Passo 5: Verificar se o tempo de duração da Tarefa não excede o total disponível;
◦ Passo 6: Repetir os passos 3, 4 e 5 até atingir o tempo total.

24/04/2019 33
Algoritmo guloso – Problema do troco
Quando uma compra gera um troco, algumas
perguntas devem ser respondidas antes de
executar a tarefa

Quais as moedas disponíveis?

Quanto é o valor que deve ser dado de troco?
Quais as combinações possíveis de moedas para
atingir o valor do troco?
Qual a melhor combinação para entregar menos
moedas?

◦ MAXIMIZAÇÃO ou MINIMIZAÇÃO?

24/04/2019 34
Algoritmo guloso – Problema do troco
Quando uma compra gera um troco, algumas
perguntas devem ser respondidas antes de
executar a tarefa

Quais as moedas disponíveis?

Quanto é o valor que deve ser dado de troco?
Quais as combinações possíveis de moedas para
atingir o valor do troco?
Qual a melhor combinação para entregar menos
moedas?

◦ MAXIMIZAÇÃO ou MINIMIZAÇÃO de moedas

24/04/2019 35
Algoritmo guloso – Problema do troco
M = {1, 2, 5, 10, 20} moedas disponíveis.

Devolver o troco no valor de 43 centavos:

Quais combinações possíveis?

24/04/2019 36
Algoritmo guloso – Problema do troco
M = {1, 2, 5, 10, 20} moedas disponíveis.

Devolver o troco no valor de 43 centavos:

Quais combinações possíveis?

{1, 2, 5, 5, 10, 10, 10 }
{ 20, 20, 2, 1 }
{1, 1, 1, 2, 2, 2, 2, 2, 10, 20}
{10, 10, 10, 10, 2, 1}
... Qual a melhor combinação? Por que?

24/04/2019 37
Algoritmo guloso – Problema do troco
Estratégia:

◦ Ordenar de forma decrescente (pelos valores) as

moedas;

◦ Iniciar pelas moedas mais valiosas –

consequentemente menos unidades;

◦ Até atingir o valor do troco desejado.

24/04/2019 38
Algoritmo guloso – Problema do troco
M = {1, 2, 5, 10, 20} moedas disponíveis.

Devolver o troco no valor de 43 centavos:

M’ = {20, 10, 5, 2, 1}
trocoGerado = 0
trocoDesejado = 43

24/04/2019 39
Algoritmo guloso – Problema do troco
M’ = {20, 10, 5, 2, 1}
trocoGerado = 0
trocoDesejado = 43

Enquanto trocoGerado < trocoDesejado:

SE M`[i] + trocoGerado <= trocoDesejado

◦ Solucao.Add(M`[i])
◦ trocoGerado + = M’[i]

SENÃO: i++
FIM ENQUANTO;

24/04/2019 40
Algoritmo guloso – Problema do troco
M’ = {20, 10, 5, 2, 1}
trocoGerado = 0
trocoDesejado = 43 0 43
trocoGerado trocoDesejado

Enquanto trocoGerado < trocoDesejado:

SE M`[i] + trocoGerado <= trocoDesejado

◦ Solucao.Add(M`[i])
◦ trocoGerado + = M’[i]

SENÃO: i++
FIM ENQUANTO;

Solução: {}

24/04/2019 41
Algoritmo guloso – Problema do troco
M’ = {20, 10, 5, 2, 1}
trocoGerado = 0
trocoDesejado = 43 0 43
trocoGerado trocoDesejado

Enquanto trocoGerado < trocoDesejado:

SE M`[i] + trocoGerado <= trocoDesejado

◦ Solucao.Add(M`[i])
◦ trocoGerado + = M’[i]
20
SENÃO: i++
FIM ENQUANTO; 20 + 0 <= 43?

Solução: {}

24/04/2019 42
Algoritmo guloso – Problema do troco
M’ = {20, 10, 5, 2, 1}
trocoGerado = 0
trocoDesejado = 43 20 43
trocoGerado trocoDesejado

Enquanto trocoGerado < trocoDesejado:

SE M`[i] + trocoGerado <= trocoDesejado

◦ Solucao.Add(M`[i])
◦ trocoGerado + = M’[i]
20
SENÃO: i++
FIM ENQUANTO; 20 + 0 <= 43?

Solução: {20}

24/04/2019 43
Algoritmo guloso – Problema do troco
M’ = {20, 10, 5, 2, 1}
trocoGerado = 0
trocoDesejado = 43 20 43
trocoGerado trocoDesejado

Enquanto trocoGerado < trocoDesejado:

SE M`[i] + trocoGerado <= trocoDesejado

◦ Solucao.Add(M`[i])
◦ trocoGerado + = M’[i]
20
SENÃO: i++
FIM ENQUANTO; 20 + 20 <= 43?

Solução: {20}

24/04/2019 44
Algoritmo guloso – Problema do troco
M’ = {20, 10, 5, 2, 1}
trocoGerado = 0
trocoDesejado = 43 40 43
trocoGerado trocoDesejado

Enquanto trocoGerado < trocoDesejado:

SE M`[i] + trocoGerado <= trocoDesejado

◦ Solucao.Add(M`[i])
◦ trocoGerado + = M’[i]
20
SENÃO: i++
FIM ENQUANTO; 20 + 20 <= 43?

Solução: {20, 20}

24/04/2019 45
Algoritmo guloso – Problema do troco
M’ = {20, 10, 5, 2, 1}
trocoGerado = 0
trocoDesejado = 43 40 43
trocoGerado trocoDesejado

Enquanto trocoGerado < trocoDesejado:

SE M`[i] + trocoGerado <= trocoDesejado

◦ Solucao.Add(M`[i])
◦ trocoGerado + = M’[i]
20
SENÃO: i++
FIM ENQUANTO; 20 + 40 <= 43?

Solução: {20, 20}

24/04/2019 46
Algoritmo guloso – Problema do troco
M’ = {20, 10, 5, 2, 1}
trocoGerado = 0
trocoDesejado = 43 40 43
trocoGerado trocoDesejado

Enquanto trocoGerado < trocoDesejado:

SE M`[i] + trocoGerado <= trocoDesejado

◦ Solucao.Add(M`[i])
◦ trocoGerado + = M’[i]
20
SENÃO: i++
FIM ENQUANTO; 20 + 40 <= 43?

Solução: {20, 20}

24/04/2019 47
Algoritmo guloso – Problema do troco
M’ = {20, 10, 5, 2, 1}
trocoGerado = 0
trocoDesejado = 43 40 43
trocoGerado trocoDesejado

Enquanto trocoGerado < trocoDesejado:

SE M`[i] + trocoGerado <= trocoDesejado

◦ Solucao.Add(M`[i])
◦ trocoGerado + = M’[i]
10
SENÃO: i++
FIM ENQUANTO; 10 + 40 <= 43?

Solução: {20, 20}

24/04/2019 48
Algoritmo guloso – Problema do troco
M’ = {20, 10, 5, 2, 1}
trocoGerado = 0
trocoDesejado = 43 40 43
trocoGerado trocoDesejado

Enquanto trocoGerado < trocoDesejado:

SE M`[i] + trocoGerado <= trocoDesejado

◦ Solucao.Add(M`[i])
◦ trocoGerado + = M’[i]
10
SENÃO: i++
FIM ENQUANTO; 10 + 40 <= 43?

Solução: {20, 20}

24/04/2019 49
Algoritmo guloso – Problema do troco
M’ = {20, 10, 5, 2, 1}
trocoGerado = 0
trocoDesejado = 43 40 43
trocoGerado trocoDesejado

Enquanto trocoGerado < trocoDesejado:

SE M`[i] + trocoGerado <= trocoDesejado

◦ Solucao.Add(M`[i])
◦ trocoGerado + = M’[i]
5
SENÃO: i++
FIM ENQUANTO; 5 + 40 <= 43?

Solução: {20, 20}

24/04/2019 50
Algoritmo guloso – Problema do troco
M’ = {20, 10, 5, 2, 1}
trocoGerado = 0
trocoDesejado = 43 40 43
trocoGerado trocoDesejado

Enquanto trocoGerado < trocoDesejado:

SE M`[i] + trocoGerado <= trocoDesejado

◦ Solucao.Add(M`[i])
◦ trocoGerado + = M’[i]
5
SENÃO: i++
FIM ENQUANTO; 5 + 40 <= 43?

Solução: {20, 20}

24/04/2019 51
Algoritmo guloso – Problema do troco
M’ = {20, 10, 5, 2, 1}
trocoGerado = 0
trocoDesejado = 43 40 43
trocoGerado trocoDesejado

Enquanto trocoGerado < trocoDesejado:

SE M`[i] + trocoGerado <= trocoDesejado

◦ Solucao.Add(M`[i])
◦ trocoGerado + = M’[i]
2
SENÃO: i++
FIM ENQUANTO; 2 + 40 <= 43?

Solução: {20, 20}

24/04/2019 52
Algoritmo guloso – Problema do troco
M’ = {20, 10, 5, 2, 1}
trocoGerado = 0
trocoDesejado = 43 42 43
trocoGerado trocoDesejado

Enquanto trocoGerado < trocoDesejado:

SE M`[i] + trocoGerado <= trocoDesejado

◦ Solucao.Add(M`[i])
◦ trocoGerado + = M’[i]
2
SENÃO: i++
FIM ENQUANTO; 2 + 40 <= 43?

Solução: {20, 20, 2}

24/04/2019 53
Algoritmo guloso – Problema do troco
M’ = {20, 10, 5, 2, 1}
trocoGerado = 0
trocoDesejado = 43 42 43
trocoGerado trocoDesejado

Enquanto trocoGerado < trocoDesejado:

SE M`[i] + trocoGerado <= trocoDesejado

◦ Solucao.Add(M`[i])
◦ trocoGerado + = M’[i]
2
SENÃO: i++
FIM ENQUANTO; 2 + 42 <= 43?

Solução: {20, 20, 2}

24/04/2019 54
Algoritmo guloso – Problema do troco
M’ = {20, 10, 5, 2, 1}
trocoGerado = 0
trocoDesejado = 43 42 43
trocoGerado trocoDesejado

Enquanto trocoGerado < trocoDesejado:

SE M`[i] + trocoGerado <= trocoDesejado

◦ Solucao.Add(M`[i])
◦ trocoGerado + = M’[i]
2
SENÃO: i++
FIM ENQUANTO; 2 + 42 <= 43?

Solução: {20, 20, 2}

24/04/2019 55
Algoritmo guloso – Problema do troco
M’ = {20, 10, 5, 2, 1}
trocoGerado = 0
trocoDesejado = 43 43 43
trocoGerado trocoDesejado

Enquanto trocoGerado < trocoDesejado:

SE M`[i] + trocoGerado <= trocoDesejado

◦ Solucao.Add(M`[i])
◦ trocoGerado + = M’[i]
1
SENÃO: i++
FIM ENQUANTO; 1 + 42 <= 43?

Solução: {20, 20, 2}

24/04/2019 56
Algoritmo guloso – Problema do troco
M’ = {20, 10, 5, 2, 1}
trocoGerado = 0
trocoDesejado = 43 43 43
trocoGerado trocoDesejado

Enquanto trocoGerado < trocoDesejado:

SE M`[i] + trocoGerado <= trocoDesejado

◦ Solucao.Add(M`[i])
◦ trocoGerado + = M’[i]
1
SENÃO: i++
FIM ENQUANTO; 1 + 42 <= 43?

Solução: {20, 20, 2, 1}

24/04/2019 57
 Outro teste

24/04/2019 58
Algoritmo guloso – Problema do troco
M = {1, 4, 6}, moedas disponíveis.

Devolver o troco no valor de 8:

24/04/2019 59
Algoritmo guloso – Problema do troco
M = {1, 4, 6}, moedas disponíveis.

Devolver o troco no valor de 8:

M’ = {6, 4, 1}
trocoGerado = 0
trocoDesejado = 8

24/04/2019 60
Algoritmo guloso – Problema do troco
M’ = {6, 4, 1}
trocoGerado = 0
trocoDesejado = 8 0 8
trocoGerado trocoDesejado

Enquanto trocoGerado < trocoDesejado:

SE M`[i] + trocoGerado <= trocoDesejado

◦ Solucao.Add(M`[i])
◦ trocoGerado + = M’[i]

SENÃO: i++
FIM ENQUANTO;

Solução: {}

24/04/2019 61
Algoritmo guloso – Problema do troco
M’ = {6, 4, 1}
trocoGerado = 0
trocoDesejado = 8 0 8
trocoGerado trocoDesejado

Enquanto trocoGerado < trocoDesejado:

SE M`[i] + trocoGerado <= trocoDesejado

◦ Solucao.Add(M`[i])
◦ trocoGerado + = M’[i]
6
SENÃO: i++
FIM ENQUANTO; 6 + 0 <= 8?

Solução: {}

24/04/2019 62
Algoritmo guloso – Problema do troco
M’ = {6, 4, 1}
trocoGerado = 6
trocoDesejado = 8 6 8
trocoGerado trocoDesejado

Enquanto trocoGerado < trocoDesejado:

SE M`[i] + trocoGerado <= trocoDesejado

◦ Solucao.Add(M`[i])
◦ trocoGerado + = M’[i]
6
SENÃO: i++
FIM ENQUANTO; 6 + 0 <= 8?

Solução: {6}

24/04/2019 63
Algoritmo guloso – Problema do troco
M’ = {6, 4, 1}
trocoGerado = 6
trocoDesejado = 8 6 8
trocoGerado trocoDesejado

Enquanto trocoGerado < trocoDesejado:

SE M`[i] + trocoGerado <= trocoDesejado

◦ Solucao.Add(M`[i])
◦ trocoGerado + = M’[i]
6
SENÃO: i++
FIM ENQUANTO; 6 + 6 <= 8?

Solução: {6}

24/04/2019 64
Algoritmo guloso – Problema do troco
M’ = {6, 4, 1}
trocoGerado = 6
trocoDesejado = 8 6 8
trocoGerado trocoDesejado

Enquanto trocoGerado < trocoDesejado:

SE M`[i] + trocoGerado <= trocoDesejado

◦ Solucao.Add(M`[i])
◦ trocoGerado + = M’[i]
6
SENÃO: i++
FIM ENQUANTO; 6 + 6 <= 8?

Solução: {6}

24/04/2019 65
Algoritmo guloso – Problema do troco
M’ = {6, 4, 1}
trocoGerado = 6
trocoDesejado = 8 6 8
trocoGerado trocoDesejado

Enquanto trocoGerado < trocoDesejado:

SE M`[i] + trocoGerado <= trocoDesejado

◦ Solucao.Add(M`[i])
◦ trocoGerado + = M’[i]
4
SENÃO: i++
FIM ENQUANTO; 4 + 6 <= 8?

Solução: {6}

24/04/2019 66
Algoritmo guloso – Problema do troco
M’ = {6, 4, 1}
trocoGerado = 6
trocoDesejado = 8 6 8
trocoGerado trocoDesejado

Enquanto trocoGerado < trocoDesejado:

SE M`[i] + trocoGerado <= trocoDesejado

◦ Solucao.Add(M`[i])
◦ trocoGerado + = M’[i]
4
SENÃO: i++
FIM ENQUANTO; 4 + 6 <= 8?

Solução: {6}

24/04/2019 67
Algoritmo guloso – Problema do troco
M’ = {6, 4, 1}
trocoGerado = 6
trocoDesejado = 8 6 8
trocoGerado trocoDesejado

Enquanto trocoGerado < trocoDesejado:

SE M`[i] + trocoGerado <= trocoDesejado

◦ Solucao.Add(M`[i])
◦ trocoGerado + = M’[i]
1
SENÃO: i++
FIM ENQUANTO; 1 + 6 <= 8?

Solução: {6}

24/04/2019 68
Algoritmo guloso – Problema do troco
M’ = {6, 4, 1}
trocoGerado = 7
trocoDesejado = 8 7 8
trocoGerado trocoDesejado

Enquanto trocoGerado < trocoDesejado:

SE M`[i] + trocoGerado <= trocoDesejado

◦ Solucao.Add(M`[i])
◦ trocoGerado + = M’[i]
1
SENÃO: i++
FIM ENQUANTO; 1 + 6 <= 8?

Solução: {6, 1}

24/04/2019 69
Algoritmo guloso – Problema do troco
M’ = {6, 4, 1}
trocoGerado = 7
trocoDesejado = 8 7 8
trocoGerado trocoDesejado

Enquanto trocoGerado < trocoDesejado:

SE M`[i] + trocoGerado <= trocoDesejado

◦ Solucao.Add(M`[i])
◦ trocoGerado + = M’[i]
1
SENÃO: i++
FIM ENQUANTO; 1 + 7 <= 8?

Solução: {6, 1}

24/04/2019 70
Algoritmo guloso – Problema do troco
M’ = {6, 4, 1}
trocoGerado = 8
trocoDesejado = 8 8 8
trocoGerado trocoDesejado

Enquanto trocoGerado < trocoDesejado:

SE M`[i] + trocoGerado <= trocoDesejado

◦ Solucao.Add(M`[i])
◦ trocoGerado + = M’[i]
1
SENÃO: i++
FIM ENQUANTO; 1 + 7 <= 8?

Solução: {6, 1, 1}

24/04/2019 71
Algoritmo guloso – Problema do troco
M’ = {6, 4, 1}
trocoGerado = 8
trocoDesejado = 8 8 8
trocoGerado trocoDesejado

Enquanto trocoGerado < trocoDesejado:

SE M`[i] + trocoGerado <= trocoDesejado

◦ Solucao.Add(M`[i])
◦ trocoGerado + = M’[i]
1
SENÃO: i++
FIM ENQUANTO; 1 + 7 <= 8?

Solução: {6, 1, 1} ÓTIMA ? E a solução S2: {4,4} ?

24/04/2019 72
Algoritmo guloso

É míope:
ele toma decisões com base nas informações disponíveis na iteração corrente.

24/04/2019 73
 Problema do troco – algoritmo guloso

24/04/2019
74
Problema da mochila
um ladrão que rouba uma loja encontra N itens, onde cada item i vale vi reais e wi quilos,
sendo vi e wi inteiros. O ladrão deseja levar a carga mais valiosa possível mas, no entanto,
consegue carregar apenas W quilos na sua mochila (W também é um inteiro).

A mochila pode suportar até 50 Kg

Critério guloso:
◦ Maior peso?
◦ Maior valor?
◦ Melhor relação valor/peso?

24/04/2019 75
Problema da mochila
um ladrão que rouba uma loja encontra N itens, onde cada item i vale vi reais e wi quilos,
sendo vi e wi inteiros. O ladrão deseja levar a carga mais valiosa possível mas, no entanto,
consegue carregar apenas W quilos na sua mochila (W também é um inteiro).

A mochila pode suportar até 50 Kg

Critério guloso:
◦ Maior peso?
◦ Maior valor?
◦ Melhor relação valor/peso?

Se o critério guloso de maior valor por kg for adotado o item 1 é o primeiro a ser selecionado

24/04/2019 76
 Problema da mochila
A mochila pode suportar até 50 Kg
Se o critério guloso de maior valor por kg for adotado o item 1 é o primeiro a ser selecionado
Solução ótima

Entretanto nota-se que escolher o item 1 não é vantajoso em

nenhuma possibilidade

24/04/2019 77
 Problema da mochila
A mochila pode suportar até 50 Kg
Se o critério guloso de maior valor por kg for adotado o item 1 é o primeiro a ser selecionado
Solução ótima

Entretanto nota-se que escolher o item 1 não é vantajoso em

nenhuma possibilidade

Não existe solução ótima para o problema da mochila binária

24/04/2019 78
Problema da mochila fracionada
Outra possibilidade é de fracionar os itens.
Ou seja, não é preciso levar o item 1, 2 ou 3 inteiros.

Critério guloso:
◦ Nesse caso a relação valor/peso leva a uma solução
ótima;

24/04/2019 79
Problema da mochila fracionada
1. Ordenar os itens por valor/peso decrescente;
2. Colocar na mochila o máximo do item I (começando em 0) que puder;
3. Passe para o próximo item;

24/04/2019 80
Problema da mochila fracionada
1. Ordenar os itens por valor/peso decrescente;
2. Colocar na mochila o máximo do item I (começando em 0) que puder;
3. Passe para o próximo item;

Solução ótima
24/04/2019 81
Algoritmos gulosos
Tomada de decisão/escolha de caminhos/combinação de possibilidades/...

Tudo isso é muito bem aplicável em grafos.

Próxima aula: Introdução à teoria dos grafos!

24/04/2019 82
Problema do espaço digital
Cada arquivo num computador ocupa um certo número de Kbytes;
Um pendrive com capacidade c Kbytes é selecionado;
Implementar uma estratégia gulosa para gravar o maior número possível de arquivos no
pendrive.

24/04/2019 83
Problema do espaço digital
Cada arquivo num computador ocupa um certo número de Kbytes;
Um pendrive com capacidade c Kbytes é selecionado;
Implementar uma estratégia gulosa para gravar o maior número possível de arquivos no
pendrive.

Modelagem:
Arquivos (tamanho em Kbytes) A: {8, 24, 256, 1024, 16, 32, ...}
Encontrar o maior subconjunto de A em unidades em que a soma dos valores não ultrapasse c;

24/04/2019 84