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