Universidade de Braslia - UnB

Departamento de Cincia da Computao CIC/Instituto de Cincias Exatas - IE

Disciplina: Projeto e Complexidade de Algoritmos
Semestre: 01/2015

Lista 1
Carlos R. Machado Oliveira
Matrcula: 15/0055170
Questo 1.
a) Escreva um algoritmo para encontrar a mediana de trs nmeros distintos, a, b e c;
b) Descreva D, o conjunto de entradas para o seu algoritmo, com o mesmo sentido
discutido em sala de aula (que corresponde ao item 1.3 do livro da Sara Baase);
c) Quantas comparaes seu algoritmo faz no pior caso? E no caso mdio?
d) De forma genrica (independentemente de um particular algoritmo), quantas
comparaes so necessrias no pior caso para encontrar a mediana de trs nmeros?
Justifique sua resposta.
Resposta: 1. a)
Algoritmo 1 a) Mediana de 3 nmeros inteiros
Entrada (D): a,b,c, : numeros inteiros
Saida (O): mediana: numero inteiro que corresponde a um elemento do conjunto de
entrada D
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

// i n i c i a l i z a c a o
mediana := a ;
// l o o p p r i n c i p a l
i f a >=b :
if c < a:
i f c >= b :
mediana := c ;
else :
mediana := b ;
else :
if c < b:
if c > a:
mediana := c ;
else :
mediana := b ;
return mediana ;

Resposta: 1. b)
Conforme pode ser visto no prembulo do Algoritmo 1 a), acima:
Entrada (D): a,b,c, : numeros inteiros

Ou, um pouco mais formalmente, D = { a,b,c | a,b,c R }

Podendo-se dizer que, se D um conjunto com trs elementos inteiros, o algoritmo
termina com valor de "mediana"igual ao valor da mediana entre os trs elementos de D.
Resposta: 1. c)
Como a entrada muito pequena, possvel perceber que o algoritmo far, no pior caso,
3 operaes de comparao e, no melhor caso, 2 operaes de comparao.
Considerando uma Hiptese de simplificao em que assumimos que os trs neumeros
so distintos, nota-se ainda que o melhor caso ocorre quando os valores de a,b,c so
fornecidos como entrada j na ordem crescente ou quando o menor dos trs nmeros
fornecido na posio do meio (nmero b). Por outro lado, o pior caso ocorre quando os
valores de a,b,c so fornecidos como entrada na ordem decrescente ou quando o maior
dos trs nmeros fornecido na posio do meio (nmero b).
Para o caso mdio de calculo de mediana de 3 nmeros, considerando a quantidade de
permutaes possveis:
Pn = n.(n 1).(n 2)...2.1 = n!
P3 = 3! = 6
A partir da anlise acima do melhor e pior caso, deduz-se que em metade dos casos
teremos uma configurao de valores de a,b,c de melhor caso e na outra metade uma
configurao de pior caso.
Assim, o nmero de comparaes do caso mdio A(n) :
A(n) = p(Cm ).t(Cm ) + p(Cp ).t(Cp )
Onde:
A(n) = Quantidade de comparaes no caso mdio;
p(Cm ) = probabilidade de a,b,c ser fornecido numa configurao de melhor caso;
t(Cm ) = tempo (ou quantidade de comparaes) quando a,b,c so fornecidos numa
configurao de melhor caso;
p(Cp ) = probabilidade de a,b,c ser fornecido numa configurao de pior caso;
t(Cp ) = tempo (ou quantidade de comparaes) quando a,b,c so fornecidos numa
configurao de pior caso;
Logo:
A(n) = p(Cm ).t(Cm ) + p(Cp ).t(Cp )
1
1
A(n) = .2 + .3
2
2
5
A(n) =
2
A(n) = 2.5 comparaes
2

Resposta: 1. d)
3 comparaes.
De forma genrica, determinar a mediana de um conjunto de nmeros depende da
paridade de nmeros (caso seja um conjunto com neumero par de elementos, a mediana
ser um elemento do conjunto que o partiona em duas metades de mesma cardinalidade;
caso seja um conjunto com neumero mpar de elementos, a mediana ser a mdia dos
dois nmeros que fazem a mesma partio) e dos valores deles. Para trs elementos, a
mediana sempre ser um deles, aquele que no for o de valor mximo nem o de valor
mnimo no conjunto.
Conhecer os valores do conjunto (lista) de elementos e t-los ordenados til para
calcular a mediana e, conforme visto na Resposta 1. c) acima, no caso de um conjunto
de cardinalidade 3, sem repeties, o pior caso fazer 3 comparaes.
Questo 2.
a) Elabore um algoritmo para o menor e o maior elementos, numa lista contendo n
entradas;
b) Quantas comparaes das entradas da lista so feitas pelo seu algoritmo no pior caso?
Resposta: 2. a)
Algoritmo 2 a) Identificar Maximo e Minimo numa lista
Entrada (D): L: lista de n nmeros, n >= 1
Saida (O): (menor, maior): tupla com os indices que apontam as posies do menor e
do maior elemeno da lista de entrada
1
2
3
4
5
6
7
8
9
10
11
12

