cco 101 processamento de dados - rcosta62br.unifei.edu.br · square root algorithms um algoritmo de...
Post on 09-Dec-2018
392 Views
Preview:
TRANSCRIPT
CIC 111Análise e Projeto de Análise e Projeto de
Algoritmos IIAlgoritmos II
Universidade Federal de Itajubá
Prof. Roberto Affonso da Costa Junior
AULA 27AULA 27– Square root algorithms
• Combining algorithms• Integer partitions• Mo’s algorithm
Square Root AlgorithmsSquare Root Algorithms
Um algoritmo de raiz quadrada é um algoritmo que tem uma raiz quadrada em sua complexidade de tempo. Uma raiz quadrada pode ser vista como um “logaritmo do homem pobre”: a complexidade O(√n) é melhor que O(n), mas pior que O(log n). Em qualquer caso, muitos algoritmos de raiz quadrada são rápidos e utilizáveis na prática.
Square Root AlgorithmsSquare Root Algorithms
Como exemplo, considere o problema de criar uma estrutura de dados que suporte duas operações em um vetor: modificar um elemento em uma determinada posição e calcular a soma de elementos no intervalo determinado. Anteriormente, resolvemos o problema usando árvores binárias indexadas e segmentadas, que suportam ambas as operações no tempo O(log n). No entanto, agora vamos resolver o problema de outra maneira usando uma estrutura de raiz quadrada que nos permite modificar elementos em tempo O(1) e calcular somas em tempo O(n).
Square Root AlgorithmsSquare Root Algorithms
A ideia é dividir o vetor em blocos de tamanho n para que cada bloco contenha a soma dos elementos dentro do bloco. Por exemplo, um vetor de 16 elementos será dividida em blocos de 4 elementos da seguinte forma:
22 17 20 13
5 8 6 3 2 7 2 6 7 1 7 5 6 2 3 2
Square Root AlgorithmsSquare Root Algorithms
Nessa estrutura, é fácil modificar os elementos do vetor, pois só é necessário atualizar a soma de um único bloco após cada modificação, o que pode ser feito no tempo O(1). Por exemplo, a figura a seguir mostra como o valor de um elemento e a soma do bloco correspondente mudam:
22 15 20 13
5 8 6 3 2 5 2 6 7 1 7 5 6 2 3 2
Square Root AlgorithmsSquare Root Algorithms
Então, para calcular a soma dos elementos em um intervalo, dividimos o intervalo em três partes, de modo que a soma consiste em valores de elementos únicos e somas de blocos entre eles:
22 15 20 13
5 8 6 3 2 5 2 6 7 1 7 5 6 2 3 2⏟
Square Root AlgorithmsSquare Root Algorithms
Como o número de elementos únicos é O(√n) e o número de blocos também é O(√n), a consulta soma toma O(√n) tempo. O objetivo do tamanho do bloco n é que ele equilibra duas coisas: o vetor é dividido em n blocos, cada um contendo n elementos.
Square Root AlgorithmsSquare Root Algorithms
Na prática, não é necessário usar o valor exato de √n como parâmetro e, em vez disso, podemos usar os parâmetros k e n / k, onde k é diferente de √n. O parâmetro ideal depende do problema e da entrada. Por exemplo, se um algoritmo costuma passar pelos blocos, mas raramente inspeciona elementos únicos dentro dos blocos, pode ser uma boa ideia dividir o vetor em blocos k < √n, cada um contendo n / k > √n elementos.
Combining AlgorithmsCombining Algorithms
Discutiremos dois algoritmos de raiz quadrada baseados na combinação de dois algoritmos em um algoritmo. Em ambos os casos, podemos usar um dos algoritmos sem o outro e resolver o problema no tempo O(n2). No entanto, combinando os algoritmos, o tempo de execução é apenas O(n√n).
Case ProcessingCase Processing
Suponha que nos seja dada uma matriz que contenha n células. Cada célula recebe uma letra e nossa tarefa é encontrar duas células com a mesma letra, cuja distância é mínima, onde a distância entre as células (x
1, y
1) e (x
2, y
2) é | x
1 - x
2 | + | y
1 - y
2 | . Por exemplo,
considere a seguinte matriz:
A F B A
C E G E
B D A F
A C B D
Case ProcessingCase Processing
Nesse caso, a distância mínima é de 2 entre as duas letras "E". Podemos resolver o problema considerando cada letra separadamente. Usando essa abordagem, o novo problema é calcular a distância mínima entre duas células com uma letra fixa c. Nós nos concentramos em dois algoritmos para isso:
Case ProcessingCase Processing
Algoritmo 1: Passe por todos os pares de células com a letra c e calcule a distância mínima entre essas células. Isso levará o tempo O(k2) em que k é o número de células com letra c.
Algoritmo 2: Realize uma pesquisa por amplitude que inicie simultaneamente em cada célula com a letra c. A distância mínima entre duas células com letra c será calculada no tempo O(n).
Case ProcessingCase Processing
Uma maneira de resolver o problema é escolher um dos algoritmos e usá-lo para todas as letras. Se usarmos o Algoritmo 1, o tempo de execução será O(n2), porque todas as células podem conter a mesma letra e, neste caso, k = n. Além disso, se usarmos o Algoritmo 2, o tempo de execução será O(n2), porque todas as células podem ter letras diferentes e, nesse caso, n pesquisas são necessárias.
Case ProcessingCase Processing
No entanto, podemos combinar os dois algoritmos e usar algoritmos diferentes para letras diferentes, dependendo de quantas vezes cada letra aparece na matriz. Suponha que uma letra c apareça k vezes. Se k ≤ √n, usamos o Algoritmo 1, e se k > √n, usamos o Algoritmo 2. Acontece que, ao fazer isso, o tempo total de execução do algoritmo é apenas O(n√n).
Case ProcessingCase Processing
Primeiro, suponha que usemos o Algoritmo 1 para uma letra c. Como c aparece no máximo n vezes na matriz, nós comparamos cada célula com a letra c O(n) vezes com outras células. Assim, o tempo usado para processar todas essas células é O(n√n). Então, suponha que usamos o Algoritmo 2 para uma letra c. Existem no máximo n tais letras, então o processamento dessas letras também leva O(n√n) tempo.
Batch ProcessingBatch Processing
Nosso próximo problema também lida com uma matriz que contém n células. Inicialmente, cada célula, exceto uma, é branca. Realizamos operações n - 1, cada uma das quais calcula primeiro a distância mínima de uma dada célula branca até uma célula preta e depois pinta a célula branca de preto.Por exemplo, considere a seguinte operação:
*
Batch ProcessingBatch Processing
Primeiro, calculamos a distância mínima da célula branca marcada com * até uma célula preta. A distância mínima é 2, porque podemos mover dois passos para uma célula preta. Então, pintamos a célula branca de preto:
Batch ProcessingBatch Processing
Combinamos os algoritmos acima dividindo as operações em lotes O(√n), cada um deles consistindo em operações O(√n). No início de cada lote, executamos o Algoritmo 1. Em seguida, usamos o Algoritmo 2 para processar as operações no lote. Limpamos a lista do Algoritmo 2 entre os lotes. Em cada operação, a distância mínima até uma célula preta é a distância calculada pelo Algoritmo 1 ou a distância calculada pelo Algoritmo 2.
Batch ProcessingBatch Processing
O algoritmo resultante funciona no tempo O(n√n). Primeiro, o Algoritmo 1 é executado O(√n) vezes, e cada pesquisa trabalha no tempo O(n). Segundo, ao usar o Algoritmo 2 em um lote, a lista contém células O(√n) (porque limpamos a lista entre os lotes) e cada operação toma o tempo O(√n).
Integer PartitionsInteger Partitions
Alguns algoritmos de raiz quadrada são baseados na seguinte observação: se um inteiro positivo n é representado como uma soma de números inteiros positivos, tal soma sempre contém no máximo O(n) números distintos. A razão para isso é que, para construir uma soma que contenha um número máximo de números distintos, devemos escolher números pequenos. Se escolhermos os números 1, 2, …, k, a soma resultante é
Assim, a quantidade máxima de números distintos é k = O(n). A seguir, discutiremos dois problemas que podem ser resolvidos eficientemente usando essa observação.
k (k+1)2 .
KnapsackKnapsack
Suponha que recebamos uma lista de pesos inteiros cuja soma é n. Nossa tarefa é descobrir todas as somas que podem ser formadas usando um subconjunto dos pesos. Por exemplo, se os pesos forem {1, 3, 3}, as somas possíveis serão as seguintes:
0 (conjunto vazio)131 + 3 = 43 + 3 = 61 + 3 + 3 = 7
KnapsackKnapsack
Usando a abordagem padrão de mochila, o problema pode ser resolvido da seguinte maneira: definimos uma função possible(x, k) cujo valor é 1 se a soma x puder ser formada usando as primeiras ponderações k e 0 caso contrário. Como a soma dos pesos é n, há no máximo n pesos e todos os valores da função podem ser calculados no tempo O(n2) usando a programação dinâmica.
KnapsackKnapsack
No entanto, podemos tornar o algoritmo mais eficiente usando o fato de que há no máximo O(√n) pesos distintos. Assim, podemos processar os pesos em grupos que consistem em pesos semelhantes. Podemos processar cada grupo no tempo O(n), o que gera um algoritmo de tempo O(n√n).
KnapsackKnapsack
A ideia é usar um vetor que registre as somas de pesos que podem ser formadas usando os grupos processados até o momento. O vetor contém n elementos: o elemento k é 1 se a soma k puder ser formada e 0 caso contrário. Para processar um grupo de pesos, varremos o vetor da esquerda para a direita e registramos as novas somas de pesos que podem ser formadas usando esse grupo e os grupos anteriores.
String ConstructionString Construction
Dada uma string s de comprimento n e um conjunto de strings D cujo comprimento total é m, considere o problema de contar o número de maneiras que s podem ser formadas como uma concatenação de strings em D. Por exemplo, se s = ABAB e D = {A, B, AB}, existem 4 maneiras:
A + B + A + BAB + A + BA + B + ABAB + AB
String ConstructionString Construction
Podemos resolver o problema usando programação dinâmica: Dado count(k) denota o número de maneiras de construir o prefixo s[0. . . k] usando as strings em D. Agora count(n - 1) dá a resposta para o problema, e podemos resolver o problema no tempo O(n2) usando uma estrutura em árvore.
String ConstructionString Construction
No entanto, podemos resolver o problema de forma mais eficiente usando hashing de string e o fato de que existem no máximo O(m) comprimentos de string distintos em D. Primeiro, construímos um conjunto H que contém todos os valores hash das strings em D. Então, quando calculamos um valor de count(k), passamos por todos os valores de p tal que existe uma string de comprimento p em D, calculamos o valor hash de s [k - p + 1 … k] e verifique se ele pertence a H. Uma vez que há no máximo O(m) comprimentos de cadeia distintos, isso resulta em um algoritmo cujo tempo de execução é O(n√m).
String ConstructionString Construction
No entanto, podemos resolver o problema de forma mais eficiente usando hashing de string e o fato de que existem no máximo O(√m) comprimentos de string distintos em D. Primeiro, construímos um conjunto H que contém todos os valores hash das strings em D. Então, quando calculamos um valor de count(k), passamos por todos os valores de p tal que existe uma string de comprimento p em D, calculamos o valor hash de s [k - p + 1 … k] e verifique se ele pertence a H. Uma vez que há no máximo O(√m) comprimentos de cadeia distintos, isso resulta em um algoritmo cujo tempo de execução é O(n√m).
Mo’s AlgorithmMo’s Algorithm
O algoritmo de Mo pode ser usado em muitos problemas que requerem consultas de intervalo de processamento em um vetor estático, ou seja, os valores do vetor não são alterados entre as consultas. Em cada consulta, nos é dado um intervalo [a, b], e devemos calcular um valor com base nos elementos do vetor entre as posições a e b. Como o vetor é estático, as consultas podem ser processadas em qualquer ordem e o algoritmo do Mo processa as consultas em uma ordem especial que garante que o algoritmo funcione de maneira eficiente.
Mo’s AlgorithmMo’s Algorithm
O algoritmo de Mo mantém um intervalo ativo do vetor e a resposta a uma consulta sobre o intervalo ativo é conhecida em cada momento. O algoritmo processa as consultas uma por uma e sempre move os pontos finais do intervalo ativo inserindo e removendo elementos. A complexidade de tempo do algoritmo é O(n√nf(n)) onde o vetor contém n elementos, existem n consultas e cada inserção e remoção de um elemento leva O(f(n)) tempo.
Mo’s AlgorithmMo’s Algorithm
O truque no algoritmo de Mo é a ordem em que as consultas são processadas: o vetor é dividido em blocos de elementos k = O(n) e uma consulta [a
1, b
1] é
processado antes de uma consulta [a2, b
2] se
⌊a1
k ⌋<⌊a2
k ⌋ ou
⌊a1
k ⌋=⌊a2
k ⌋ e b1<b2 .
Mo’s AlgorithmMo’s Algorithm
Assim, todas as consultas cujos pontos de extremidade à esquerda estão em um determinado bloco são processadas, uma após a outra, classificadas de acordo com seus pontos de extremidade corretos. Usando essa ordem, o algoritmo somente executa operações O(n√n), porque o terminal esquerdo move O(n) vezes O(√n) etapas e o terminal direito move O(√n) vezes O(n) etapas. Assim, ambos os pontos de extremidade movem um total de etapas O(n√n) durante o algoritmo.
ExampleExample
Como exemplo, considere um problema em que recebemos um conjunto de consultas, cada uma delas correspondendo a um intervalo em um vetor, e nossa tarefa é calcular para cada consulta o número de elementos distintos no intervalo.
No algoritmo de Mo, as consultas são sempre classificadas da mesma maneira, mas isso depende do problema de como a resposta à consulta é mantida. Nesse problema, podemos manter uma contagem do vetor em que count[x] indica o número de vezes que um elemento x ocorre no intervalo ativo.
ExampleExample
Quando passamos de uma consulta para outra, o intervalo ativo é alterado. Por exemplo, se o intervalo atual for
e o próximo alcance é
haverá três etapas: o ponto final esquerdo move um passo para a direita e o ponto final direito move dois passos para a direita.
4 2 5 4 2 4 3 3 4
4 2 5 4 2 4 3 3 4
ExampleExample
Após cada etapa, a contagem de matrizes precisa ser atualizada. Depois de adicionar um elemento x, aumentamos o valor de count[x] por 1, e se count[x] = 1 depois disso, aumentamos a resposta para a consulta em 1. Da mesma forma, depois de remover um elemento x, diminuímos o valor valor de count[x] por 1, e se count[x] = 0 depois disso, também diminuiremos a resposta para a consulta em 1.Nesse problema, o tempo necessário para executar cada etapa é O(1), portanto, a complexidade total do tempo do algoritmo é O(n√n).
RuleRule
Os alunos devem:Ler e descrever os problemas;Avaliar a solução e descrevê-la cada um dos problemas;Identificar as técnicas utilizadas e adicionar a cada problema;Apresentar as bibliografias referentes aos assuntos;Montar a conclusão do trabalho em cima do que foi realizado no documento;Colocar em anexo o código do problema. (obrigatório)
Deve usar os arquivos que estão na página do professor.
Data da Entrega: 01/06/2018 as 23:00hs
Group OneGroup One
URI 2169http://codeforces.com/contest/13/problem/E
Group TwoGroup Two
UVa 11235URI 1767
Group ThreeGroup Three
UVa 562URI 1286
Group FourGroup Four
UVa 990URI 1288
Group FiveGroup Five
UVa 1213URI 2026
Sites visitarSites visitar
top related