CURSO DE CINCIA DA COMPUTAO

CURSO DE CINCIA DA COMPUTAO

NDICE
1

PROBLEMAS COMPUTACIONAIS E ALGORITMOS ............................................................................. 1

FUNO DE COMPLEXIDADE - ANLISE DA COMPLEXIDADE DE ALGORITMOS......................... 3

CRESCIMENTO DE FUNES - NOTAES ASSINTTICAS............................................................. 6

PROJETANDO ALGORITMOS - DIVISO E CONQUISTA..................................................................... 7

RECURSO - ANLISE DE RECORRNCIAS........................................................................................ 9

5.1 MTODO DE SUBSTITUIO..................................................................................................................... 9
5.2 MTODO DE ITERAO ........................................................................................................................... 9
5.3 MTODO MESTRE ................................................................................................................................. 11

ALGORITMO HEAPSORT ...................................................................................................................... 12

ALGORITMO QUICKSORT..................................................................................................................... 18

PROJETANDO ALGORITMOS PROGRAMAO DINMICA .......................................................... 21

8.1 MULTIPLICAO DE MATRIZES ............................................................................................................... 21

PROJETANDO ALGORITMOS MTODO GULOSO .......................................................................... 25

10

PROBLEMAS TRATVEIS E PROBLEMAS INTRATVEIS ................................................................ 26

11

INTRODUO S CLASSES DE COMPLEXIDADE ALGORTMICA .................................................. 27

BIBLIOGRAFIA:
Introduction to Algorithms
Thomas H. Cormen, Charles E. Leiserson e Ronald L. Rivest - MIT Press, McGraw-Hill (1990)
Complexidade de Algoritmos
Laira Vieira Toscani e Paulo A. S. Veloso Editora Sagra Luzzatto (2001)
The Algorithm Design Manual
Steven S. Skiena - Springer Verlag (1997)
Computer Algorithms: Introduction to Design and Analysis
Sara Baase, Allen Van Gelder - Addison-Wesley Pub Co. - 3rd edition (2000)
Problems on algorithms
Ian Parberry - Prentice-Hall (1995)
Design and analysis of computer algorithms
A. V. Aho, J. E. Hopcroft e J. D. Ullman - Addison-Wesley (1976)

!
CENTRO UNIVERSITRIO

" ! #

SO CAMILO

&'

' (

$#

%! )

CURSO DE CINCIA DA COMPUTAO

PROBLEMAS COMPUTACIONAIS E ALGORITMOS

Algoritmo: Regras usadas para definir ou executar uma tarefa especfica ou para resolver um problema.
Sistema particular de disposio que se d a uma sucesso de procedimentos computacionais.

Algoritmos existem desde a remota Antigidade. A execuo de uma soma armada de 2 nmeros com
vrios algarismos segue um algoritmo. O famoso algoritmo de Euclides para clculo de mximo divisor
o

comum, se o autor assumido foi seu inventor, data do 3 sculo a.C. O algoritmo pode ser usado como uma
ferramenta genrica para representar a soluo de tarefas, independente do desejo de automatiz-las.
Geralmente, entretanto, algoritmos esto associados ao processamento eletrnico de dados, onde sua
elaborao representa uma fase importante do projeto e anlise. No caso da elaborao de um programa, a
maneira correta de faz-lo consiste em inicialmente procurar os mtodos mais adequados soluo do
problema em questo, especificar essa soluo na forma de um algoritmo e somente aps isso elaborar o
cdigo de execuo em alguma linguagem de programao. O algoritmo pode ter vrios nveis de
abstraes de acordo com a necessidade de representar ou encapsular detalhes inerentes s linguagens de
programao. Por exemplo, um algoritmo feito com o objetivo de servir como modelo para uma linguagem
de III gerao pode ser diferente daquele para uma linguagem de IV gerao. Mas isso no impede que a
ferramenta em si possa ser usada em ambos os casos. Existem conceitos avanados como corretude, e
complexidade de algoritmos, a noo de algoritmo timo e a intratabilidade de certos problemas, que
auxiliam na sua elaborao e anlise.
Excertos de:
Algoritmos e sua anlise uma introduo didtica
Valdemar W. Setzer e Fbio H. Carvalheiro
e
Apostila de Algoritmo Estruturado
Professor Jos Maria Rodrigues Santos Jnior

Exemplo: Abaixo apresentado um algoritmo no-computacional cujo objetivo usar um telefone pblico:
Incio

SEQUNCIA

Tirar o fone do gancho;

Ouvir o sinal de linha;
Introduzir o carto;
Teclar o nmero desejado;
Se der o sinal de chamar
Conversar;
Desligar;
Retirar o carto;
Seno
Repetir;
Fim.

DESVIO

Fonte:
Apostila de Lgica de Programao
Professor Renato da Costa

!
CENTRO UNIVERSITRIO

" ! #

SO CAMILO

&'

' (

$#

%! )

CURSO DE CINCIA DA COMPUTAO

EXEMPLOS:
Algoritmo para diviso manual:

a
a mod b

|_b_
a div b

onde: (a mod b) = a b.(a div b)

Algoritmo de Euclides (para clculo do mximo divisor comum):

Mximo divisor comum entre dois inteiros a e b , sendo a > b (notao de clculo manual):
1 diviso:

|_b_

|_a mod b

a div b

a mod b

|_b mod (a mod b)

b div (a mod b)

...

...

...

...

...

2 diviso:
3 diviso:

n diviso:

...

...

O mdc de a e b o ltimo divisor (ou seja, o ltimo resto no-nulo).

Exemplo numrico:

68
0

85
|_17
4

493
|_68
1

2550
|_85
5

|_493_
5

Algoritmo de Euclides em um programa recursivo:

funo Euclides(a, b)
se b = 0
ento retorne a
seno retorne Euclides (b, a mod b)
Exemplo numrico:

Euclides(30, 21) = Euclides(21, 9) = Euclides(9, 3) = Euclides(3, 0) = 3

(3 recurses)

!
CENTRO UNIVERSITRIO

" ! #

SO CAMILO

&'

' (

$#

%! )

CURSO DE CINCIA DA COMPUTAO

FUNO DE COMPLEXIDADE - anlise da complexidade de algoritmos

