Crescimento de Função

George Darmiton da Cunha Cavalcanti

CIn – UFPE
Introdução
Muitas são as classes de problemas da matemática
discreta:
Dada uma seqüência de inteiros, encontrar o maior;
Dado um conjunto, encontrar todos os seus subconjuntos;
Dada uma rede, encontrar o menor caminho entre dois
nós.

O primeiro passo para solucionar esses problemas

é construir um modelo matemático do problema
Algoritmo

É um conjunto finito e preciso de instruções

para resolver um problema.
Exemplo de um algoritmo
Encontrar o maior valor em uma lista de inteiros.

Passos:
1) O primeiro valor será o máximo temporário
2) Compare o próximo item na lista com o máximo
temporário. Torná-lo o máximo temporário caso ele seja
maior que o máximo temporário;
3) Repetir os passos 1-2 enquanto houver itens na lista;
4) O máximo temporário é o maior valor da lista.
Pseudocódigo do exemplo

Finding the maximum element in a finite sequence

procedure max(a1, a2,...,an:integers)
max = a1
for i=2 to n
if max < ai then max = ai
{max is the largest element}
Algoritmo para busca seqüencial

The linear search algorithm

procedure linearSearch(x:integer, a1, a2,...,an:integers)
i=1
while (i ≤ n and x ≠ ai)
i=i+1
if i ≤ n then location = i
else location = 0
{location is the subscript of term that equals x, or is 0 if
x is not found}
Algoritmo para busca binária
The binary search algorithm
procedure binarySearch(x: integer, a1, a2,...,an: increasing integers)
i=1
j=n
while i < j
begin
m = [(i+j)/2]
if x > am then i = m + 1
else j = m
end
if x == ai then location = i
else location = 0
{location is the subscript of term that equals x, or is 0 if x is not found}
 Ordenação (Bubble Sort)
Primeiro passo

3 2 2 2
2 3 3 3
4 4 4 1
1 1 1 4
5 5 5 5

Segundo passo
2 2 2
3 3 1
1 1 3
4 4 4
5 5 5
Ordenação (Bubble Sort)

Terceiro passo Quarto passo

2 1 1
1 2 2
3 3 3
4 4 4
5 5 5
 Bubble Sort Algorithm

procedure bubblersort(a1,...,an)
for i=1 to n-1
for j=1 to n-i
if aj > aj+1 then interchange aj and aj+1
Ordenação (Insertion Sort)

Java Applet Insertion Sort

Ordenação (Insertion Sort)
Ordenação (Insertion Sort)
Ordenação (Insertion Sort)
 Insertion Sort Algorithm
procedure insertionsort(a1,...,an)
for j=2 to n
begin
i=1
while aj > ai
i = i+1
m = aj
for k=0 to j – i – 1
aj-k = aj-k-1
ai = m
end
Greedy algorithms
Greedy algorithms são usados para resolver
problemas de otimização:
Encontrar a menor rota entre duas cidades;
Distribuir carga entre computadores em uma
rede;
Agendamento;
Bin-packing.
Greedy algorithms (exemplo)
Exemplo:
Para se ter $6.39, é possível escolher:
$6, ou seja, 6 × $1, para se ter $6
25¢, para $6.25
10¢, para $6.35
quatro 1¢, para $6.39
Greedy algorithms (exemplo)
Problema: “trocar dinheiro”
Moedas estão disponíveis nos seguintes valores:
dollars (100 centavos)
quarters (25 centavos)
dimes (10 centavos)
nickels (5 centavos)
pennies (1 centavo)

Problema
Trocar um valor utilizando o menor número de moedas
possível.
 Greedy algorithm
“trocar dinheiro”

procedure change(c1,c2,...,cr: values of coins, n: a

positive integer) c1 > c2 > ... >cr
for i=1 to r
while n ≥ ci
begin
add a coin with the value ci to the change
n = n – ci
end
Crescimento de funções
Vários algoritmos podem ser utilizados para resolver
um dado problema

Fatores que devem ser levados em consideração

Tempo de Execução
Espaço de armazenamento

Problemas da área de Análise de Algoritmos

Análise de uma algoritmo em particular
Análise de uma classe de algoritmos
Custo de um Algoritmo
Existem várias maneiras para se medir o custo

Uma delas é medir o tempo de computação de

algoritmos em uma máquina real.

Esse tipo de medida é inadequado pois:

Os resultados dependem do compilador
Os resultados dependem do hardware
Quando grandes quantidades de memória são
utilizadas, as medidas de tempo podem depender
desse aspecto
Custo de um Algoritmo

Uma forma mais adequada de se medir o custo de

um algoritmo é através de um modelo matemático

O conjunto de operações a ser executada deve ser

especificado, bem como o custo de cada operação

Usualmente, ignora-se o custo de algumas

operações. Exemplo
Em algoritmos de ordenação, considera-se o número de
comparações e ignora-se atribuições e manipulação de
índices
Notação Big-O
É uma notação bastante usada para estimar o
número de operações que um algoritmo executa na
medida em que a entrada cresce

Com essa notação é possível verificar a utilidade

prática de um algoritmo na solução de um problema

É possível, também, comparar dois algoritmos e

indicar qual dos dois é mais eficiente
Notação Big-O
Estimar custo de algoritmo em relação ao tempo e
ao espaço.

Definição:
Sejam f e g funções do conjunto dos inteiros (ou conjunto
dos números reais) no conjunto dos números reais. Diz-se
que f(x) é O(g(x)) se existem constantes C e n0 de forma
que:

quando x > n0. Diz-se que f(x) é “O grande de g(x)".

