Departamento de Cincias e Tecnologias da Informao

Filipe Santos

ALGORITMOS E COMPLEXIDADE
COMPLEXIDADE DE ALGORITMOS E
PROBLEMAS

Algoritmos e Complexidade

Departamento de Cincias e Tecnologias da Informao

Filipe Santos

Plano
Eficincia de algoritmos. Eficincia no melhor caso, pior caso
e em mdia. Ordem de complexidade. Melhoramentos de
pequena e grande magnitude na eficincia de algoritmos.
Exemplos de diferentes algoritmos com diferentes eficincias
para o mesmo problema. Complexidade de um problema.
Problemas fechados e abertos.
Algoritmos: Insert sort; Pesquisa Linear; Pesquisa Binria;
Bubblesort; Barricada dos tigres adormecidos.

Algoritmos e Complexidade

Filipe Santos

Departamento de Cincias e Tecnologias da Informao

Eficincia de algoritmos
Que recursos computacionais so necessrios para executar um algoritmo?
C tempo de execuo
C espao de memria

Complexidade Temporal
Complexidade Espacial

Cespao e tempo dependem da dimenso dos dados. Podemos portanto

representar a eficincia por funes!
e
s
p
a

S(n)

n - dimenso dos dados

S(n)
T(n)

memria utilizada pelo algoritmo em funo do tamanho n do input

tempo de execuo do algoritmo em funo do tamanho n do input

Algoritmos e Complexidade

Departamento de Cincias e Tecnologias da Informao

Filipe Santos

Eficincia de algoritmos
L Na prtica muito difcil calcular com rigor o tempo de execuo de um
algoritmo!
Identificar no algoritmo as operaes elementares e determinar o nmero de
vezes que so executadas. O tempo real de execuo de cada operao
elementar ser uma constante multiplicativa!
A Independentemente do computador!
$ Dados vrios algoritmos para solucionar um mesmo problema, devemos
escolher aquele que nos permite resolver o problema mais rapidamente e
utilizando o menor espao possvel para representar os dados do problema!
Mas

Algoritmos e Complexidade

Departamento de Cincias e Tecnologias da Informao

Filipe Santos

Eficincia de algoritmos
t
e
m
p
o

e
s
p
a

T1(n)

S1(n)

S2(n)

T2(n)
k
n - dimenso dos dados

m
n - dimenso dos dados

C um algoritmo pode ser mais eficiente que outro para inputs de pequena
dimenso e deixar de o ser para inputs de grande dimenso. E.g. insertsort vs
treesort
C um algoritmo pode ser mais eficiente que outro em tempo e no o ser em
espao. E.g. bublesort vs treesort
C Mais ainda, diferentes amostras com a mesma dimenso podem ser
processadas em tempos diferentes, podendo-se falar de eficincia temporal
mnima (melhor caso), mxima (pior caso) e mdia.
Algoritmos e Complexidade

Departamento de Cincias e Tecnologias da Informao

Filipe Santos

Eficincia no melhor caso, pior caso e em mdia

Exemplo: Dado um array de nN empregados, ordenar os empregados por nome.
Empregado[] insertsort(Empregado[] empregados, int n){
for(int i = 2; i < n+1; i = i +1){
int pos = i; empregados[0] = empregados[i];
while( empregados[pos-1].nome >x.nome){
empregados[pos] = empregados[pos-1];
pos = pos-1
}
empregados[pos] = empregados[0];
} return empregados;
}
Tmin(n) = i=2..n 3 = 3(n 1)
(ocorre quando o array a ordenar j est ordenada)
Tmax(n) = i=2..n (2i+1) = n2 + 2n 3
(ocorre quando o array a ordenar est pela ordem inversa)
Tmed(n) = i=2..n (2i+1) = (n2 + 5n 6)/2, para amostras equiprovveis.
Algoritmos e Complexidade

Filipe Santos

Departamento de Cincias e Tecnologias da Informao

Ordem de Complexidade
C Normalmente a anlise de algoritmos simplificada se nos concentrarmos na sua
eficincia assimpttica, i.e. anlise da taxa de crescimento do pior caso.
Notao O: Sejam f: N R e g: N
R funes.
f(n) = O(g(n))
sse
cR+ n0N : |f(n)| c|g(n)|, n n0
Exemplos:
(n+1)/2
2n3+2n -7
(n2+5)(n-3)
ln n
25

= O(n)
= O(n3)
= O(n3)
= O(log2 n)
= O(n0) = O(1)

Algoritmos e Complexidade

c g(n)
f(n)

n
n0

f(n) = O(g(n))

Departamento de Cincias e Tecnologias da Informao

Filipe Santos

Classes de Complexidade Algortmica

Classes de Complexidade Algortmica

2n

O(1)
O(log n)
O(n)
O(n log n)
O(n2)
O(n3)
O(nk)
O(an)
O(n!)