Analisar um algoritmo significa prever os recursos que esse algoritmo requer. Ocasionalmente, recursos
tais como memrias, largura de banda de comunicao, ou portas lgicas so de interesse principal, mas
freqentemente o tempo de execuo que se quer calcular. Geralmente, analisando vrios algoritmos
candidatos para um problema, o mais eficiente pode ser facilmente identificado.
Para a maioria do nosso curso, iremos assumir o modelo de mquina com um processador e
computao de acesso randmico (RAM).
A anlise de um algoritmo envolve ferramentas matemticas tais como anlise combinatria, teoria de
probabilidades, destreza algbrica, e habilidade para identificar os termos mais significativos em uma
frmula (uma reviso dessa matemtica pode ser encontrada em Introduction to Algorithms - Thomas
H. Cormen, Charles E. Leiserson e Ronald L. Rivest - MIT Press, McGraw-Hill Book Company (1990)
captulo 1 Mathematical Foundations).
"Corretude" de um algoritmo
A prova da corretude de um algoritmo consiste em mostrar que ele executa corretamente o processo
desejado, isto , que chega soluo procurada. Existem mtodos de prova formal da corretude,
empregando Lgica Matemtica. Nessa rea h duas classes de problemas: a prova da execuo correta e
a prova de que a execuo termina para quaisquer dados de entrada (problema de parada).
Uma outra tcnica especificar matematicamente um problema, e transformar essa especificao
(usando regras formais de transformao) at chegar-se a um algoritmo que pode ser formulado em uma
linguagem de programao. Essa rea denominada Transformao Formal de Programas. Em lugar de
provar que um programa est correto, faz-se sua deduo inicial de maneira correta, o que pode ser muito
mais simples e factvel.
Primeiro exemplo: ordenao por insero.
Comearemos pelo algoritmo de ordenao por insero, que um algoritmo eficiente para ordenar um
pequeno nmero de elementos

1
2
3
4
5
6
7
8

Insero (A)
para j = 2 at comprimento[A}
faa chave = A[j]
// insere A[j] na seqncia ordenada A[1..j-1]
i = j-1
enquanto (i > 0) e (A[i] > chave)
faa A[i+1] = A[i]
i= i-1
A[i+1] = chave

Exemplo, A = (5,2,4,6,1,3):
5

!
CENTRO UNIVERSITRIO

" ! #

SO CAMILO

&'

$#

' (

%! )

CURSO DE CINCIA DA COMPUTAO

Exerccios:
1. ilustre a operao Insero(A), para o vetor A=(31,41,59,26,41,58)
2. Rescreva Insero(A) para ordenar em ordem decrescente

Anlise do algoritmo de ordenao por insero:

linhas de cdigo

custo

no de repeties

c1

Insero (A)
1

para j = 2 at comprimento[A}

faa chave = A[j]

c2

n-1

// insere A[j] na seqncia ordenada A[1..j-1]

n-1

i = j-1

c4

n-1

enquanto (i > 0) e (A[i] > chave)

c5

c8

A[i+1] = chave

n
j =2
n

c7

i= i-1

j =2 j

c6

faa A[i+1] = A[i]

j =2

(t 1)
(t 1)
j

n-1

O tempo de execuo do algoritmo a soma dos tempos de execuo para cada linha (declarao):

T(n) = c1n + c2(n-1) + c4(n-1) + c5

t + c6

j =2 j

j =2

(t

1) + c7

n
j =2

(t

1) + c8(n-1)

O melhor caso de tempo de execuo de um algoritmo um limite inferior do tempo de execuo.

Se A[j] j estiver ordenada:

T(n) = c1n + c2(n-1) + c4(n-1) + c5(n-1) + c6(n-1) + c7(n-1) + c8(n-1) =

= (c1 + c2 + c4 + c5 + c6 + c7 + c8) n - (c2 + c4 + c5 + c8)

O pior caso de tempo de execuo de um algoritmo um limite superior do tempo de execuo.

Para alguns algoritmos, o pior caso ocorre freqentemente.
Se A[j] estiver ordenada na ordem inversa:

T(n) =

c5 c6 c7 2
c
c
c
n + c 1 + c 2 + c 4 + 5 6 7 + c 8 n (c 2 + c 4 + c 5 + c 8 )
+
+
2
2
2
2
2
2

Exerccio: Sabendo que

n
j= 2

j=

n(n + 1)
1, e
2

n
j= 2

( j 1) =

n(n 1)
, prove a expresso acima.
2

O caso mdio freqentemente to ruim quanto o pior caso (ou seja, da mesma ordem)

!
CENTRO UNIVERSITRIO

" ! #

SO CAMILO

&'

' (

$#

%! )

CURSO DE CINCIA DA COMPUTAO

Exerccio: comparao de tempos de execuo.

Para cada funo

T(n) e tempo t na tabela abaixo, determine o maior tamanho n de um problema que pode
T(n) microsegundos.

ser resolvido no tempo t, assumindo que o algoritmo para resolver o problema leva
(obs: lg n = log2 n = logaritmo binrio)

1s

1 min

1h

1 dia

1 ms

1 ano

1 sculo

T(n)
lg n

n
n
n lg n
n

n!

Resposta:
t

1s

1 min

1h

1 dia

1 ms

1 ano

1 sculo

106 s

6.107 s

3,6.109 s

8,64.1010 s

2,6.1012 s

3,2.1013 s

3,2.1015 s

T(n)
lg n
12

10

10

10

65000

10

n
n lg n

15

10

19

10

10

10

21

10

10

10

24

10

11

10

10

10

27

10

12

10

11

10

31

13

10

12

10

15

13

1000

7800

60000

300000

10

10

10

100

400

1500

4500

14000

30000

150000

20

26

31

36

41

44

51

n!

10

11

13

14

15

16

17

!
CENTRO UNIVERSITRIO

" ! #

SO CAMILO

&'

' (

$#

%! )

CURSO DE CINCIA DA COMPUTAO

CRESCIMENTO DE FUNES - notaes assintticas

Em geral, a taxa de crescimento, ou ordem de crescimento, do tempo de execuo de um algoritmo

2
que interessa. Por exemplo, considera-se apenas o termo de ordem mais alta da frmula (p.ex. an ), pois os
termos de ordem mais baixa so relativamente insignificante para n grandes.

notao

(g(n)) = {f(n) : existem constantes positivas c1 e c2 tais que 0 c1g(n) f(n) c2g(n), para todo n n0}

notao O big-O

O (g(n)) = {f(n) : existe constante positivas c tal que 0 f(n) cg(n), para todo n n0}

notao

(g(n)) = {f(n) : existe constante positiva c tal que 0 cg(n) f(n), para todo n n0}

Exerccios:

i)
ii)
iii)

n+1

