Solved Exercises

1. Finding the Peak. Let A= a1,…,an be a sequence of n numbers with the following
property: there is p in {1,…,n} for which
(i) the subsequence a1,..,ap is increasing and
(ii) the subsequence ap,…,an is decreasing.

Find p in O( log n) time.

Exemplo
A=13568 6432
p=5
 Solved Exercises

2. Subcadeia de Soma Máxima

Entrada
a = (a1, a2, … , aN) um vetor de inteiros
Saída: i e j tais que
S[i , j ]= ai + ai+1 + … + aj é máximo.

quando todos os valores de a são negativos, então a subsequencia vazia é

escolhida e o valor máximo da soma é considerado 0.
Exemplo: a = (-2, 11, -4, 13, -5, -2)
Solução

i=2 e j=4

s[2,4]= 11 - 4 + 13 = 20
 Solução “força bruta”

Existem O(n2) intervalos

Para calcular s[i, j ] gasta-se O(j-i)=O(n)

Complexidade de tempo O(n3)

 Solução “força bruta”

Smax 0
Para i:=1 até n faça
Para j:=i ate n faça
SA[i]
Para k:=i+1 até j faça
S  S+A[k]
if S > Smax then
Smax S
 Preprocessamento ...

Calculando s[1,i], para 1≤ i ≤ n, podemos calcular as demais somas em O(1):

S[ i , j ]= s[ 1, j ] –s[ 1 , i-1 ]

O(n2) intervalos =>

Complexidade de tempo O(n2)

 Preprocessamento ...

Para i:=0 até n

Prefix[i]  0
Para i:=1 até n
Prefix[i+1]  Prefix[i] + A[i]

Smax  0
Para i:=1 até n faça
Para j:=i ate n faça
if Prefix[j] – Prefix[i-1] > Smax then
Smax Prefix[j] – Prefix[i-1]
 ...“dividir-e-conquistar”

Quebrar em dois subvetores menores

resposta resposta resposta

a esquerda no centro a direita

a1 a2

a1 a2
 ...“dividir-e-conquistar”

Quebrar em dois subvetores menores

resposta
no centro

a1 a2
T(esq): subsequencia de soma máxima que começa em algum i*
menor ou igual a n/2 e termina em n/2
T(dir): subsequencia de soma máxima que começa em n/2 e termina
em algum j* maior ou igual a n/2
Melhor resposta no centro igual a s[ i*, j* ]
 …“dividir-e-conquistar”

SubseqMaxima (i,j)
Se i=j and A[i]>0 then return A[i]
Se i=j and A[i]<0 then return 0
Senão
Sleft  SubseqMaxima (i,(i+j) div 2 )
Sright SubseqMaxima ((i+j) div 2 + 1, j )
Lmax 0; aux  0
Para k:= (i+j) div 2 downto i
aux  aux + A[k]
Se aux > Lmax then Lmax  aux
Rmax  0; aux  0
Para k:= (i+j) div 2 +1 to j
aux < - aux + A[k]
Se aux > Rmax then Rmax  aux
Scenter  Lmax+ Rmax
Return max(Sleft , Scenter , Sright )
 …“dividir-e-conquistar”

T(n) = esforço para resolver instancia de tamanho n

T(n) = n + 2.T(n/2)
T(1) = O(1)
T(n) = O(n.lg(n)) + O(n) = O(n.lg(n))

Complexidade de tempo O(n log n)

 …“ É possível melhorar ?”

 Programação Dinâmica

 Tempo Linear
 Exercício 1

Ao comparar a mediana a(n/2) da primeira lista com a mediana b(n/2) da

segunda lista temos

Caso i) a(n/2) >= b(n/2). Neste caso, os elementos a(n/2+1),…,a(n) são

maiores ou iguais que n elementos e os elementos b(1),…,b(n/2) são
menores ou iguais do que n elementos. Portanto, o elemento desejado é o
(n/2)-ésimo elemento do conjunto b(n/2+1),…,b(b), a(1),…,a(n/2). Este
pode ser encontrado recursivamente

Caso ii) a(n/2) < b(n/2). Análogo ao caso i

Complexidade de Tempo
T(2n) = 1 + T(n)
T(1) =1

Resolvendo a recorrência temos T(2n)= log (2n) = O(log n)

 Exercício 2

