Informática Teórica Engenharia da Computação. COMPLEXIDADE DE TEMPO A escolha do modelo não...
Transcript of Informática Teórica Engenharia da Computação. COMPLEXIDADE DE TEMPO A escolha do modelo não...
Informática Teórica
Engenharia da Computação
COMPLEXIDADE DE TEMPO
A escolha do modelo não afeta o poder: todos são equivalentes:– MT de uma única fita– MT multifita– MT não-determinística
Mas afeta a complexidade de tempo– MT multifita O(t(n)) → MT única fita O(t2(n))– MT não-determinística O(t(n)) → MT única fita
2O(t(n))
COMPLEXIDADE DE TEMPO
Diferenças polinomiais serão consideradas pequenas– MT multifita e MT com uma fita– Polinomialmente equivalentes
Mas diferenças exponenciais serão tomadas como grandes– MT não-determinística e MT com uma fita
COMPLEXIDADE DE TEMPO
Algoritmos exponenciais– Raramente são úteis– Em geral surgem numa busca por força bruta– Exemplo: fatoração
Algoritmos polinomiais– Rápidos para muitos propósitos– Computadores reais– Vários modelos computacionais são
polinomialmente equivalentes
COMPLEXIDADE DE TEMPO
Já desprezamos fatores constantes– Notação O-grande
Iremos desprezar diferenças polinomiais– Nossa teoria não dependerá de um modelo de
computação específico– São importantes, mas queremos olhar por uma
perspectiva diferente
CLASSE P
DEFINIÇÃO P é a classe de linguagens que são decidíveis
em tempo polinomial por uma MT determinística de uma única fita
k
kn )(TIMEP
CLASSE P
P é matematicamente robusta– Invariante para os modelos de computação
equivalentes à MT determinística de uma fita
P é relevante de um ponto de vista prático– Problemas realisticamente solúveis em um
computador
CLASSE P – DESCRIÇÃO DOS ALGORITMOS
Algoritmos serão descritos em alto nível– Não nos prenderemos em detalhes de um modelo
computacional específico– Evitaremos detalhes relativos a fitas e movimentos
de cabeças
Descrição dos estágios– Estágios serão enumerados (como antes)– Um estágio em geral vai requerer muitos passos
numa MT
CLASSE P – DESCRIÇÃO DOS ALGORITMOS
Análise quanto à polinomialidade– Entrada de comprimento n– Dar um limitante superior polinomial para o
número de estágios que o algoritmo roda em função de n
– Cada estágio deve ser implementável em tempo polinomial num modelo determinístico razoável
Se os critérios acima forem respeitados, então o algoritmo executa em tempo polinomial– A composição de polinômios é um polinômio
CLASSE P – DESCRIÇÃO DOS ALGORITMOS
Codificação da entrada– Continuamos com – A codificação e a decodificação dos objetos devem
ser polinomiais (razoáveis)– Exemplos: codificações que temos usados para
autômatos e grafos
Grafos– Matriz de adjacência: (i,j) é 1 sse existe aresta do
nó i para j– Tempo calculado em função do número de nós
CLASSE P – PROBLEMAS
CAM = {<G,s,t> | G é um grafo direcionado que tem um caminho de s para t }
CLASSE P – PROBLEMAS
TEOREMA CAM ∈ P
Estratégia força bruta– Examina todos os caminhos potenciais em G– Determinar se algum é um caminho direcionado de
s para t– Caminho potencial: sequência de nós em G tendo
um comprimento de no máximo |V|– Há aproximadamente |V||V| caminhos potenciais– Tempo exponencial
CLASSE P – PROBLEMAS
IDÉIA DA PROVA: usar um método de busca no grafo para evitar a força bruta.– Busca em largura: marcamos sucessivamente
todos os nós que são atingíveis a partir de s por caminhos de comprimento 1, depois 2, em seguida 3 etc.
– Mostrar que a estratégia é polinomial
PROVA: o algoritmo seguinte M decide CAM em tempo polinomial
CLASSE P – PROBLEMAS
M = “Sobre a entrada <G, s, t> onde G é um grafo direcionado com nós s e t:– 1. Marque o nó s.– 2. Repita o passo seguinte até que nenhum nó
adicional seja marcado 3. Para cada aresta (a,b) de G: se a for um nó
marcado e b não estiver marcado, marque b.– 4. Se t estiver marcado, aceite. Senão, rejeite.”
CLASSE P – PROBLEMAS
Número de passos de M– Os passos 1 e 4 executam apenas uma vez– O passo 3 executa no máximo |V| vezes: no pior
caso, apenas um nó é marcado a cada vez, exceto a última
Complexidade dos passos de M– Os passos 1 e 4 são facilmente implementados em
tempo polinomial– O passo 3 varre cada aresta e executa um teste
para ver se um nó está marcado
CLASSE P – PROBLEMAS
Conclusão da prova– M executa uma quantidade de passos polinomial
na entrada– Todos os passos de M rodam em tempo polinomial
na entrada– Logo, M é polinomial– CAM ∈ P
Exercício do livro: 7.8
CLASSE P – PROBLEMAS
PRIM-ES = {<x, y> | x e y são primos entre si}
Dois números são primos entre si quando 1 é o maior inteiro que divide ambos
<10, 21> PRIM-ES∈ <10, 22> PRIM-ES∉
CLASSE P – PROBLEMAS
TEOREMA PRIM-ES ∈ P
Estratégia força bruta– Procurar entre todos os possíveis divisores de
ambos os números– Aceita se o único divisor comum entre eles for 1– A magnitude de um número representado em
qualquer base maior ou igual a 2 é exponencial no comprimento da representação
– Então a busca é feita entre um número exponencial de potenciais divisores
CLASSE P – PROBLEMAS
IDÉIA DA PROVA: usar o algoritmo de Euclides para computar o máximo divisor comum– Calcular o MDC de x e y– Se o resultado for 1, x e y são primos entre si
Função mod: retorna o resto da divisão do primeiro número pelo segundo– 10 mod 3 = 1– 28 mod 4 = 0
CLASSE P – PROBLEMAS
PROVA: definiremos o algoritmo E para computar o MDC. Em seguida, definiremos o algoritmo R para decidir PRIM-ES
CLASSE P – PROBLEMAS
E = “Sobre a entrada <x, y>, onde x e y são números naturais em binário:– 1. Repita até que y = 0:
2. x := x mod y 3. Troque os valores de x e y
– 4. Retorne x”
R = “Sobre a entrada <x, y>, onde x e y são números naturais em binário:– 1. Execute E sobre <x, y>– 2. Se E retornou 1, aceite. Senão, rejeite.”
CLASSE P – PROBLEMAS
Complexidade de E– O passo 2 reduz o valor de x no mínimo pela
metade (exceto possivelmente na 1ª vez: se x ≤ y)– Após o passo 2 temos x < y e depois do passo 3
temos x > y: a cada iteração do loop, um valor é reduzido no mínimo pela metade e o outro não
– Então o número máximo de execuções do loop é o mínimo entre 2log2x e 2log2y
– Como x e y são representados em binário, a quantidade de passos de E é O(n)
– Os passos de E são facilmente implementáveis em tempo polinomial. Logo, o algoritmo é polinomial
CLASSE P – PROBLEMAS
Complexidade de R– R = “Sobre a entrada <x, y>, onde x e y são
números naturais em binário: 1. Execute E sobre <x, y> 2. Se E retornou 1, aceite. Senão, rejeite.”
– Como E roda em tempo polinomial, então R também é polinomial
Exercícios do livro: 7.3 e 7.12
CLASSE P – PROBLEMAS
AGLC = {<G, w> | G é uma GLC que gera a cadeia w }
Uma MT que decide AGLC
S = “Sobre a entrada <G, w>, onde G é uma GLC e w uma cadeia de comprimento n:– 1. Converta G para a forma normal de Chomsky– 2. Liste todas as derivações com 2n-1 passos (se
n = 0, liste todas as derivações com 1 passo)– 3. Se alguma derivação gerou w, aceite. Senão,
rejeite.”
CLASSE P – PROBLEMAS
S roda em tempo polinomial?– Qualquer derivação de uma cadeia |w| = n tem 2n-
1 passos (se a gramática está na forma normal de Chomsky)
– S tenta todas as derivações com 2n-1 passos para verificar se alguma gera w
– Como o número de derivações com k passos pode ser exponencial em k, S não é polinomial
– Logo, S não prova que aceitação de LLC é polinomial
Existe algum algoritmo polinomial para aceitação de LLC?
CLASSE P – PROBLEMAS
TEOREMA IDÉIA DA PROVA
– Utilizar programação dinâmica: guardar informações sobre subproblemas menores
– Subproblema: determinar se cada variável da GLC gera cada subcadeia de w
– Usar uma tabela n x n para guardar as soluções dos subproblemas
– (i, j): se i ≤ j, então a célula guarda as variáveis que geram a subcadeia wiwi+1...wj. As posições com i > j não serão utilizadas
– Preenche a tabela para as subcadeias de comprimento 1, depois 2, ... Até a de tamanho n
CLASSE P – PROBLEMAS
IDÉIA DA PROVA (continuação)– Suponha que o algoritmo já tenha resolvido o problema
para todas as subcadeias de tamanho k– Para saber se alguma variável A gera uma subcadeia
específica de tamanho k+1: Dividir a subcadeia de tamanho k+1 em duas partes não
vazias (há k possibilidades de divisão) Para cada divisão, o algoritmo passa por cada regra do
tipo A → BC Se B gera a primeira subcadeia e C gera a segunda,
então A gera a subcadeia de tamanho k+1 Adicionamos A à entrada associada da tabela
– Iniciamos com as cadeias de tamanho 1 e analisando as regras do tipo A → b
CLASSE P – PROBLEMAS
TEOREMA PROVA: algoritmo que recebe uma gramática na
forma normal de Chomsky e uma cadeia w (S é a variável inicial da gramática)
D = “Sobre a entrada w = w1w2...wn
– 1. Se w = ε e S → ε for uma regra, aceite– 2. Para i=1 até n:
3. Para cada variável A:– 4. Teste se A → wi é uma regra
– 5. Se for, adicione A em tabela(i, i)
CLASSE P – PROBLEMAS
D (continuação)– 6. Para l = 2 até n [l é o comprimento da subcadeia]
7. Para i=1 até n-l-1 [i é a posição inicial da subcadeia]
8. j := i+l-1 [j é a posição final da subcadeia]
9. Para k=i até j-1 [k é onde ocorre a divisão]
– 10. Para cada regra A → BC– 11. Se tabela(i, k) contém B e tabela (k+1,j) contém C
Coloque A em tabela(i, j)
– 12. Se S estiver em tabela(1, n), aceite. Senão, rejeite
CLASSE P – PROBLEMAS
Complexidade de D– Todo os passos são implementados em tempo polinomial– A quantidade de passos é polinomial: O(n3) + O(n) = O(n3)
O passo 1 roda apenas uma vez Os passos 4 e 5 rodam no máximo n*v (onde v é o número de
variáveis): O(n) O passo 6 roda no máximo n vezes
– Para cada vez que o 6º roda, o passo 7 roda no máximo n vezes– Para cada vez que o 7º roda, os passos 8 e 9 rodam no máximo
n vezes– Cada execução do 9º, o passo 10 roda r vezes (onde r é uma
constante fixa) Logo, o passo 11 roda O(n3) vezes
Exercício do livro: 7.4
Informática Teórica
Engenharia da Computação