La complejidad de bits de la consulta de rango de tiempo O (1) en

Considere el siguiente problema:

Deje ser una constante. Se nos da una matriz -ary de y 's. Deje . $k$ $k$ $A_{d_1\times\ldots\times d_k}$ $0$ $1$ $N = \prod_{i=1}^k d_i$

Queremos crear una estructura de datos preprocesando para realizar el siguiente tipo de operaciones de consulta: $A$

Dadas las coordenadas de un -ary caja , ¿hay un en la caja? $k$ $D$ $1$
Dadas las coordenadas de un cuadro -ary , devuelve la posición de un en el cuadro (si hay uno). $k$ $D$ $1$

Las operaciones deben realizarse en tiempo constante . La complejidad del tiempo se mide en una máquina RAM. El tiempo y el espacio de preprocesamiento para la estructura de datos no son importantes para nosotros. $O(1)$

La pregunta es ¿cuánto espacio (en complejidad de bits) necesitamos para almacenar una estructura de datos que permita las operaciones anteriores?

El límite inferior trivial es bits, ya que la matriz se puede reconstruir para estas consultas (por lo que la estructura de datos debe tener al menos la misma cantidad de información). $N$

El límite superior trivial es almacenar la respuesta a todas las consultas. Eso necesitaría $\prod_{i=1}^k {d_i \choose 2} = \Theta(N^2)$ bits. Sin embargo, sospechamos que esto se puede hacer de manera mucho más eficiente.

Por ejemplo, considere el caso especial donde $k=1$ . En este caso, podemos usar una estructura de datos RMQ sucinta para resolver el primer problema, y la estructura de datos requiere $2N+o(N)$ bits para almacenar.

¿Cuál es una estructura de datos eficiente para esta tarea?
¿Qué tan bajo puede ser la complejidad del espacio (el número de bits) para soportar estas operaciones (o solo la primera operación)?

Actualización (1/15): en el caso especial , usar bits es suficiente (en realidad mejor, , donde es el número de 's en ) reduciendo el problema a un problema predecesor y utilizando la reducción del problema predecesor a un diccionario completamente indexable (FID). Consulte " Más prisa, menos desperdicio: reducir la redundancia en diccionarios completamente indexables " por Grossi, Orlandi, Raman y Rao (2009). $k=1$ $N +o(N)$ $\log {N\choose t}+O(t)$ $t$ $1$ $A$

Actualización (27/06): Nuevamente, reduzca el problema a RMQ. Utilizamos un RMQ dimensional de Yuan y Atallah para obtener un límite superior en la cantidad de espacio requerido cuando es fijo. $k$ $O(n\log n)$ $k$

reference-request data-structures space-complexity

— Chao Xu
fuente

La pregunta no está clara: ¿es una pregunta de estructura de datos? Si es así, ¿cuáles son las otras operaciones en esta matriz kD? Si no hay otra operación, entonces no hay 1 en ella. Si la pregunta es que se nos da una matriz kD y qué hacer un preprocesamiento en ella y luego almacenarla de manera que usemos poca cantidad de memoria pero podamos realizar esta operación de verificación en peor de los casos, entonces aclare eso. También explique cuál es el modelo de cálculo si desea un límite inferior.

O (1)

$O(1)$

— Kaveh

citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.72.5421

— Kaveh

IIUC, el documento dice que la respuesta para 1D es realmente bits y la idea es almacenar todas las cajas pequeñas más todas las cajas con longitudes de potencia 2 y otras cajas se pueden obtener de len pow-2 cajas en constante tiempo ( ) y me parece que lo mismo funcionaría aquí y los bits serán suficientes.

O (n \lg n)

$O(n\lg n)$

O (2^{k})

$O(2^k)$

O (n^{k} \lg^{k} n)

$O(n^k\lg^k n)$

— Kaveh

Gracias, he agregado algunas aclaraciones. ¿El periódico no dijo que su contribución principal es usar bits tanto en preprocesamiento como en almacenamiento?

2 n + o (n)

$2n+o(n)$

— Chao Xu

Lo siento, el que describí fue de un trabajo anterior. Sin embargo, su resultado parece ser conceptualmente similar, es decir, dividen la matriz en bloques, calculan previamente la respuesta en ellos y usan un número constante de ellos para calcular la respuesta para cualquiera. Si en kD el número de bloques base que uno necesita para calcular la respuesta a un bloque arbitrario es una constante, entonces un algoritmo similar funcionaría aquí y probablemente daría algo como (no tengo ' t verifique que este sea el caso).

O (n^{k}) = O (N)

$O(n^k) = O(N)$

— Kaveh

Puede ahorrar mucho más en memoria si solo permite la complejidad del tiempo logarítmico. Puede implementar un árbol de segmentos kD que necesitará una memoria N * 2 ^ k bits, y se ejecuta en complejidad de tiempo logarítmica para ambas subtareas y complejidad de tiempo lineal para construir el árbol.

Si quiere estrictamente O (1), precalcule todo.

— Bojan Serafimov
fuente

¿Puedes describir cómo se construye el árbol en tiempo logarítmico?

— Raphael

lo siento, está construido en tiempo lineal

— Bojan Serafimov

@BojanSerafimov Debería actualizar la respuesta y luego :) Es posible que se eliminen los comentarios.

— Juho

Creo que esta puede ser una buena respuesta, si solo la editó para que sea correcta y tal vez un poco más elaborada sobre cómo son estos árboles y cómo los construye.

— Raphael