2 = O (2 ) ?
2n
n
2 = O (2 ) ?
Considere a ordenao de n nmeros armazenados em uma matriz A achando primeiro o menor
elemento de A e colocando-o na primeira posio de outra matriz B. Ento achando o segundo
menor elemento de A e colocando-o na segunda posio de B. Continue dessa maneira, para todos
os elementos de A. Escreva o cdigo de execuo para este algoritmo, que conhecido como
ordenao por seleo. D o melhor caso e pior caso dos tempos de execuo em termos da
notao O.

!
CENTRO UNIVERSITRIO

" ! #

SO CAMILO

&'

' (

$#

%! )

CURSO DE CINCIA DA COMPUTAO

PROJETANDO ALGORITMOS - DIVISO E CONQUISTA.

Muitos algoritmos teis so recursivos na sua estrutura. Para resolver um dado problema eles chamam a si
mesmos recursivamente uma ou mais vezes para lidar com problemas. Tipicamente, estes algoritmos
seguem um esquema de diviso e conquista: eles quebram o problema em vrios sub-problemas que so
similares ao original, mas menores em tamanho, resolvendo os problemas recursivamente e ento
combinando estas solues para se obter a soluo do problema original.
Paradigma da diviso e conquista:
Divida o problema em um nmero de subproblemas
Conquiste os subproblemas, resolvendo-os recursivamente ou diretamente (para subproblemas
suficientemente pequenos)
Combine as solues dos subproblemas na soluo do problema original

EXEMPLO: ORDENAO POR FUSO

1. Dividir a seqncia de n elementos a ser ordenada em duas sub-seqncias de n/2 elementos cada
2. Ordenar as duas subseqncias recursivamente
3. Combinar as duas seqncias ordenadas para produzir uma resposta
Vamos definir: A[1..n] a seqncia original. p, q, e r so ndices numerando os elementos de A, tais
que p q < r.
Assumindo que duas partes de A, ou seja, A[p..q] e A[q+1..r] esto arranjadas, a combinao das
duas sub-seqncias ordenadas :

Fuso(A,p,q,r)
1
m = r p
2
i = 1
3
j = p
4
k = q + 1
5
para i = 0 at m faa
6
se j q ento aux1 = A[j]
7
seno aux1 = infinito
8
se k r ento aux2 = A[k]
9
seno aux2 = infinito
10
se aux1 < aux2
11
ento
12
B[i] = aux1
13
j = j + 1
14
seno
15
B[i] = aux2
16
k = k + 1
17
para i = 0 at m faa
18
A[p+i] = B[i]

Exerccio: calcule a funo de complexidade deste algoritmo.

!
CENTRO UNIVERSITRIO

" ! #

SO CAMILO

&'

$#

' (

%! )

CURSO DE CINCIA DA COMPUTAO

Podemos agora usar o procedimento Fuso() como uma parte do algoritmo de ordenao por fuso. O
procedimento OrdenaF(A,p,r) ordena os elementos no sub-arranjo A[p..r]. Se p r, o sub-arranjo tem
apenas um elemento, e portanto j est ordenado.
OrdenaF(A,p,r)
1
se p < r ento
2
q = (p + r) /2
3
OrdenaF(A,p,q)
4
OrdenaF(A,q+1,r)
5
Fuso(A,p,q,r)
Exemplo:
1

Anlise do algoritmo de ordenao por fuso:

1) Diviso: o passo de diviso apenas calcula o meio de cada seqncia, o que leva um tempo constante.
Assim, D(n) = (1).
2) Conquista: Resolve-se recursivamente dois sub-problemas, cada um com tamanho n/2, o que contribui
2T(n/2) para o tempo de execuo total.
3) Combinao: O procedimento de fuso toma um tempo C(n) = (n)

Assim:
T(n) = (1)
T(n) = 2T(n/2) + (n)

(para n = 1)
(para n > 1)

!
CENTRO UNIVERSITRIO

" ! #

SO CAMILO

&'

' (

$#

%! )

CURSO DE CINCIA DA COMPUTAO

5
5.1

RECURSO - anlise de recorrncias

Mtodo de substituio

Supondo-se uma soluo, testa-se matematicamente para achar as constantes e demonstrar que a soluo
funciona.
Exemplo (ordenao por fuso):
T(n) = 2T(n/2) + (n)
Soluo suposta: T(n) = O (n lg n)
T(n) 2 [c (n/2) lg (n/2)] + n
cn lg(n/2) + n
= cn lg n cn lg 2 + n
= cn lg n cn
cn lg n

Assim:

5.2

Mtodo de iterao

O mtodo de iterao consiste em expandir a recorrncia e express-la como uma soma de termos
dependentes apenas de n e das condies iniciais.
Exemplo:
T(n) = 3T(n/4) + n
Expandindo:

T(n) = n + 3 T(n/4)
= n + 3 ( n/4 + 3 T(n/16) )
= n + 3 ( n/4 + 3 ( n/16 + 3 T(n/64) ) )
= n + 3 n/4 + 9 n/16 + 27 T(n/64)
= ...
i

o i-simo termo da srie 3 (n/4 ). Quando (n/4 ) = 1, ou seja, quando i excede log4n

log n
b

onde utilizou-se a

log a
b .

=n

!
CENTRO UNIVERSITRIO

" ! #

SO CAMILO

&'

CURSO DE CINCIA DA COMPUTAO

Visualizao de iteraes com rvores de recurso:

Ex.: T(n) = 2T(n/2) + n

Ex.: T(n) = T(n/3) + T(2n/3) + n

' (

$#

%! )

!
CENTRO UNIVERSITRIO

" ! #

SO CAMILO

&'

' (

$#

%! )

CURSO DE CINCIA DA COMPUTAO

5.3

Mtodo mestre

O mtodo mestre fornece uma receita de bolo para resolver recorrncias da forma: T(n) = aT(n/b) + f(n),
com: a 1 , b > 1 e f(n) uma funo assintoticamente positiva.
Teorema mestre:
Para o caso geral descrito acima, T(n) pode ser limitada assintoticamente como segue:

I. se f(n) = O (nlogba- ), para alguma constante > 0, ento:

II. se f(n) = (nlogba ), ento:
III. se f(n) = (nlogba+ ), para alguma constante > 0, e se
a.f(n/b) c.f(n) para alguma constante c < 1 e para n
suficientemente grande, ento:

Exerccios:
1. Determine um bom limite assinttico de T(n) = 3T(n/2) + n por iterao.
2. Use o mtodo mestre para dar limites assintticos para:
a) T(n) = 2T(n/2) + (n)
b) T(n) = 9T(n/3) + n
c) T(n) = T(2n/3) + 1
d) T(n) = 3T(n/4) + n lgn
e) T(n) = 2T(n/2) + n lgn
f)

