Exercícios: Alg Gulosos. Eduardo Laber

Transcrição

1 Exercícios: Alg Gulosos Eduardo Laber

2 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

3 Estratégia: Cap 4- Exercício 4 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.

4 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

5 Cap 4- Exercício 4

6 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

7 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

8 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={j 1,...,j k } a solução ótima cujo prefixo comum com S é máximo. Seja j 1,...,j r o prefixo comum entre as duas OPT: i 1 i 2 i r i r+1 i r+1 S: j 1 j 2 j r j r+1 j r+2 j r+3 O que acontece se trocarmos a base i r+1 com a base j r+1?

9 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={j 1,...,j k } a solução ótima cujo prefixo comum com S é máximo. Seja j 1,...,j r o prefixo comum entre as duas OPT*: i 1 i 2 i r j r+1 i r+1 S: j 1 j 2 j r j r+1 j r+2 j r+3 Trocando a base i r+1 com a base j r+1, obtemos uma outra solução ótima OPT* já que j r+1 e i r cobrem todas as casas cobertas por i r+1

10 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={j 1,...,j k } a solução ótima cujo prefixo comum com S é máximo. Seja j 1,...,j r o prefixo comum entre as duas OPT * : i 1 i 2 i r j r+1 i r+1 S: j 1 j 2 j r j r+1 j r+2 j r+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

11 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

12 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).

13 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.

14 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.

15 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

16 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).

17 b) Sim. Cap 4- Exercício 9 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!

18 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

19 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

20 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.

21 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

22 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.

23 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.

24 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.

25 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.

26 Cap 4 - Exercício 13 Escalonar em ordem decrescente de w i / t i. 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

27 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

28 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.

29 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

30 Cap 4 - Exercício 21 Encontre um ciclo na Near tree e remova aresta mais cara (cycle property). Repita este procedimento 9 vezes