// i n i c i a l i z a c a o
menor := 1 ;
maior := 1 ;
a t u a l := 1 ;
// l o o p p r i n c i p a l
while a t u a l <=n do :
i f L [ a t u a l ] > maior :
maior := a t u a l ;
e l s e i f L [ a t u a l ] < menor :
menor := a t u a l ;
a t u a l ++;
return ( menor , maior ) ;

Resposta: 2. b)
2n comparaes. O algoritmo percorre toda a lista e, para cada um dos n elementos
dela, compara se o valor do elemento atual maior que o valor da varivel maior e, caso
no seja, compara se o valor do elemento atual menor que o valor da varivel menor.
Assim, o pior caso seria quando em nenhuma das posies se encontra um elemento com
valor maior que a varivel maior definida na inicializao (linha 3) e, como
consequncia, todos os elementos da lista tem seu valor comparado tabm com a
varivel menor. Logo, no pior caso seriam feitas duas comparaes para cada elemento
3

da lista, totalizando 2*n comparaes. Por simplificao, pode-se dizer que a quantidade
de comparaes da ordem de n.
Questo 3.
Suponha que voce tenha 50 moedas de ouro, supostamente com o mesmo peso, mas
voc sabe que uma das moedas falsa. Voc tem uma balana com dois braos, e voc
pode colocar qualquer nmero de moedas em cada um dos braos em um determinado
momento. Cada uma dessas medidas pode ser usada para indicar se ambos os braos
sustentam o mesmo peso, ou se um dos braos tem um peso relativamente menor
quando comparado ao outro.
a) Escreva o algoritmo para encontrar a moeda falsa.
b) Quantas medidas so feitas no pior caso?
Respostas:
3. a)
Assumindo que:
i) o peso da moeda falsa seja menor que o peso das demais moedas;
ii) podemos numerar as moedas, atribuindo um numero de indice a elas;
iii) o indice varia de 1..n (n = 50);
iv) a complexidade do procedimento readPeso(lista) ser desconsiderada 1 .
v) no ser usada recurso
Algoritmo 3 a) Identificar Moeda falsa
Entrada (D): L: lista de n moedas, n >= 2 (n = 50)
Saida (O): index: indice que aponta a moeda falsa (index = 0, se todas as moedas
tiverem o mesmo peso)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// i n i c i a l i z a c a o
i n d e x := 0 ;
f i r s t := 1 ;
l a s t := n ;
meio := p i s o ( ( f i r s t + l a s t ) / 2 ) ;
// l o o p p r i n c i p a l
while l a s t f i r s t >= 1 do :
i f ( l a s t f i r s t +1) mod 2 ==0:
// q t d e PAR de moedas
p e s o _ l e f t := readPeso ( L [ f i r s t : meio ] ) ;
p e s o _ r i g h t := readPeso ( L [ meio +1: l a s t ] ) ;
if
peso_left < peso_right :
l a s t := meio ;
i n d e x := f i r s t ;
else i f peso_left > peso_right :
f i r s t := meio + 1 ;
i n d e x := l a s t ;

p. ex.: leitura direta do hardware da balana

20
i f p e s o _ l e f t == p e s o _ r i g h t :
21
index :=0;
22
return i n d e x ; // s a i do l o o p e r e t o r n a r e s p o s t a
23
// r e t o r n a 0 ( z e r o ) c a s o t o d a s as moedas tenham mesmo p e s o
24
25
else :
26
// q t d e IMPAR de moedas
27
p e s o _ l e f t := readPeso ( L [ f i r s t : meio 1] ) ;
28
p e s o _ r i g h t := readPeso ( L [ meio +1: l a s t ] ) ;
29
30
i f p e s o _ l e f t == p e s o _ r i g h t :
31
i n d e x := meio ;
32
return i n d e x ; // s a i do l o o p e r e t o r n a r e s p o s t a
33
else i f peso_left < peso_right :
34
l a s t := meio 1;
35
i n d e x := f i r s t ;
36
else :
37
f i r s t := meio +1;
38
i n d e x := l a s t ;
39
40
meio := p i s o ( ( f i r s t + l a s t ) / 2 ) ;
41
// c a l c u l o do meio s e mantem
42
// para q t d e de moedas par | | impar
43 return i n d e x ;

3. b)
No pior caso, so feitas 5 medidas.
Analisando o Algoritmo 3. a), acima, e assumindo que:
i) o indice retornado sera o meio em alguma das iteraes; ou ii) caso (i) no se
confirme, o indice ser um dos extremos (first || last) da lista final, na comparao de
peso das ltimas duas moedas;
iii) a cardinalidade de moedas a terem seus pesos comparados cai pela metade a cada
iterao.
n
Assim, a cada iterao, o problema que inicialmente tem n moedas2 passa a ter
2
n
n n n
moedas (ou 1 moedas) e, sucessivamente, , ,
...
2
4 8 16
Logo, podemos afirmar, de acordo com a bibliografia de referncia e demonstrao em
sala, que no pior caso(w(n)) a quantidade de medidas log2 (n)
w(n) = log2 (n)
w(50) = log2 (50)
w(50) = 5.644 medidas.
Por simplicidade, podemos dizer que o nmero de medidas da ordem de log(n)

n = 50, no caso presente