exercícios parcialmente resolvidos

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 contra-

exemplo: 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

K0

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

j1 j2 jr

i1 i2 ir ir+1 OPT:

S: jr+1

O que acontece se trocarmos a base ir+1 com a base jr+1?

ir+1

jr+2 jr+3

Cap 4- Exercício 5

Prova de Corretude.





j1 j2 jr

i1 i2 ir OPT*:

S: jr+1

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

ir+1

jr+2 jr+3

jr+1

Cap 4- Exercício 5

Prova de Corretude.





j1 j2 jr

i1 i2 ir OPT’* :

S: jr+1

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

ir+1

jr+2 jr+3

jr+1

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.


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


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.


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.


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.


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.


• 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


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


Prova de Corretude

• Utilizar técnica da soluçào ótima com o maior

prefixo comum com aquela construída pelo

Greedy.


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


• Encontre um ciclo na Near tree e

remova aresta mais cara (cycle property).

Repita este procedimento 9 vezes

exercícios parcialmente resolvidos

Documents