Complexidade Constante
Complexidade Logartmica
Complexidade Linear
Complexidade Log-Linear
Complexidade Quadrtica
Complexidade Cbica
Complexidade Polinomial
Complexidade Exponencial
Complexidade Factorial
n2

n
log n

Algoritmos e Complexidade

Filipe Santos

Departamento de Cincias e Tecnologias da Informao

Classes de Complexidade Algortmica

log2 n
n
n log2 n
n2
n3
2n
n!
nn

Com 210

10
3
10
30
100
1000
1000
106
1010

103 M

50
5
50
282
2500
125000
1016
1065
1085

100
6
100
664
104
106
1030
10160
10200

1000
9
1000
9965
106
109
10300
M
M

104
13
104
105
108
1012
103000
M
M

105
16
105
106
1010
1015
1030000
M
M

106
19
106
107
1012
1018
10300000
M
M

nmero grande inimaginvel

1 dia 24 X 60 X 60 = 86400 9 X 1010 microsegundos

1 ano = 365 X 24 X 60 X 60 3 X 107 segundos 3 X 1013 microsegundos
1 sculo 3 X 109 segundos 3 X 1015 microsegundos
1 milnio 3 X 1010 segundos 3 X 1016 microsegundos
Big Bang 15 X 109 anos 45 X 1016 segundos 45 X 1022 microsegundos
CAlgoritmos de complexidade constante e logaritmica so os mais eficientes
C Algoritmos de complexidade exponencial geram tempos de execuo incomportveis
Algoritmos e Complexidade

Departamento de Cincias e Tecnologias da Informao

Filipe Santos

Melhoramentos de pequena e grande magnitude

C Pequenos melhoramentos no mudam a classe de complexidade!
boolean pesquisalinear(Empregado[] empregados, int n, String nome){
int i = 0; boolean sim = false;
while(i < n){
if( empregados[i].nome == nome) sim = true; i = i +1;
} return sim;
}
C O(n)
boolean pesquisalinear(Empregado[] empregados, int n, String nome){
int i = 0; boolean sim = false;
while(!sim && i < n){
if( empregados[i].nome == nome) sim = true; i = i +1;
} return sim;
}
C O(n)
Algoritmos e Complexidade

10

Departamento de Cincias e Tecnologias da Informao

Filipe Santos

Melhoramentos de pequena e grande magnitude

boolean pesquisalinear(Empregado[] empregados, int n, String nome){
int i = 0;
empregados[n] = new Empregado(nome, 0.0);
while(empregados[i].nome == nome) i = i +1;
return i != n;
}
C O(n)

C Mudar a classe de complexidade exige uma reformulao mais profunda do algoritmo!

Algoritmos e Complexidade

11

Departamento de Cincias e Tecnologias da Informao

Filipe Santos

Melhoramentos de pequena e grande magnitude

Problema: Dado um array de nN empregados ordenados por nome e um nome (input), saber se
existe um empregado com esse nome (output)
boolean pesquisabinria(Empregado[] empregados, int n, String nome){
return pesquisa(empregados, 0, n-1, nome);
}
boolean pesquisa (Empregado[] empregados, int a, int b, String nome){
int meio = (a+b)/2;
if( empregados[meio].nome == nome) return true;
else{
if( nome < empregados[meio].nome){
if(a<meio) return pesquisa(empregados, a, meio-1, nome);
else return false;
}
else{ if (meio<b) return pesquisa(empregados, meio+1, b, nome);
else return false;
}
}
}
Algoritmos e Complexidade

12

Filipe Santos

Departamento de Cincias e Tecnologias da Informao

Melhoramentos de pequena e grande magnitude

anlise de complexidade:
Considere-se um array com n = 24-1 = 15 elementos e a seguinte rvore. Cada n da rvore
representa uma operao de comparao. Cada ramo a partir do n raiz at outro n da rvore
representa uma execuo possvel do algoritmo.

10

11

12

13

14

15

Melhor caso: 1 operao (no passa do 1 nvel da rvore)

Pior caso: 4 comparaes (tantas comparaes quantos os nveis da rvore)
C Uma rvore binria completa com k nveis tem n=2k-1 elementos! k
C O(log n)
Algoritmos e Complexidade

log2n

13

Departamento de Cincias e Tecnologias da Informao

Filipe Santos

Eficincia de algoritmos recursivos

Problema Torres de Hannoi
void Hanoi(int n, char posteInicial, char posteFinal, char posteAuxiliar){
if(n == 1) System.out.println(posteInicial +
+ posteFinal);
else{
Hanoi(n-1, posteInicial, posteAuxiliar, posteFinal);
System.out.println(posteInicial + + posteFinal);
Hanoi(n-1, posteAuxiliar, posteFinal, posteInicial);
}
}
Neste caso fcil obter a seguinte frmula recorrente:
1

, n=1