Notação Big-O
A notação “big-Oh” (“O grande”) é utilizada para
expressar formalmente um limite superior para a
função.

Quanto se diz que f(x) é O(x2), se quer dizer que f

nunca cresce mais do que cx2 a partir de um
determinado valor x e para uma constante c.

Usa-se a notação f(x) = O(g(x)) quando f(x) é “O

grande de g(x)”. Isso significa que f(x) é limitada
superiormente por g(x).

Aqui há um abuso de notação, pois na realidade f(x)

∈ O(g(x)), pois O(g(x)) é o conjunto das funções
que g limita superiormente.
Notação Big-O
Em termos de algoritmos, quando se diz que
dentre as soluções algorítmicas para um
determinado problema, a melhor é O(x2) em
função da entrada.

Isso significa que se alguém achar um outro

algoritmo cuja função para estimar o tempo é
O(log n) significa que a cota superior (“upper
bound”) para aquele problema diminuiu.
Exemplo

É possível observar que

x<x2 e 1<x2 quando x>1
Assim
0 ≤ x2+2x+1 ≤ x2+2x2+x2 = 4x2, quando x>1
Conseqüentemente, quando C = 4 e n0 = 1
tem-se que f(x) é O(x2)
Exemplo (continuação)
Uma outra alternativa é estimar os valores de
f(x) quando x > 2
2x ≤ x2 e 1 ≤ x2
Conseqüentemente
0 ≤ x2+2x+1 ≤ x2+x2+x2 = 3x2
Assim, quando C = 3 e n0 = 2
tem-se que f(x) é O(x2)
Exemplo (continuação)

x2+2x+1 é O(x2)
Notação Big-O
|f(x)| ≤ C|g(x)|, se x>n0

E se |h(x)| > |g(x)| para todo x>n0 , então

|f(x)| ≤ C|h(x)|, se x>n0

Assim, f(x) é O(g(x))

Notação Big-O
Notação Big-O
Combinação de Funções
|f1(x)| ≤ C1|g1(x)|, quando x>k1
|f2(x)| ≤ C2|g2(x)|, quando x>k2

Dado que
Assim, |a+b| ≤ |a|+|b|

|(f1+ f2)(x)| = |f1(x)+ f2(x)|

≤ |f1(x)|+ |f2(x)|
Combinação de Funções
Quando x é maior que k1 e k2 tem-se:

|f1(x)|+ |f2(x)| ≤ C1|g1(x)|+ C2|g2(x)|

≤ C1|g(x)|+ C2|g(x)|
= (C1+ C2)|g(x)|
= C|g(x)|

Dado que C=C1+C2 e g(x) = max(|g1(x)|,|g2(x)|)

Se f1(x) e f2(x) são O(g(x)), então (f1+f2)(x) é O(g(x)).

 Combinação de Funções
Quando x é maior que k1 e k2 tem-se:

|f1f2(x)| = |f1(x)| |f2(x)|

≤ C1|g1(x)| C2|g2(x)|
≤ C1C2|(g1g2)(x)|
≤ C|(g1g2)(x)| ,

Dado que C=C1C2 e f1(x)f2(x) é O(g1g2)

Se f1(x) é O(g1(x)) e f2(x) é O(g2(x)), então (f1f2)(x) é O(g1(x)g2(x)).

Notação Big-Omega
A notação Big-O provê um limite superior
para uma função f(x).

Um limite inferior, para valores grandes de x,

é calculado usando a notação Big-Omega.
 Notação Big-Omega
Definição:
Sejam f e g funções do conjunto dos inteiros (ou conjunto
dos números reais) no conjunto dos números reais.
Diz-se que f(x) é Ω(g(x)) se existem constantes C e n0 de
forma que:

quando x > n0. Diz-se que f(x) é “Omega grande de g(x)".

Ω
Existe uma forte conexão entre as notações big-O e big-Ω
f(x) é Ω(g(x)) se e somente se g(x) for O(f(x))
Função de Complexidade (ƒ)
Exemplo
Encontrar o maior elemento em um vetor de inteiros
A[1..n], n ≥ 1

ƒ(n): é o número de comparações entre elementos de A

Logo, ƒ(n) = n-1
Esse algoritmo é ótimo
Função de Complexidade (ƒ)
O exemplo mostrado no slide anterior mostra que o algoritmo é
função linear do tamanho da entrada
Porém, existem algoritmos que dependem da organização dos
dados de entrada. Exemplo: algoritmos de ordenação
Para esses casos três cenários podem ser destacados
Exemplo – Pesquisa Seqüencial

Problema:
Cada registro possui uma chave única.
Dada uma chave qualquer, o programa encontra o registro que
contém essa chave

Solução
O algoritmo mais simples faz uma pesquisa seqüencial
ƒ(n): número de registros consultados no arquivo
Casos a considerar
Melhor caso: ƒ(n) = 1
Pior caso: ƒ(n) = n
Caso Médio: ƒ(n) = (n+1)/2
Exemplo
Encontrar o maior e o menor elemento em um vetor de inteiros A[1...n]

Seja ƒ(n) o número comparações entre elementos de A

ƒ(n) = 2(n−1), para n >0
Para o melhor caso, pior caso e caso médio
Exemplo
Como melhorar a implementação do slide anterior?
Terminologia usada para a
complexidade de algoritmos

Complexidade Terminologia
O(1) Complexidade Constante

O(log n) Complexidade Logarítmica

O(n) Complexidade Linear
O(n log n) Complexidade n log n
O(np) Complexidade Polinomial

O(bn), b > 1 Complexidade Exponencial

O(n!) Complexidade Fatorial