CIC 110 Análise e Projeto de Algoritmos I

Transcrição

1 CIC 110 Análise e Projeto de Algoritmos I Prof. Roberto Affonso da Costa Junior Universidade Federal de Itajubá

2 AULA 09 Consultas de Intervalo

3 Consulta de Intervalo Neste capítulo, discutimos estruturas de dados que nos permitem processar eficientemente consultas de alcance. Em uma consulta de intervalo, nossa tarefa é calcular um valor com base em um subarray de um vetor. As consultas de alcance típico são: sum q (a, b): calcula a soma dos valores no intervalo [a, b]; min q (a, b): encontre o valor mínimo no intervalo [a, b] max q (a, b): encontre o valor máximo no intervalo [a, b] Por exemplo, considere o intervalo [3, 6] no seguinte vetor:

4 Consulta de Intervalo Neste caso, soma q(3, 6) = 14, min q(3, 6) = 1 e max q(3, 6) = 6. Uma maneira simples de processar consultas de intervalo é usar um loop que passa por todos os valores do vetor no intervalo. Por exemplo, a seguinte função pode ser usada para processar consultas de soma em um vetor: int sum(int a, int b) { int s = 0; for (int i = a; i <= b; i++) { s += A[i]; return s;

5 Consulta de Intervalo Esta função funciona no tempo O(n), onde n é o tamanho do vetor. Assim, podemos processar q consultas no tempo O(nq) usando a função. No entanto, se ambos n e q são grandes, essa abordagem é lenta. Felizmente, verifica-se que existem maneiras de processar consultas de alcance muito mais eficientemente.

6 Consultas de vetor estático Primeiro nos concentramos em uma situação em que o vetor é estático, ou seja, os valores do vetor nunca são atualizados entre as consultas. Neste caso, basta construir uma estrutura de dados estática que nos diga a resposta para qualquer consulta possível.

7 Soma de Intervalo Podemos processar facilmente consultas de soma em um vetor estático construindo um vetor de soma de prefixo. Cada valor no vetor de soma de prefixo é igual a soma dos valores no vetor original até essa posição, isto é, o valor na posição k é soma q(0, k). O vetor de soma de prefixo pode ser construído em tempo de O(n). Por exemplo, considere a seguinte vetor: O vetor de soma de prefixo correspondente é o seguinte:

8 Soma de Intervalo Uma vez que o vetor da soma do prefixo contém todos os valores da soma q(0, k), podemos calcular qualquer valor da soma q(a, b) no tempo O(1) da seguinte maneira: sum q ( a, b ) = sum q (0, b ) sum q (0, a 1) Ao definir a soma q(0, -1) = 0, a fórmula acima também se mantém quando a = 0. Por exemplo, considere o intervalo [3, 6]:

9 Soma de Intervalo Neste caso, soma q(3, 6) = = 15. Esta soma pode ser calculada a partir de dois valores do vetor de som de prefixo: Assim, sum q (3, 6) = sum q (0, 6) sum q (0, 2) = = 15. Também é possível generalizar essa ideia para maiores dimensões. Por exemplo, podemos construir uma matriz de soma de prefixo bidimensional que pode ser usada para calcular a soma de qualquer subarray retangular em tempo de O(1). Cada soma dessa matriz corresponde a um subarray que começa no canto superior esquerdo da matriz.

10 Soma de Intervalo A seguinte imagem ilustra a ideia: D C B A A soma da submatriz pode ser calculada usando a fórmula: S ( A ) S ( B ) S ( C ) + S ( D ), aqui S (X) denota a soma de valores em um subarray retangular do canto superior esquerdo para a posição de X.

11 Programa de Soma de Intervalo Normal: #include <bits/stdc++.h> #define lli long long using namespace std; vector <lli> A; lli sum(int a, int b) { lli s = 0; for (int i = a; i <= b; i++) { s += A[i]; return s; int main() { int n, a, b; lli X; scanf("%d %d %d", &n, &a, &b); for (int i = 0; i < n; i++) { scanf("%lld", &X); A.push_back(X); X = sum(a,b);

12 Programa de Soma de Intervalo Normal: for (int i = a; i <= b; i++) { if (i < b) { printf("%lld + ", A[i]); else { printf("%lld = %lld\n", A[i], X); return 0;

13 Programa de Soma de Intervalo PD: #include <bits/stdc++.h> #define lli long long using namespace std; vector <lli> A, S; void sum(int a, int b) { lli s = 0; for (int i = a; i <= b; i++) { s += A[i]; S.push_back(s); int main() { int n, a, b; lli X; scanf("%d %d %d", &n, &a, &b); for (int i = 0; i < n; i++) { scanf("%lld", &X); A.push_back(X); sum(0,7); X = S[a-1] + S[b];

14 Programa de Soma de Intervalo PD: for (int i = a; i <= b; i++) { if (i < b) { printf("%lld + ", A[i]); else { printf("%lld = %lld\n", A[i], X); return 0;

15 Menor valor em um intervalo A consulta de menor valor em um intervalo é mais difícil de processar do que as da soma. Ainda assim, existe um método de pré-processamento de tempo O(n log n) bastante simples, após o qual podemos responder qualquer consulta de menor valor em um intervalo em tempo O(1). Observe que, que a consulta de menor valor e/ou de maior valor em um intervalo podem ser processadas de forma semelhante, podemos fazer a consulta de menor valor em um intervalo pois será a mesma coisa para o maior valor. A ideia é precalcular todos os valores de min q (a, b) onde b - a + 1 (o comprimento do alcance) é uma potência de dois.

16 Menor valor em um intervalo Menor valor em um intervalo Por exemplo, para o vetor: os seguintes valores são calculados: a b min q (a,b) a b min q (a,b) a b min q (a,b)

17 Menor valor em um intervalo O número de valores precalculados é O(n log n), porque existem comprimentos de intervalo O(log n) que são potência de dois. Os valores podem ser calculados eficientemente usando a fórmula recursiva min q (a, b) = min( min q (a, a + w 1), min q (a + w, b)), onde b a + 1 é uma potência de dois e w = (b a + 1) / 2. O cálculo de todos esses valores leva o tempo O(n log n).

18 Menor valor em um intervalo Depois disso, qualquer valor de min q (a, b) pode ser calculado em tempo O(1) como menor valor de um intervalo precalculados. Seja k a maior potência de dois que não exceda b a + 1. Podemos calcular o valor de min q (a, b) usando a fórmula: min q (a, b) = min( min q (a, a + k 1), min q (b k + 1, b)). Na fórmula acima, o intervalo [a, b] é representado como a união dos intervalos [a, a + k 1] e [b k + 1, b], ambos de comprimento k.

19 Menor valor em um intervalo Como exemplo, considere o intervalo [1, 6]: O comprimento do intervalo é 6 e a maior potência de dois que não exceda 6 é 4. Assim, o intervalo [1, 6] é a união das faixas [1, 4] e [3, 6]: Uma vez que min q (1, 4) = 3 e min q (3, 6) = 1, concluímos que min q (1, 6) = 1.

20 Programa do Menor valor em um intervalo #include <bits/stdc++.h> #define lli long long using namespace std; vector <lli> A; lli MAX = LL; lli menor(int a, int b) { lli s = MAX; for (int i = a; i <= b; i++) { if (s > A[i]) { s = A[i]; return s;

21 Programa do Menor valor em um intervalo int main() { int n, a, b; lli X; scanf("%d %d %d", &n, &a, &b); for (int i = 0; i < n; i++) { scanf("%lld", &X); A.push_back(X); X = menor(a,b); for (int i = a; i <= b; i++) { if (i < b) { printf("%lld, ", A[i]); else { printf("%lld = %lld\n", A[i], X); return 0;

22 Árvore indexada binária Uma árvore indexada binária ou uma árvore Fenwick pode ser vista como uma variação dinâmica de um vetor soma de prefixo. Ela suporta duas operações de tempo O(log n) em um vetor: processando uma consulta de soma de intervalo e atualizando um valor. A vantagem de uma árvore indexada binária é que nos permite atualizar de forma eficiente os valores do vetor entre as consultas da soma. Isso não seria possível usando um vetor soma de prefixo, porque depois de cada atualização, seria necessário criar um vetor soma de prefixo inteiro novamente no tempo O(n). A estrutura de árvore indexada binária foi apresentada por P. M. Fenwick em 1994.

23 Estrutura Mesmo que o nome da estrutura seja uma árvore indexada em binário, geralmente é representado como um vetor. Nesta seção, adotamos que todos os vetores são indexados, porque facilita a implementação. Dado p(k) que denota a maior potência de dois que divide k. Nós armazenamos uma árvore indexada binária como uma árvore de vetor, tal que tree [ k ] = sum q ( k p ( k ) + 1, k ),

24 Estrutura isto é, cada posição k contém a soma de valores em um intervalo do vetor original cujo comprimento é p(k) e que termina na posição k. Por exemplo, uma vez que p(6) = 2, a árvore [6] contém o valor da sum q (5, 6). Por exemplo, considere o seguinte vetor: A árvore indexada binária correspondente é a seguinte:

25 Estrutura A seguinte imagem mostra mais claramente como cada valor na árvore indexada binária corresponde a um intervalo na matriz original:

26 Estrutura Usando uma árvore indexada binária, qualquer valor da sum q (1, k) pode ser calculado no tempo O(log n), porque um intervalo [1, k] sempre pode ser dividido em intervalos O(log n) cujas somas são armazenadas na árvore. Por exemplo, o intervalo [1, 7] consiste nos seguintes intervalos:

27 Estrutura

28 Estrutura Assim, podemos calcular a soma correspondente da seguinte forma: sum q (1, 7) = sum q (1, 4) + sum q (5, 6) + sum q (7, 7) = = 27 Para calcular o valor da sum q (a, b) onde a > 1, podemos usar o mesmo truque que usamos com os vetores de soma de prefixo: sum q (a, b) = sum q (1, b) sum q (1, a 1).

29 Estrutura Uma vez que podemos calcular a sum q (1, b) e a sum q (1, a - 1) no tempo O(log n), a complexidade do tempo total é O(log n). Então, após atualizar um valor no vetor original, vários valores na árvore indexada binária devem ser atualizados. Por exemplo, se o valor na posição 3 mudar, as somas dos seguintes intervalos mudam:

30 Estrutura Uma vez que cada elemento do vetor pertence aos intervalos O(log n) na árvore indexada binária, basta atualizar os valores de O(log n) na árvore.

31 Implementação As operações de uma árvore indexada binária podem ser implementadas de forma eficiente usando operações de bits. O fato fundamental é que podemos calcular qualquer valor de p(k) usando a fórmula: A seguinte função calcula o valor da sum q (1, k): p(k) = k & k. int sumq(int k) { int s = 0; while (k >= 1) { s += tree[k]; k -= k&-k; return s;

32 Implementação A seguinte função aumenta o valor do vetor na posição k por x (x pode ser positivo ou negativo): void add(int k, int x) { while (k <= n) { tree[k] += x; k += k&-k; A complexidade do tempo de ambas as funções é O(log n), porque as funções acessam valores de O(log n) na árvore indexada binária e cada movimento para a próxima posição leva tempo O(1).

33 Árvore de segmentação Uma árvore de segmentação é uma estrutura de dados que suporta duas operações: processando uma consulta de intervalo e atualizando um valor no vetor. As árvores de segmentação podem suportar consultas de soma, consultas mínimas e máximas e muitas outras consultas para que ambas as operações funcionem em tempo de O(log n). Comparado com uma árvore indexada binária, a vantagem de uma árvore de segmentação é que é uma estrutura de dados mais geral. Enquanto as árvores indexadas binárias apenas suportam consultas de soma, as árvores de segmentação também oferecem suporte a outras consultas. Por outro lado, uma árvore de segmentação requer mais memória e é um pouco mais difícil de implementar.

34 Estrutura Uma árvore de segmentação é uma árvore binária, de modo que os nós no nível inferior da árvore correspondem aos elementos do vetor e os outros nós contêm informações necessárias para processar consultas de alcance. Nesta seção, assumimos que o tamanho do vetor é uma potência de dois e a indexação baseada em zero é usada, porque é conveniente criar uma árvore de segmento para esse vetor. Se o tamanho do vetor não for uma potência de dois, sempre podemos acrescentar elementos extras ao vetor.

35 Estrutura Em primeiro lugar, discutiremos árvores de segmentação que suportem consultas da soma. Como exemplo, considere o seguinte vetor: A árvore de segmentação correspondente é a seguinte:

36 Estrutura Cada nó de árvore interno corresponde a uma pedaço do vetor cujo tamanho é uma potência de dois. Na árvore anterior, o valor de cada nó interno é a soma dos valores do vetor correspondentes e pode ser calculado como a soma dos valores de seu nó filho esquerdo e direito. Acontece que qualquer intervalo [a, b] pode ser dividido em intervalos O(log n) cuja os valores são armazenados em nós da árvore. Por exemplo, considere o intervalo [2,7]:

37 Estrutura Aqui, sum q (2, 7) = = 26. Neste caso, os dois nós de árvore a seguir correspondem ao intervalo: Assim, outra maneira de calcular a soma é = 26.

38 Estrutura Quando a soma é calculada usando nós posicionados o mais alto possível na árvore, são necessárias no máximo dois nós em cada nível da árvore. Portanto, o número total de nós é O(log n). Após uma atualização do vetor, devemos atualizar todos os nós cujo valor depende do valor atualizado. Isso pode ser feito atravessando o caminho do elemento do vetor atualizado para o nó superior e atualizando os nós ao longo do caminho.

39 Estrutura A seguinte imagem mostra quais os nós da árvore mudam se o valor da matriz 7 mudar: O caminho de baixo para cima sempre consiste de nós O(log n), portanto, cada atualização altera nós O(log n) na árvore.

40 Implementação Nós armazenamos uma árvore de segmento como um vetor de 2n elementos onde n é o tamanho do vetor original e uma potência de dois. Os nós de árvore são armazenados de cima para baixo: árvore [1] é o nó superior, árvore [2] e árvore [3] são seus filhos, e assim por diante. Finalmente, os valores da árvore [n] para a árvore [2n - 1] correspondem aos valores do vetor original no nível inferior da árvore.

41 Implementação Por exemplo, a árvore de segmentação: Cada nó de árvore interno corresponde a uma gama de matriz cujo tamanho é uma potência de dois. Na árvore acima, o valor de cada nó interno é a soma dos valores do vetor correspondentes e pode ser calculado como a soma dos valores de seu nó filho esquerdo e direito.

42 Implementação está armazenado da seguinte forma: Usando esta representação, o pai da árvore [k] é árvore [ k /2 ], e seus filhos são árvore [2k] e árvore [2k + 1]. Note que isso implica que a posição de um nó é o mesmo que seja um filho esquerdo e diferente se for um filho direito.

43 Implementação A seguinte função calcula o valor da sum q (a, b): int sumq(int a, int b) { a += n; b += n; int s = 0; while (a <= b) { if (a%2 == 1) s += tree[a++]; if (b%2 == 0) s += tree[b--]; a /= 2; b /= 2; return s;

44 Implementação A função mantém um intervalo inicialmente [a + n, b + n]. Então, em cada etapa, o intervalo é movido um nível mais alto na árvore, e antes disso, os valores dos nós que não pertencem ao intervalo mais alto são adicionados à soma. A seguinte função aumenta o valor da matriz na posição k por x: void add(int k, int x) { k += n; tree[k] += x; for (k /= 2; k >= 1; k /= 2) { tree[k] = tree[2*k]+tree[2*k+1];

45 Implementação Primeiro, a função atualiza o valor no nível inferior da árvore. Depois disso, a função atualiza os valores de todos os nós de árvore internos, até chegar ao nó superior da árvore. Ambas as funções acima funcionam no tempo O(log n), uma vez que uma árvore de segmentos de n elementos consiste em níveis de O(log n), e as funções se movem um nível mais alto na árvore em cada etapa.

46 Outras consultas As árvores de segmentação podem suportar todas as consultas de intervalo onde é possível dividir um intervalo em duas partes, calcular a resposta separadamente para ambas as partes e, em seguida, combinar as respostas com eficiência. Exemplos de tais consultas são mínimas e máximas, o maior divisor comum, e operações de bits e, ou e xor.

47 Outras consultas Por exemplo, a seguinte árvore de segmentação suporta consultas mínimas:

48 Outras consultas Nesse caso, cada nó da árvore contém o menor valor no intervalo do vetor correspondente. O nó superior da árvore contém o menor valor em todo o vetor. As operações podem ser implementadas como anteriormente, mas em vez das somas, os mínimos são calculados. A estrutura de uma árvore de segmentação também nos permite usar a pesquisa binária para localizar elementos do vetor. Por exemplo, se a árvore suportar consultas mínimas, podemos encontrar a posição de um elemento com o menor valor no tempo O(log n).

49 Outras consultas Por exemplo, na árvore acima, um elemento com o menor valor 1 pode ser encontrado atravessando um caminho para baixo do nó superior:

50 Técnicas adicionais Compressão do índice Uma limitação nas estruturas de dados que são construídas sobre um vetor é que os elementos são indexados usando números inteiros consecutivos. Dificuldades surgem quando são necessários um tamanho maior dos índices. Por exemplo, se desejarmos usar o índice 10 9, o vetor deve conter 10 9 elementos que exigiriam muita memória. No entanto, muitas vezes podemos ignorar essa limitação usando a compressão de índice, onde os índices originais são substituídos pelos índices 1, 2, 3, etc. Isso pode ser feito se conhecermos todos os índices necessários antes do algoritmo.

51 Técnicas adicionais A ideia é substituir cada índice original x por c(x) onde c é uma função que comprime os índices. Exigimos que a ordem dos índices não mude, então se a < b, então c(a) < c(b). Isso nos permite realizar consultas conveniente, mesmo que os índices sejam compactados. Por exemplo, se os índices originais são 555, 10 9 e 8, os novos índices são: c(8) = 1 c(555) = 2 c(10 9 ) = 3

52 Atualizações de intervalo Até agora, implementamos estruturas de dados que suportam consultas de alcance e atualizações de valores únicos. Consideremos agora uma situação oposta, onde devemos atualizar os intervalos e recuperar valores únicos. Nós nos concentramos em uma operação que aumenta todos os elementos em um intervalo [a, b] por x. Surpreendentemente, podemos usar as estruturas de dados apresentadas neste capítulo também nesta situação. Para fazer isso, nós criamos um vetor de diferenças cujos valores indicam as diferenças entre valores consecutivos no vetor original. Assim, o vetor original é o vetor de fontes de prefixo do vetor de diferenças. Por exemplo, considere a seguinte vetor:

53 Atualizações de intervalo O vetor de diferenças para o vetor acima é o seguinte: Por exemplo, o valor 2 na posição 6 na matriz original corresponde à soma = 2 na matriz de diferenças.

54 Atualizações de intervalo A vantagem do vetor de diferenças é que podemos atualizar um intervalo no vetor original alterando apenas dois elementos no vetor de diferenças. Por exemplo, se quisermos aumentar os valores do vetor original entre as posições 1 e 4 por 5, basta aumentar o valor do vetor de diferença na posição 1 em 5 e diminuir o valor na posição 5 em 5. O resultado é o seguinte:

55 Atualizações de intervalo De forma mais geral, para aumentar os valores no alcance [a, b] por x, aumentamos o valor na posição a por x e diminuímos o valor na posição b + 1 por x. Assim, só é necessário atualizar valores únicos e processar consultas de soma, para que possamos usar uma árvore indexada binária ou uma árvore de segmentação. Um problema mais difícil é suportar tanto as consultas de alcance quanto as atualizações de alcance. Veremos na próxima disciplina de CIC 111.

56 Exercício Você pode fazer eles no no codepit.io CIC senha: unifei