Transcript Exercícios: Alg Gulosos - PUC-Rio

Exercícios: Alg Gulosos
Eduardo Laber
Cap 4-Exercício 2
a) Verdadeiro, já que trocando cada
elemento pelo seu quadrado não altera a
ordem das arestas. Portanto, o algoritmo
de Kruskal constrói a mesma árvore.
b) Falso. Considere o seguinte contraexemplo: V={s,a,b,t}, cost(s,a)=9,
cost(a,t)=1, cost(s,b)=6, cost(b,t)=6
Cap 4- Exercício 4
Estratégia:
Encontrar a primeira ocorrência do primeiro
elemento de S’ em S. Seja i(1) o índice desta
ocorrência em S. Depois, encontre a primeira
ocorrência do segundo elemento de S’ em S
que esteja a direita de i, e assim por diante.
Cap 4- Exercício 4
Sejam e’(1),...,e’(m) os eventos de S’. Execute o seguinte
algoritmo
K0
Para i=1...m
Encontre a primeira ocorrência de e’(i) em S que esteja depois
da posição K
Se nenhuma ocorrência for encontrada
Retorne “S’ não é subsequência de S”
Senão
K posição em S aonde e’(i) foi encontrado
Fim Se
Fim Para
Retorne “S’ é subsequência de S”
Cap 4- Exercício 4
Cap 4- Exercício 4
Prova de corretude
• Se o algoritmo encontra a sequência ele funciona
corretamente.
• Considere que o algoritmo não encontra a sequência
mas tal sequência existe.
– Assuma que o algoritmo conseguiu encontrar k <m eventos nas
posição P=i(1)< i(2)< ....< i(k)
– Seja j(1),j(2),...,j(m) as posições da subsequência S’ em S que
tem maior prefixo comum com P. Como k<m, a subsequência
Cap 4- Exercício 5
Execute o seguinte algoritmo:
H conjunto com todas as casas
Enquanto o conjunto H tem alguma casa
Coloque uma base b 4 milhas à direita da casa
mais à esquerda do conjunto H
Remova todas as casas do conjunto H cuja
distância até a base b é de no máximo 4 milhas
Fim Enquanto
Cap 4- Exercício 5
Prova de Corretude.
Assuma por contradição que a solução S do algoritmo não
é ótima. Dentre as soluções ótimas, seja OPT={j1,...,jk} a
solução ótima cujo prefixo comum com S é máximo.
Seja j1,...,jr o prefixo comum entre as duas
OPT:
i1
i2
ir
S:
j1
j2
jr
ir+1
ir+1
jr+1
jr+2
O que acontece se trocarmos a base ir+1 com a base jr+1?
jr+3
Cap 4- Exercício 5
Prova de Corretude.
Assuma por contradição que a solução S do algoritmo não
é ótima. Dentre as soluções ótimas, seja OPT={j1,...,jk} a
solução ótima cujo prefixo comum com S é máximo.
Seja j1,...,jr o prefixo comum entre as duas
OPT*:
i1
i2
ir
jr+1
S:
j1
j2
jr
jr+1
ir+1
jr+2
jr+3
Trocando a base ir+1 com a base jr+1 , obtemos uma outra solução
ótima OPT* já que jr+1 e ir cobrem todas as casas cobertas por ir+1
Cap 4- Exercício 5
Prova de Corretude.
Assuma por contradição que a solução S do algoritmo não
é ótima. Dentre as soluções ótimas, seja OPT={j1,...,jk} a
solução ótima cujo prefixo comum com S é máximo.
Seja j1,...,jr o prefixo comum entre as duas
OPT’* :
i1
i2
ir
jr+1
S:
j1
j2
jr
jr+1
ir+1
jr+2
jr+3
OPT* é ótima e o prefixo comum entre S e OPT*é maior que o
prefixo comum entre S e OPT. Essa contradição surge da hipótese
que S não é ótima. Portanto, S é ótima
Cap 4-Exercício 7
Algoritmo:
• Obtenha um escalonamento S
escalonando os jobs no supercomputador
em ordem decrescente de f (tempo de
processamento no PC) – O que tiver
maior f é escalonado antes
Cap 4-Exercício 7
Prova de corretude
• Assuma que o escalonamento S contém
inversões  existem jobs i e j tal que i é
escalonado imediatamente antes de j e
que f(j)>f(i).
• Seja P o tempo em que i começa a ser
processado no super computador. Logo, i
termina em P+p(i) + f(i) e j termina em
P+p(i)+p(j)+f(j).
Cap 4-Exercício 7
Prova de corretude
• Seja S* o escalonamento obtido ao
inverter i e j. Temos que:
– O tempo de término fica inalterado para todos
os jobs diferentes de i e j.
– Para o job j a situação só pode melhorar.
– O job i passa a terminar em
t’(i)=P+p(j)+p(i)+f(i). Entretanto, temos t’(i)<t(j)
já que f(i)<f(j).Portanto, S* é melhor ou igual a
S.
Cap 4-Exercício 7
Prova de corretude
• Logo, sempre que um escalonamento S
tiver inversões podemos obter um
escalonamento S* tão bom quanto S mas
com menos inversões que S.
• Portanto, existe um escalonamento ótimo
sem inversões, o que implica que o
algoritmo guloso obtém um
escalonamento ótimo.
Cap 4- Exercício 8
• Assuma que existam duas MST’s T e T’.
Seja e uma aresta que está em T mas não
está em T’. Logo, T U e contém um ciclo.
• Como todas as arestas tem custo
diferente, segue da propriedade do ciclo
que a aresta mais cara deste ciclo não
pode estar em uma MST, o que contradiz
o fato de T e T’ serem MST’s
Cap 4- Exercício 9
Exercício 9
a) Não.
• Considere um grafo G formado por um triângulo,
onde um dos vértices está ligado a um caminho.
(arestas tem custos distintos)
• Considere que a aresta de maior custo em G
não pertence ao triângulo.
• Então existe apenas uma MST e toda árvore
geradora é uma miminum bottleneck tree (MBT).
Cap 4- Exercício 9
b) Sim.
• Assuma que uma MST T não é uma MBT.
• Seja T* uma MBT para o grafo e seja f a aresta
de maior custo de T. Temos que f não pertence
a T* já que T não é uma MBT
• Logo, o subgrafo obtido pela união de T* com a
aresta f contém um ciclo.
• A aresta mais cara deste ciclo é f e, portanto,
pela propriedade do ciclo, f não pode pertencer
a T. Contradição!
Cap 4 - Exercício 10
a) Se a aresta uv for inserida, teste se
existe alguma aresta no caminho que liga
u a v em T que é mais cara que uv.
– Se existir, T não é mais uma MST
(propriedade do ciclo).
– Caso não exista, T é uma MST ( Algoritmo de
Kruskal faria as mesmas escolhas).
– DFS, executa em O(|V|) já que o número de
arestas em T é |V|-1
Cap 4 –Exercicio 10
(assumindo custos distintos)
b) Encontrar um ciclo na árvore T+e e
remover a aresta de custo máximo deste
ciclo.
As demais arestas do grafo não
pertencem a MST antes e não passar a
pertencer após adição de e já que elas
são as arestas mais caras de algum ciclo
Cap 4 -Exercício 12
a) Falso J(1)=(1,1000), J(2)=(1000,1),r= 1
Para o segundo job não vale, mas
escalonando J(1) depois J(2) a restrição é
satisfeita.
Cap 4 -Exercício 12
b) Para i=1,...,n, seja r(i)=b(i)/t(i)
• Ordene os streams em ordem crescente de r(i).
• Para i=1,...,n, verifique se a soma dos b’s para
os i primeiros streams dividido pela soma dos t’s
para os i primeiros streams é menor que r.
• Se a condição for sempre satisfeita, um
escalonamento viável foi encontrado. Caso
contrário, não existe escalonamento viável
Cap 4 -Exercício 12
Prova de corretude.
• Dizemos que as streams i e j estão
invertidas em um escalonamento S se i
ocorre antes de j e r(i) > r(j)
• Seja S um escalonamento viável com
inversões  existem streams i e i+1 tal
que r(i) >r(i+1) e i aparece imediatamente
antes de i+1 em S.
Cap 4 -Exercício 12
Prova de corretude.
• Seja T o tempo que i começa em S e B o
número de bits transmitidos antes de i começar.
• Vamos mostrar que invertendo i e i+1 obtemos
um escalonamento S* que é viável e tem menos
inversões que S
– Basta analisar os instantes de tempo em que os
streams i e i+1 estão sendo enviados já que os
demais streams não são afetados pela inversão.
Cap 4 -Exercício 12
Prova de Corretude (cont)
• Seja t um número no intervalo [0, t(i+1)]. No instante T+t:
– O escalonamento S* já transmitiu B+tr(i+1) bits
– O escalonamento S transmitiu B+min{t,t(i))}r(i) + max{0,t-t(i)} 
r(i+1)
– Como r(i)>r(i+1), S* transmitiu menos bits e, portanto, ele é
viável neste instante.
• Seja t um número no intervalo (0, t(i)]. No instante
T+t(i+1)+t:
– O escalonamento S* transmitiu B+ t(i+1)r(i+1)+tr(i) bits
– O escalonamento S transmitiu B+ min{t(i),t(i+1)+t)r(i) +
max{0,t(i+1)+t –t(i) }r(i+1).
– Como r(i)>r(i+1), S* transmitiu menos bits e, portanto, ele é
viável neste instante.
Cap 4 -Exercício 12
Prova de corretude.
• Portanto, o stream S* é viável e tem menos
inversões que S
• Portanto, se existe um escalonamento viável,
então existe um viável com 0 inversões.
Cap 4 - Exercício 13
• Escalonar em ordem decrescente de wi/ ti.
• Considerar solução ótima com número
mínimo de inversões e argumentar que
trocar a ordem de jobs invertidos
consecutivos não piora a solução
Cap 4 - Exercício 15
S Todos estudantes; C vazio
Enquanto S<>vazio
• Seja s o estudante de S, ainda não coberto por
C, cujo shift termina primeiro. Inclua no comitê o
estudante t cujo shift é o último a terminar
dentre todos os estudantes de S cujo shift
começa antes do término do shift de s.
• Remova de S o estudante t e todos os
estudantes cujo shift termina antes do shift de t
• Coloque t em C
Fim Enquanto
Cap 4 - Exercício 15
Prova de Corretude
• Utilizar técnica da soluçào ótima com o maior
prefixo comum com aquela construída pelo
Greedy.
Cap 4 -Exercício 19
Bottleneck tree
• Compute uma árvore geradora T de custo
máximo ( Aplique Kruskal ordenado as arestas
por ordem decresente de peso)
• Se existir um caminho P entre u e v em G tal
que o bottleneck seja maior do que o dado por T
então T U P tem um ciclo em que a aresta de
menor custo pertence a T. Pela propriedade do
ciclo isto contradiz o fato de T ser uma árvore
geradora de custo máximo
Cap 4 - Exercício 21
•
Encontre um ciclo na Near tree e
remova aresta mais cara (cycle property).
Repita este procedimento 9 vezes