T(n) =
2T(n-1) +1, n>1
Que explicitando d: T(n) = 2n-1 , n 1
C O(2n)
Algoritmos e Complexidade

14

Departamento de Cincias e Tecnologias da Informao

Filipe Santos

Complexidade de um problema
C A complexidade de um problema a complexidade do melhor algoritmo que o resolve.
C O melhor algoritmo que resolve um problema pode no ser conhecido.
Problema Pesquisa em listas ordenadas: Dado um array de nN empregados ordenados por
nome e um nome (input), saber se existe um empregado com esse nome (output)
pesquisa linear O(n)
pesquisa binria O(log n)
ser que podemos fazer melhor?
Limites superior e inferior de um problema
C A complexidade de um problema pode no ser conhecida, mas pode ser delimitada
superiormente e inferiormente
C O limite superior indica que no necessrio gastar mais para resolver o problema
C O limite inferior indica que no se pode gastar menos para resolver o problema
Algoritmos e Complexidade

15

Departamento de Cincias e Tecnologias da Informao

Filipe Santos

Complexidade de um problema
C O limite superior estabelecido pelo melhor
algoritmo, entre os algoritmos conhecidos. A
descoberta de um novo algoritmo mais eficiente
faz descer o limite superior.

C O limite inferior estabelecido por tcnicas

de prova que comprovem que no existem
algoritmos mais eficientes. Qualquer algoritmo,
conhecido ou desconhecido, dever ser mais
complexo do que esse limite.

Algoritmos e Complexidade

16

Departamento de Cincias e Tecnologias da Informao

Filipe Santos

Complexidade de um problema
Exemplo de prova de que algoritmos de pesquisa em listas tm limite inferior log n

C O pior caso est associado aos caminhos mais longos na rvore a partir da raiz
C Os algoritmos melhores so portanto aqueles que so representados por rvores de
profundidade menor.
C rvores com n folhas com menos nveis so as rvores binrias completas, que tm log2n
nveis.
C limite inferior O(log n)
Algoritmos e Complexidade

17

Departamento de Cincias e Tecnologias da Informao

Filipe Santos

Problemas fechados e abertos

C Um problema diz-se fechado quando o seu limite superior e inferior coincidem.
C Um problema diz-se aberto quando o seu limite superior e inferior no coincidem.
Nesse caso:
1. existe um algoritmo melhor para o problema e ainda no o descobrimos; ou
2. no conseguimos provar que no existem algoritmos melhor; ou
3. 1 e 2.
Exemplos de problemas fechados
pesquisa em listas ordenadas
pesquisa em listas no ordenadas
ordenao
torres de Hanoi

O(log n)
O(n)
(soma salrios, )
O(n log n) (barricada dos tigres)
O(2n)

Exemplos de problemas abertos

rodovia mais barata

Algoritmos e Complexidade

limite superior

O(n log n)limite inferior O(n)

18

Departamento de Cincias e Tecnologias da Informao

Filipe Santos

Um exemplo adicional para terminar

Problema barricada dos tigres/ convex hull: Dados nN tigres posicionados num campo
(input), qual o menor polgono que os cerca (output)

$ Um segmento faz parte da cerca sse todos os restantes pontos esto no mesmo lado desse
segmento.
Algoritmo1: Testar para cada um dos n2 segmentos se os restantes n-2 pontos esto do mesmo
lado.
C O(n3)
Algoritmos e Complexidade

19

Departamento de Cincias e Tecnologias da Informao

Filipe Santos

Um exemplo adicional para terminar

Algoritmo2:
C O(n)
Procurar o ponto mais baixo;
C O(n log n)
Ordenar os restantes pontos por ordem crescente de ngulos;
C O(1)
Considerar que o segmento P1 P2 faz parte da cerca;
C O(n) *
Para cada um dos restantes pontos PI
4.1 Adicionar PI cerca
4.2 Verificar todos os pontos PJ anteriores da cerca (por ordem inversa) e elimin-los caso
P1 e PI estejam em lados diferentes do segmento com os pontos PJ e PJ-1. Parar este processo
quando um PJ no for eliminado.
1.
2.
3.
4.

* $ medida que so eliminados no voltam a ser comparados

C O(n log n)

Algoritmos e Complexidade

20

Filipe Santos

Departamento de Cincias e Tecnologias da Informao

Um exemplo adicional para terminar

P6

P5

P3

P7

P4

P2
P1
P6

P5

P3

P6

P7

P4

P7

P4

P2

P2
P1

Algoritmos e Complexidade

P5

P3

P1
21

Filipe Santos

Departamento de Cincias e Tecnologias da Informao

Um exemplo adicional para terminar

P6

P6

P5

P3

P7

P5

P3

P4

P7

P4

P2

P2
P1

P1
P6

P5

P3

P7

P4

P2
P1
Algoritmos e Complexidade

22