T(n) = 4T(n/2) + n.
Dica : use caso 1, percebendo que n = (n)
2

g) T(n) = 4T(n/2) + n .
2
2
Dica : use caso 2, percebendo que n = (n )
3

h) T(n) = 4T(n/2) + n .
Dica : use caso 3, com =1 e c=1/2

T(n) = (nlogba)
T(n) = (nlogba lgn)

T(n) = (f(n))

!
CENTRO UNIVERSITRIO

" ! #

SO CAMILO

&'

' (

$#

%! )

CURSO DE CINCIA DA COMPUTAO

Algoritmo Heapsort

rvore binria armazenada em um vetor

Suponha que temos um vetor A[1..n]. Por enquanto, os valores armazenados no vetor no nos
interessam; s interessam certas relaes entre ndices. Diremos que, para qualquer ndice i,

i/2 o pai de ndice i ,

2i o filho esquerdo de i ,
2i+1 o filho direito de i .

claro que isso deve ser entendido com cautela: o ndice 1 no tem pai; um ndice i s tem filho esquerdo
se 2i <= n; e i s tem filho direito se 2i+1 <= n.
Com essa histria de pais e filhos, o vetor adquire uma estrutura de rvore binria quase completa e os
elementos do vetor, identificados pelos ndices 1 a n, passam a ser chamados de ns. A figura abaixo
sugere uma maneira de encarar o vetor; nesta figura, os nmeros representam ndices e no valores dos
elementos do vetor.
1
2
4 5
8 9 10 11
16 17 18 19 20 21 22 23
32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

3
6
12
24
48

7
13 14 15
25 26 27 28 29 30 31
49 50 51 52 53 54 55

2
3
4
5

Os nmeros do lado direito indicam os nveis da rvore. Cada nvel p exceto o ltimo tem exatamente 2p
elementos e esses elementos so
2p, 2p+1, 2p+2, . . . , 2p+1-1.
(O ltimo nvel pode ter menos elementos.) O n i pertence ao nvel
cho(lg(i)).
Portanto, o nmero total de nveis 1 + cho(lg(n)).
O n 1 a raiz da rvore. Qualquer n i raiz da subrvore formada por i, seus filhos, seus netos, etc.
Ou seja, a subrvore com raiz i o vetor
A [i, 2i, 2i+1, 4i, 4i+1, 4i+2, 4i+3, 8i, ..., 8i+7, ... ].

EXEMPLO: A figura destaca a subrvore com raiz 13.

1
2
4 5
8 9 10 11
16 17 18 19 20 21 22 23
32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

3
6
12
24
48

7
13 14 15
25 26 27 28 29 30 31
49 50 51 52 53 54 55

2
3
4
5

!
CENTRO UNIVERSITRIO

" ! #

SO CAMILO

&'

' (

$#

%! )

CURSO DE CINCIA DA COMPUTAO

Altura de um n
O conceito de altura sutilmente diferente do conceito de nvel. A altura de um n i em A[1..n] o
nmero
cho(lg(n/i)) .
A altura de um n i o comprimento do mais longo caminho da forma i, filho(i), filho(filho(i)), . . . Os ns
que tm altura 0 so chamados folhas; o n n, por exemplo, uma folha.
A altura de um n i no passa da diferena entre os nveis de n e i, mas pode ser menor que essa
diferena.
Heap
Definio um tanto vaga: um heap uma rvore binria quase completa em que cada pai maior ou igual
que qualquer de seus filhos. Definio mais precisa: Um vetor A[1..n] um heap (= monte) se
A[cho(i/2)] >= A[i]
para i = 2, . . . , n. Em outras palavras, A[1..n] um heap se A[j] >= A[2j] e A[j] >= A[2j+1]
sempre que os ndices no ultrapassarem n.
s vezes convm aplicar a palavra "heap" apenas a uma parte do vetor: dado um ndice i, diremos que a
subrvore com raiz i um heap se
A[i] >= A[2i], A[i] >= A[2i+1], A[2i] >= A[4i], A[2i] >= A[4i+1], etc.
Por que um heap uma estrutura de dados to til? Eis algumas razes:

Se A[1..n] um heap, muito fcil encontrar um elemento mximo do vetor: A[1] mximo.
Se A[1..n] um heap e se o valor de A[1] for alterado, o heap pode ser restaurado muito
rapidamente (tempo O(lg(n))), como veremos adiante.
Um vetor A[1..n] arbitrrio pode ser transformado em um heap muito rapidamente (tempo O(n)),
como veremos adiante.

Exerccios
1. O algoritmo abaixo trabalha sobre um vetor A[1..m]. Que efeito o algoritmo tem sobre o vetor?
Justifique de maneira precisa. (Uma boa maneira de fazer isso dizer que "cara" tem o vetor no
incio de cada iterao "para" e no incio de cada iterao "enquanto".)
para j := 2 at m faa
i := j
enquanto i >= 2 e A[i/2] < A[i] faa
troque A[i/2] :=: A[i]
i := i/2
Delimite (usando notao Theta) o tempo total que o algoritmo consome no pior caso. Justifique.
2. O seguinte algoritmo transforma A[1..m] em heap?
para k := m decrescendo at 2 faa
se A[i/2] < A[i]
ento troque troque A[i/2] :=: A[i]

!
CENTRO UNIVERSITRIO

" ! #

SO CAMILO

&'

' (

$#

%! )

CURSO DE CINCIA DA COMPUTAO

Algoritmo auxiliar PENEIRA

Suponha dado um vetor A[1..n] e um ndice i tal que a subrvore com raiz 2i um heap e a subrvore
com raiz 2i+1 um heap.
PROBLEMA BSICO: Rearranjar o vetor de modo que a subrvore com raiz i seja um heap.
Como resolver o problema? A idia do algoritmo simples: se A[i] maior ou igual que seus filhos ento
no preciso fazer nada; seno, troque A[i] com o maior dos filhos e repita o processo para o filho
envolvido na troca.

PENEIRA (A, n, i)
e := 2i
d := 2i+1
se e <= n e A[e] > A[i]
ento f := e
seno f := i
se d <= n e A[d] > A[f]
ento f := d
se f > i ento
troque A[f] :=: A[i]
PENEIRA (A, n, f)
Quanto tempo o algoritmo consome no pior caso? claro que esse nmero vai depender de n e de i.
conveniente exprimir esse consumo de tempo em funo da altura de i, ou seja, em funo do nmero
cho(lg(n/i)); vamos denotar esse nmero simplesmente por h.
Digamos, ento, que o tempo de pior caso do algoritmo T(h), onde h a altura do n i. A figura abaixo
mostra o consumo de tempo de cada linha do algoritmo:
PENEIRA (A, n, i)
e := 2i
d := 2i+1
se e <= n e A[e] > A[i]
ento f := e
seno f := i
se d <= n e A[d] > A[f]
ento f := d
se f <> i ento
troque A[f] :=: A[i]
PENEIRA (A, n, f)