Devemos aplicar a mesma estratégia do algoritmo para contar inversões com

a seguinte modificação na hora de combinar

 multiplique todos os elementos da lista direita por 2 e faça um merge

entre as duas listas para contar o número de inversões

 Faça o merge com as listas originais (sem multiplicar por 2) para obter
uma lista ordenada
 Exercício 3

Escreva uma função Cartão(S) que dados o conjunto S de cartões :

 Retorna um dos cartões que aparece mais do que |S|/2 vezes caso este
exista
 Null caso contrário
 Exercício 3
Cartão (S)
Se |S|=1
Return o único cartão de S
Senão
Particione S em dois subconjuntos S1 e S2 de mesmo
tamanho
a  Cartão(S1) ; bCartão(S2)
Se a = Null e b = Null
Return Null
Se a <> Null
Compare a com todos os cartões de S
Se a aparece mais do que |S|/2 vezes
Return a
Se b <> Null
Compare b com todos os cartões de S
Se b aparece mais do que |S|/2 vezes
Return b
Return Null
 Exercício 3

Teorema. Cartão(S) devolve Null se nenhum cartão de S aparece mais do

que |S|/2 vezes e o cartão que aparece mais do |S|/2 vezes

Indução em |S|
Base |S|=1. Ok!
Hipótese. Propriedade vale quando |S| < = k.
Passo |S|=k+1.

Reciocínio.
Caso 1.) Existe um cartão em S, digamos c, que aparece mais do que (k+1)/2
vezes. Logo, este cartão aparecerá mais do que |S1|/2 vezes em S1 ou
mais de |S2|/2 vezes em S2. Como Cartão(S1) e Cartão(S2) estão
corretos então um destes retornará c. Logo, Cartão(S) retornará c.

Caso 2) Não existe cartão em S que aparece mais do que (k+1)/2 vezes. O
procedimento retorna Null.
 Exercício 3

Complexidade de Tempo

T(n) = 2n + 2T(n/2) ( comparar cartões mais duas chamadas recursivas)

T(1)=1

 T(n) = O(n log n)

Exercício 4
 Exercício 5

Escreva um Rotina HSR que recebe como entrada n retas e retorna uma
partição do intervalo (-\infty,+\infty) aonde a cada intervalo é associado
a reta visível naquele intervalo. Note que cada reta esta associada a no
máximo um intervalo

Divisão. Divida as retas em dois conjuntos de n/2 retas e resolva

recursivamente cada um dos subproblemas.

Conquista. Faça um “merge dos intervalos” obtidas

Complexidade de Tempo

T(n)=n + 2T(n/2) ( merge + duas chamadas recursivas)

T(1)=1
 T(n) =O(log n)
 Exercício 6

LocalMinimo existe ?

Óbvio. O menor elemento da árvore é um local mínimo

 Exercício 6

LocalMinimo(r)
Se r é um folha (i)
Return r
Se r< r.esq e r<r.dir (ii)
Return r
Se r.esq<r
Return LocalMinimo(r.esq) (iii)
Se r.dir<r
Return LocalMinimo(r.dir) (iv)

Complexidade de Tempo

T(n) <= c + T(n/2) se n>1 ( comparações + chamada recursiva)

T(n) =1 se n=1 ( caso base)
 T(n) = O(log n)
 Exercício 6

Teorema. LocalMinimo (r) retorna um mínimo local da árvore enraízada em r

Prova
Indução no tamanho da árvore.
Base. r é uma folha (i). Ok.
Hipótese. Vale para árvores com 2d -1 nós
Passo. Provar para árvore T com 2d+1 -1 nós

Caso 1) A raíz é um mínimo local de T. O algoritmo devolve r (ii)

Caso 2) A raíz não é um mínimo local de T

Subcaso 2.1) r.esq < r. Então um mínimo local da árvore enraízada em r.esq
é um mínimo local de T. Como neste caso LocalMinimo(r.esq) é chamado,
segue da hip de indução que o algoritmo devolve a resposta correta

Subcaso 2.2) r.esq > r. Então r.dir < r eum mínimo local da árvore enraízada
em r.dir é um mínimo local de T. Como neste caso LocalMinimo(r.dir) é
chamado, segue da hip de indução que o algoritmo devolve a resposta correta