Mostrar que as consultas de soma de intervalo em uma matriz binária não podem ser feitas usando espaço linear e tempo constante

Você recebe uma matriz binária de tamanho . $n$

Quero mostrar que nenhum algoritmo pode fazer o seguinte (ou surpreender-se e descobrir que esses algoritmos existem afinal):

1) Pré-processe a matriz de entrada usando tempo ilimitado, mas apenas usando bits . $O(n)$

2) Responda às consultas em tempo constante, em que a consulta solicita o número de bits definidos entre o índice índice na matriz. $(x,y)$ $x$ $y$

Parece que o tempo constante por consulta não deve permitir que o algoritmo leia informações suficientes para calcular o número de bits definidos.

Como podemos provar que esse algoritmo não existe?

Uma pergunta mais geral seria,

dado que o algoritmo pode usar o espaço , qual limite inferior no tempo de consulta podemos derivar? $f(n)$

Obviamente, se tivermos espaço , podemos armazenar todas as somas parciais e responder a consultas em , mas e se for menor? $f=\Omega(n\log n)$ $O(1)$ $f$

Você pode assumir que o tamanho de uma palavra na memória é e podemos ler os índices em tempo constante. $\Theta(\log n)$ $x,y$

ds.algorithms lower-bounds it.information-theory

— RB
fonte

@ EmilJeřábek - Eu quero que o algoritmo use

bits (linear no tamanho da entrada), não

palavras de memória. Isso faz sentido?

O (n)

$O(n)$

O (n)

$O(n)$

— RB

Entendo, obrigado pelo esclarecimento. Agora, outra pergunta: quais operações você pode fazer em tempo constante com palavras de memória? Aqui está um algoritmo candidato: divida a matriz em blocos de tamanho

e, para cada bloco

, armazene o conteúdo de

como uma palavra e a contagem de bits definidos antes de

como outra palavra. Isso cria

bits. Cada consulta pode ser respondida examinando quatro palavras e pode ser calculada usando operações

nessas palavras, como turnos, subtração e (mais importante) contagem de população. Seu modelo permite isso?

(\log n)

$(\log n)$

b

$b$

b

$b$

b

$b$

O (n)

$O(n)$

O (1)

$O(1)$

— Emil Jeřábek

@ EmilJeřábek - Eu tinha apenas operações aritméticas, indexação e pesquisas de bits (ou seja, procurando um pouco específico de uma palavra) em mente. Operações padrão de bits, como turnos, também podem ser consideradas. Concordo que, se pudermos contar o número de bits definidos em

, seu algoritmo realmente resolverá o problema.

O (1)

$O(1)$

— RB

O problema vem de um algoritmo que estamos construindo para consultas de soma de intervalos em janelas deslizantes. Ou seja, temos um fluxo de números inteiros, cada um em

e desejamos aproximar a soma de um determinado intervalo. Nosso problema se reduz à contagem exata de intervalos em uma matriz binária (muito menor) (que também `` desliza ''). Para uma janela deslizante binária de tamanho

, usamos

bits, adicionamos um bit no tempo constante amortizado e realizamos consultas em

. Eu queria saber se as consultas de tempo constante são viáveis, mesmo que a matriz não seja atualizada.

0, 1, \dots, R

${0,1,\ldots, R}$

n

$n$

O (n)

$O(n)$

O (\log n)

$O(\log n)$

— RB

O (n)

$O(n)$

Respostas:

Acredito que o que você está procurando é uma estrutura de dados compacta que suporte a operação de classificação. Vejo...

https://en.m.wikipedia.org/wiki/Succinct_data_structure

Especificamente, você pode modificar a solução Emils (primeira) para remover a operação de contagem pop e substituí-la por uma tabela de pesquisa (para obter detalhes, consulte o artigo da wiki). Ao reduzir o tamanho de um bloco para (log n) / 2 bits, a tabela de pesquisa usa o (n) bits.

— Benjamin Sach
fonte

(* facepalm *) Tabela de pesquisa, obviamente. Por que eu não pensei nisso.

— Emil Jeřábek

Em vista do comentário do OP acima, é importante notar que a estrutura pode ser facilmente implementada como uma janela deslizante, de modo que mover a janela um bit (ou mesmo bloco) também leva tempo constante.

— Emil Jeřábek

@ EmilJeřábek - traduzir sua solução para a janela deslizante não é fácil. Em vez de contar o número de bits definidos em toda a parte da matriz que precede o bloco atual, precisamos contar o número de bits definidos na janela deslizante que precede esse bloco, o que não parece factível em tempo constante. Estou faltando alguma coisa?

— RB

x

$x$

y

$y$

n

$n$

$\log n$ $\log_2n$ $\log^{(k)}n$ $\mathop{\underbrace{\log\dots\log}_{k\text{ times}}}n$ $\log^*n$ $\tilde O(t(n))$ $O(t(n)\operatorname{polylog}(t(n)))$

Proposição: Existem algoritmos que alcançam

$O(n\log^{(k)}n)$ $O(1)$ $k$

$O(n)$ $\tilde O(\log^*n)$

$k>0$ $n=b_0>b_1>\dots>b_k>0$ $n$ $b_0$ $b_1$ $b_2$ $k$ $b_i$ $2$

$i=1,\dots,k$ $i$ $(i-1)$
$k$ $k$ $x$ $y$

$b_i$

n \sum_{i = 1}^{k} \frac{\log b_{i - 1}}{b_{i}},

$n\sum_{i=1}^k\frac{\log b_{i-1}}{b_i},$

O (k + b_{k}) .

$O(k+b_k).$

$k$ $b_i=\log^{(i)}n$ $0<i<k$ $b_k=1$

$k=\log^*n$

b_{i} = i (\log i)^{3} \log^{(i)} n .

$b_i=i(\log i)^3\log^{(i)}n.$

n \sum_{i = 1}^{k} \frac{\log^{(i)} n + 2 \log i}{i (\log i)^{3} \log^{(i)} n} \leq n \sum_{i = 1}^{\infty} \frac{3}{i (\log i)^{2}} = c n

$n\sum_{i=1}^k\frac{\log^{(i)}n+2\log i}{i(\log i)^3\log^{(i)}n}\le n\sum_{i=1}^\infty\frac{3}{i(\log i)^2}=cn$

c

$c$

— Emil Jeřábek
fonte

$O(n)$ $n\cdot(1+o(1))$

$n$ $\{1,2,\ldots,n\}$ $i'th$ $i$

— RB
fonte