1
1
1
1
1
1
1
1
T(h-1)

A justificativa do "T(h-1)" fcil: se f diferente de i ento o nvel de f exatamente uma unidade maior
que o nvel de i. Portanto, T(h) dado pela seguinte recorrncia: T(0) <= 7 e T(h) <= T(h-1) + 8 para
h = 1, 2, 3, etc. Logo, T(h) <= 7 + 8h. Se preferir uma expresso mais simples, voc pode dizer que
T(h) <= 15 h
para h = 1, 2, 3, etc. Em termos dos parmetros n e i do algoritmo, podemos dizer que o consumo de
tempo no pior caso
O(lg(n/i)).
Em particular, verdade que o consumo de tempo O(lg(n)), mas esta delimitao grosseira demais
para o clculo que faremos na prxima seo.

!
CENTRO UNIVERSITRIO

" ! #

SO CAMILO

&'

' (

$#

%! )

CURSO DE CINCIA DA COMPUTAO

[O consumo de tempo do algoritmo deveria ser expresso em funo do "tamanho" do problema. Qual o
tamanho do problema que PENEIRA(A,n,i) resolve? O mais razovel dizer que esse tamanho o
nmero de ns na ``subrvore'' cuja raiz i. Infelizmente, difcil escrever uma frmula que d esse
nmero exatamente, mas certo que ele vale aproximadamente n/i. Podemos dizer ento que o consumo
de tempo de PENEIRA logartmico.]
Exerccios
1. Encontre uma frmula fechada para a funo f definida pela seguinte recorrncia:
f(1) = 7
f(k) = f(2k/3) + 8
quando k uma potncia de 3/2.
SOLUO: Supondo k = (3/2)j, temos:
j-1

j-2

j-3

j-j

f((3/2)j) = f((3/2) ) + 8 = f((3/2) ) + 8 + 8 = f((3/2) ) + 83 = f((3/2) ) + 8j = 7 + 8j

Logo, f(k) = 8 log3/2(k) + 7.
2. Digamos que um algoritmo X age sobre uma rvore binria quase completa com k ns. O algoritmo
recursivo e a recurso reduz o problema subrvore esquerda ou subrvore direita da rvore
dada. Digamos que o tempo de pior caso do algoritmo, T(k), satisfaz a seguinte recorrncia:
T(1) <= 7
T(k) <= T(cho(2k/3)) + 8
para k maior que 1. (Veja exerccio.) Mostre que T(k) <= 16 lg(k) para k = 2, 3, 4, . . .
SOLUO: A desigualdade vale com k = 2 pois T(2) = 15 e 16 lg(2) = 16. Agora suponha que k
> 2. Como lg(cho(2k/3)) <= lg(2k/3), teremos
T(k)

<=

16lg(2k/3) + 8

16(1 + lg(k) - lg(3)) + 8

16lg(k) + 24 - 16lg(3)

<=

16lg(k) ,

uma vez que 16lg(3) > 24.

!
CENTRO UNIVERSITRIO

" ! #

SO CAMILO

&'

' (

$#

%! )

CURSO DE CINCIA DA COMPUTAO

Construo de um heap
O algoritmo abaixo recebe um vetor A[1..n] e rearranja seus elementos de modo a transformar o vetor em
um heap.

CONSTRI-HEAP (A, n)
para i := cho(n/2) decrescendo at 1 faa
PENEIRA (A, n, i)
O algoritmo PENEIRA chamado cho(n/2) vezes. Cada chamada no consome mais que 15 h unidades
de tempo, onde h a altura de i. Como h <= lg(n), podemos dizer que o consumo de tempo do algoritmo
no pior caso
O(n lg(n)).
Mas esta estimativa muito folgada: na verdade, o consumo O(n), mesmo no pior caso. o que
veremos a seguir. Adote a abreviatura p = cho(lg(n)). Ento a rvore tem p+1 nveis, numerados de 0 a
p. O algoritmo comea a trabalhar no nvel p-1. Neste nvel, cada chamada do PENEIRA consome no
mais que 15 unidades de tempo, pois cada n tem altura 1. Como h 2p-1 ns neste nvel, o consumo total
<= 152p-1.
Se continuarmos esse raciocnio com os nveis p-2, . . . , 0 chegaremos concluso de que o tempo gasto
no passa de
15 (12p-1 + 22p-2 + 32p-3 + . . . ).
A figura resume o raciocnio. A coluna direita d o custo das execues de PENEIRA. Para simplificar,
foram omitidos os custos das linhas "para ...".
CONSTRI-HEAP (A, n)
p := cho(lg(n))
para i := cho(n/2) decrescendo at 2p-1 faa
PENEIRA (A, n, i)
para i := 2p-1-1 decrescendo at 2p-2 faa
PENEIRA (A, n, i)
para i := 2p-2-1 decrescendo at 2p-3 faa
PENEIRA (A, n, i)
. . .
para i := 21-1 decrescendo at 20 faa
PENEIRA (A, n, i)

15 1 2p-1
15 2 2p-2
15 3 2p-3
15 p 20

Mas a soma 12-1 + 22-2 + 32-3 + . . . menor que 2.

Logo, o tempo gasto pelo algoritmo no passa de
152p.
Como p <= lg(n), o tempo gasto no passa de 15 n . Conclumos assim a verificao de que o consumo
de tempo de CONSTRI-HEAP(A, n) O(n).

!
CENTRO UNIVERSITRIO

SO CAMILO

" ! #

&'

' (

$#

%! )

CURSO DE CINCIA DA COMPUTAO

Heapsort
Finalmente, vamos juntar todas as peas do quebra cabeas. O algoritmo abaixo recebe rearranja um vetor
A[1..N] (no confunda N com n) de modo que ele fique em ordem crescente.

HEAPSORT (A, N)
CONSTRI-HEAP (A, N)
para n := N, N-1, . . . , 2 faa
A[1] :=: A[n]
PENEIRA (A, n-1, 1)
Para entender como a coisa funciona, observe que no incio de cada iterao do "para"

o vetor A[1..n] um heap,

A[1..n] <= A[n+1..N] e
o vetor A[n+1..N] est em ordem crescente.
(Note como o algoritmo consegue fazer o servio seu usar vertor auxiliar!) claro que A[1..N] estar em
ordem crescente quando n for igual a 1.
1
n
N
888 777 666 555 444 333 222 111 000 999
999
999
999
999
heap, elementos pequenos
crescente, elementos grandes
fcil verificar que o consumo de tempo do algoritmo O(N lg(N)) no pior caso.
Exerccios
3. Escreva um algoritmo iterativo que faa o seguinte: recebe um vetor A[1..N] que um heap e
rearranja o vetor de modo que ele fique crescente. Faa uma anlise do consumo de tempo do seu
algoritmo no pior caso.

!
CENTRO UNIVERSITRIO

" ! #

SO CAMILO

&'

$#

' (

%! )

CURSO DE CINCIA DA COMPUTAO

Algoritmo Quicksort
1

O algoritmo QUICKSORT, inventado por C.A.R. Hoare , resolve o problema de rearranjar um vetor
A[p..r] de modo que ele fique em ordem crescente, A[p] ... A[r]. QUICKSORT utiliza a tcnica de
diviso e conquista. Ele muito rpido em mdia, mas lento no pior caso (que raro).
O subproblema da partio: O corao do QUICKSORT est em rearranjar A[p..r] de modo que todos
os elementos pequenos fiquem na parte esquerda do vetor e todos os elementos grandes fiquem na parte
direita, considerando um valor referncia (ou chave) x.
p

q
x

1
2
3
4
5
6
7
8
9
10

q+1
x

r
x

PARTICIONE(A, p, r)
x A[p]
i p-1
j r+1
enquanto verdade faa
repita j j-1
at A[j] <= x
repita i i+1
at A[i] >= x
se i < j
ento troque A[i] A[j]
seno retorne j

Exerccios
1. Mostre que os ndices i e j nunca referenciam um elemento de A fora do intervalo p..r
2. Mostre que o ndice j nunca igual a r quando PARTICIONE() termina.
3. Mostre que Cada elemento de A[p..j] menor ou igual que qualquer elemento de A[j+1..r]
quando PARTICIONE() termina.
4. Suponha que todos os elementos do vetor A[p..r] so iguais entre si. Quantas vezes a linha 4 do
algoritmo PARTICIONE() executada? Qual o valor de j que o algoritmo devolve?
5. Suponha que A[p..r] uma permutao de 1, 2, . . . , n. Qual o valor de j no fim do algoritmo
PARTICIONE() se o valor inicial de A[p] 1? E se o valor inicial de A[p] 2? E se o valor inicial
2
de A[p] x, com x em 3..n? E se o valor inicial de A[p] n?
6. Mostre que o consumo de tempo do algoritmo PARTICIONE() (n).

C.A.R. Hoare, Computer Journal, 5, pp.10-15, 1962.

Este exerccio faz parte da anlise do desempenho mdio do QUICKSORT

!
CENTRO UNIVERSITRIO

" ! #

SO CAMILO

&'

' (

$#

%! )

CURSO DE CINCIA DA COMPUTAO

O algoritmo Quicksort
O algoritmo QUICKSORT recebe um vetor A[p..r] e o rearranja em ordem crescente.

1
2
3
4

QUICKSORT(A, p, r)
se p < r ento
q PARTICIONE(A, p, r)
QUICKSORT(A, p, q)
QUICKSORT(A, q+1, r)

Desempenho do Quicksort no pior caso

O pior caso do QUICKSORT() ocorre quando a funo de particionamento produz uma regio com n-1
elementos e outra com apenas 1 elemento. Vamos supor que este particionamento desbalanceado surge
em cada passo do algoritmo. Como o particionamento custa (n) e T(1)= (1), a recorrncia para o tempo
de execuo :
T(n) = T(n-1) + (n)
o que leva a:
n

T(n) =

(k ) =

k =1

k = (n
)
2

k =1

Desempenho do Quicksort no melhor caso

O melhor caso do QUICKSORT() ocorre para particionamento balanceado:

T(n) = 2T(n/2) + (n)

T(n) = (n lgn)

Exerccio
7. Mostre a soluo acima usando o caso 2 do Teorema Mestre
Intuio para o desempenho mdio do Quicksort

O consumo de tempo mdio do QUICKSORT() equivalente ao do melhor caso, T(n) = (n lgn).

A verificao rigorosa deste fato no fcil, mas a idia intuitiva simples: o consumo de tempo s chega
2
perto de n quando o valor de q devolvido por PARTICIONE() est sistematicamente muito prximo de p ou
de r-1. A intuio sugere que isso deve ser raro. No caso mdio, PARTICIONE() produz uma mistura de
separaes "boas" e "ruins". Na rvore de recurso de um caso mdio, as divises "boas" e "ruins" esto
aleatoriamente distribudas. Por exemplo, em 80% das vezes, PARTICIONE() produz uma separao que
mais balanceada que 9 para 1. No caso hipottico de separaes reincidentes de 9 para 1, a recorrncia
T(n) = T(9n/10) + T(n/10) + (n) tambm leva a T(n) = (n lgn). Assim, mesmo sem realizarmos uma prova
formal, podemos intuir que o caso mdio de QUICKSORT() corresponde ao caso timo.

!
CENTRO UNIVERSITRIO

SO CAMILO
CURSO DE CINCIA DA COMPUTAO

" ! #

&'

' (

$#

%! )

!
CENTRO UNIVERSITRIO

" ! #

SO CAMILO

&'

' (

$#

%! )

CURSO DE CINCIA DA COMPUTAO

PROJETANDO ALGORITMOS PROGRAMAO DINMICA

Programao Dinmica, como o mtodo de Diviso e Conquista, resolve os problemas combinando

solues para os subproblemas. Ao contrrio da tcnica de diviso e conquista, entretanto, esta tcnica
aplicvel quando os subproblemas no so independentes, ou seja, quando eles compartilham
subproblemas (assim, diviso e conquista gastaria mais tempo, pois resolveria repetidamente subproblemas
comuns).
Um algoritmo usando Programao Dinmica resolve cada subproblema uma vez, e
salva sua resposta em uma tabela, evitando o trabalho de recalcular sua resposta.
O desenvolvimento de um algoritmo com programao dinmica pode ser caracterizado
seqncia de quatro passos:
1.
2.
3.
4.

como uma

Caracterizar a estrutura de uma soluo tima do problema

Definir, recursivamente, o valor de cada soluo tima
Calcular o valor de uma soluo tima, na seqncia: do menor para o maior subproblema
Construir uma soluo tima a partir da informao calculada

Note que o problema decomposto uma nica vez, e que os subproblemas menores so gerados antes dos
maiores. Assim, este mtodo chamado ascendente, ao contrrio dos mtodos de diviso e conquista, que
so chamados descendentes.
Utiliza-se a seguinte propriedade de optimalidade: S solues timas dos subproblemas podem
compor uma soluo tima do problema

8.1

Multiplicao de matrizes

Trata-se de multiplicar n matrizes, ou seja, calcular o produto:

M = M1 x M2 x ... x Mn
Onde cada matriz Mi tem bi-1 linhas e bi-1 colunas, para 1 i n. O algoritmo imediato para multiplicar cada
matriz p x q por outra q x r :

[A B]ij =

q
k =1

A ik .Bkj

onde a matriz-produto ter p x r elementos. Este clculo portanto requer (p x q x r) multiplicaes de

elementos. Veja o algoritmo de multiplicao de matrizes abaixo:

multMatriz (A,B)
se colunas[A] linhas[B]
ento erro dimenses incompatveis
seno para i = 1 at linhas [A] faa
para j = 1 at colunas[B] faa
C[i,j] = 0
para k = 1 at colunas[A] faa
C[i,j] = C[i,j] + A[i,k]*B[k,j]
retorne C

!
CENTRO UNIVERSITRIO

" ! #

SO CAMILO

&'

' (

$#

%! )

CURSO DE CINCIA DA COMPUTAO

Como a multiplicao de matrizes associativa (no comutativa), h vrias maneiras de se realizar as

multiplicaes. Isso pode afetar o nmero de operaes final. Considere por exemplo:

M = M1(100 x 3) x M2(3 x 10) x M3(10 x 50) x M4(50 x 30) x M1(30 x 5)

Calcular M por meio de ( ( ( M1 x M2 ) x M3 ) x M4 ) x M5 requer 218.000 operaes. Por outro lado,
agrupando diferentemente as operaes, M = M1 x (M2 x ( (M3 x M4) x M5) ) , temos 18.150 operaes.
Checar todas as ordenaes possveis de clculo das multiplicaes de matrizes (busca exaustiva ou forabruta) no leva a um algoritmo eficiente para escolha da melhor parentizao do produto.

O primeiro passo do paradigma de programao dinmica

caracterizar a estrutura de uma soluo tima.

Vamos adotar a seguinte notao: Mi..j a matriz que resulta do produto Mi x Mi+1 x ... x Mj.
Uma parentizao tima do produto M1 x M2 x ... x Mn divide a seqncia de multiplicaes na matriz k, com
1 k < n. Ou seja, dado um ndice k, primeiro calculamos o produto M1..k e Mk+1..n e ento os multiplicamos
para produzir o resultado final. O custo total ento dado pela soma do custo de calcular M1..k , mais o
custo de calcular Mk+1..n , mais o custo de multiplic-las para produzir o resultado final.
Mas, a observao chave aqui que, os produtos M1..k e Mk+1..n tambm devem ser otimizados.

O segundo passo do paradigma de programao dinmica

definir o valor de uma soluo tima, recursivamente,
em termos das solues timas dos subproblemas.

Seja mi,j o mnimo nmero de multiplicaes escalares necessrias para se calcular o produto Mi..j .
Podemos definir mi,j recursivamente como se segue. Se i = j, mi,j = 0. Para calcular mi,j quando i < j
tomamos vantagem da estrutura de uma soluo tima avaliada no passo 1.

mi,j = mi,k + mk+1,j + di-1 dk dj

onde di-1 dk dj o o custo de multiplic-las para produzir o resultado final (d uma dimenso de matriz;
di-1 o nmero de linhas da matriz resultante Mi..k).
Mas, o valor de k ainda uma incgnita, ou seja, precisamos checar todos estes valores de k para descobrir
qual leva soluo tima. Assim, temos:

mi,j = mnimo { mi,k + mk+1,j + di-1 dk dj} , para i k < j

mi,j = 0
, para i = j

Ao invs de calcular a recorrncia acima para m1,n recursivamente (o que levaria um tempo exponencial
com n), vamos realizar o terceiro passo do paradigma da programao dinmica:

!
CENTRO UNIVERSITRIO

" ! #

SO CAMILO

&'

' (

$#

%! )

CURSO DE CINCIA DA COMPUTAO

O terceiro passo do paradigma de programao dinmica

calcular o custo timo do menor para o maior problema.

O algoritmo abaixo assume que cada matriz Mi tem dimenses di-1 di, para i = 1, 2, 3...n. A entrada a
seqncia D = (d0,d1,d2...dn). O procedimento preenche uma tabela auxiliar m[1..n,1..n] para
armazenar os custos mi,j e uma tabela auxiliar s[1..n,1..n], que grava qual o ndice k atingido para o custo
timo de clculo, mi,j .

ordenaCadeiaDeMatrizes(D)
n = comprimento(D)1
para i = 1 at n faa m[i,i]=0
para l = 2 at n faa
para i = 1 at n-l+1 faa
j = i+l-1
m[i,j] =
para k = i at j-1 faa
q = m[i,k]+m[k+1,j]+D[i-1]*D[k]*D[j]
se q < m[i,j] ento
m[i,j] = q
s[i,j] = k
retorna m e s

//escolhe os k e avalia mi,j

// zera os mi,i
// Calcula primeiro m[i,i+1] para
// cadeias de comprimento l=2. Depois
// calcula m[i,i+2] para cadeias de
// comprimento l=3, etc. Em cada passo,
// os custos m[i,j] calculados
// dependem apenas das entradas de
// tabela m[i,k] e m[k+1,j], j
// calculados.

Exemplo:
matriz

A1
A2
A3
A4
A5
A6

dimenso
30 x 35
35 x 15
15 x 5
5 x 10
10 x 20
20 x 25

Figura 1 Matrizes m e s calculadas por ordenaCadeiaDeMatrizes(), para as matrizes do exemplo.

As tabelas esto rodadas, de maneira que a diagonal principal est na horizontal. As vrgulas referem-se
notao numrica inglesa de milhar (figura escaneada de livro em ingls)

!
CENTRO UNIVERSITRIO

" ! #

SO CAMILO

&'

' (

$#

%! )

CURSO DE CINCIA DA COMPUTAO

O menor nmero de multiplicaes escalares para se realizar o produto das matrizes A1-6 m1,6 = m[1,6]
= 15125. Cada linha horizontal da tabela rotacionada, como na figura, contm entradas para cadeias de
mesmo comprimento.
Uma inspeo simples dos loops de ordenaCadeiaDeMatrizes(), leva a um tempo de execuo de
O(n3) para o algoritmo. Alm disso, o algoritmo requer (n2) espao para armazenar as tabelas m e s.

O quarto passo do paradigma de programao dinmica

construir uma soluo tima a partir da informao calculada.

O procedimento ordenaCadeiaDeMatrizes(), no mostra diretamente como multiplicar as matrizes.

Nesse caso, iremos usar a tabela s[1..n,1..n] para determinar o melhor modo de multiplicar as
matrizes. Fazendo k0 = s[1,n], sabemos que o produto das matrizes, A1..n, realizado otimamente
como A1..k0 Ak0+1..n. As multiplicaes de matrizes anteriores podem ser calculadas recursivamente, pois

s[1,s[1,n]] d o k1 que otimiza A1.. k0, e s[s[1,n]+1,n] d o k2 que otimiza Ak0+1,n , e assim por
diante.
O procedimento abaixo calcula o produto de matrizes A1..n , dadas as matrizes
s calculada por ordenaCadeiaDeMatrizes(), e os ndices i e j.

A = { A1, A2,.. An}, a tabela

multCadeiaDeMatrizes(A,s,i,j)
se j > i
ento
X = multCadeiaDeMatrizes(A,s,i,s[i,j])
Y = multCadeiaDeMatrizes(A,s,s[i,j]+1,j)
retorne multMatriz(X,Y)
seno retorne Ai
No exemplo dado, este procedimento multiplica as matrizes de acordo com: (A1 (A2A3)) ((A4A5)

A6).

!
CENTRO UNIVERSITRIO

SO CAMILO

" ! #

&'

' (

$#

%! )

CURSO DE CINCIA DA COMPUTAO

PROJETANDO ALGORITMOS MTODO GULOSO

Como os algoritmos de Programao Dinmica, algoritmos gulosos resolvem os problemas realizando

solues timas para os subproblemas, mas nesse caso de uma maneira local. Um algoritmo guloso
sempre faz a escolha que parece melhor no momento. Nem sempre levam a solues globais timas, mas
para muitos problemas sim.
Um exemplo simples o do Troco em moedas. Para minimizar a quantidade de moedas necessrias para
fazer um troco, suficiente selecionar repetidamente a moeda de maior valor que no maior que a
quantidade ainda devida.
Existem vrios problemas aos quais o Mtodo Guloso prov uma soluo tima mais rapidamente que a
Programao Dinmica. O Mtodo Guloso especialmente til para resolver problemas de otimizao
combinatria, cuja soluo s pode ser alcanada por uma seqncia de decises. Uma importante
aplicao o design de cdigos de compresso de dados.

!
CENTRO UNIVERSITRIO

SO CAMILO

" ! #

&'

' (

$#

%! )

CURSO DE CINCIA DA COMPUTAO

10 PROBLEMAS TRATVEIS E PROBLEMAS INTRATVEIS

Problemas tratveis e intratveis

Considere a coleo de todos os algoritmos que resolvem um certo problema.

Se existir algum algoritmo de complexidade polinomial, ento o problema denominado tratvel. Caso
contrrio, denominado intratvel.
A idia que um problema tratvel sempre pode ser resolvido por um processo automtico (por
exemplo, computador) em tempo factvel.
Algoritmos no polinomiais, de problema intratvel, podem levar sculos, mesmo para entradas de
tamanho reduzido.
Verificando a tratabilidade

Um problema tratvel se for possvel exibir um algoritmo de complexidade polinomial que o resolva.
Por outro lado, para verificar se um problema intratvel, h a necessidade de se provar que todo
possvel algoritmo que o resolva no possui complexidade polinomial.
Existe classe de problemas para os quais todos os algoritmos conhecidos so de complexidade
exponencial, mas por outro lado, no se conhecem provas, at o momento, de que o fato seja comum a
todos os possveis algoritmos para esses problemas.

!
CENTRO UNIVERSITRIO

" ! #

SO CAMILO

&'

' (

$#

%! )

CURSO DE CINCIA DA COMPUTAO

11 INTRODUO S CLASSES DE COMPLEXIDADE ALGORTMICA

Classe de complexidade (definio) : Qualquer conjunto de problemas
computacionais com mesmas limitaes em tempo e espao (como funo
de n), para mquinas determinsticas e no-determinsticas.

A Classe P
Define-se a classe P de problemas como sendo aquela que compreende precisamente aqueles problemas
que admitem soluo por um algoritmo de tempo polinomial, em uma mquina determinstica.
A Classe NP
Define-se a Classe NP como sendo aquela que compreende todos os problemas de deciso para os quais a
resposta pode ser checada por um algoritmo cujo tempo de execuo polinomial como funo do tamanho
da entrada (n). Note que isso no requer ou implica que uma resposta possa ser obtida rapidamente,
apenas que qualquer resposta pode ser verificada (ou em alguns casos refutada) rapidamente. NP a
classe na qual mquinas no-determinsticas aceitam tempo polinomial.
A Classe NP-completa
a classe de complexidade de problemas de deciso na qual respostas podem ser checadas quanto sua
correo (dado um certificado) por um algoritmo cujo tempo de execuo polinomial no tamanho da
entrada (isso , NP) e nenhum outro problema NP tem peso maior que um fator polinomial a mais. Ou seja,
um algoritmo rpido para resolver este problema pode ser usado para resolver todos os outros problemas
NP rapidamente.

Observa-se que:

no se exige uma soluo polinomial para os problemas de NP; somente que uma justificativa
resposta SIM possa ser verificada em tempo polinomial no tamanho da entrada.

P NP, pois se existe um algoritmo polinomial que apresenta a soluo, pode ser utilizado como
algoritmo de reconhecimento para uma justificativa resposta.

P NP ? At o momento, no se conhece a resposta a essa pergunta. Todas as evidncias

apontam na direo P NP. O principal argumento para essa conjectura que a classe NP
incorpora um conjunto enorme de problemas, para os quais inmeros pesquisadores tm procurado
algoritmos polinomiais, porm sem sucesso.

Se um problema da classe NP ento possvel ao menos resolver em tempo exponencial todo

problema da classe NP.

P a subclasse de "menor dificuldade" de NP. A subclasse de "maior dificuldade" de NP a classe

dos problemas NP-completos. Intuitivamente, se uma soluo polinomial for encontrada para um
problema NP-completo, ento todo problema de NP tambm admite soluo polinomial (e
consequentemente, nessa hiptese, P=NP).