Estructura de datos para el mapa en intervalos

Sea $n$ un número entero y $\mathbb{Z}$ denote el conjunto de todos los enteros. Supongamos que $[a,b]$ denota el intervalo de enteros $\{a,a+1,a+2,\dots,b\}$ .

Busco a una estructura de datos para representar un mapa $f:[1,n] \to \mathbb{Z}$ . Quiero que la estructura de datos admita las siguientes operaciones:

$\text{get}(i)$ debería devolver $f(i)$ .
$\text{set}([a,b],y)$ debe actualizar $f$ modo que $f(a)=f(a+1)=\cdots=f(b)=y$ , es decir, actualice $f$ a un nuevo mapa $f'$ tal que $f'(i) = y$ para $i \in [a,b]$ y $f'(i) = f(i)$ para $i \notin [a,b]$ .
debería devolver el intervalo más grande tal que y es constante en (es decir, ). $\text{stab}(i)$ $[a,b]$ $i \in [a,b]$ $f$ $[a,b]$ $f(a)=f(a+1)=\cdots=f(b)$
$\text{add}([a,b],\delta)$ debería actualizar $f$ a un nuevo mapa $f'$ modo que $f'(i) = f(i) + \delta$ para $i \in [a,b]$ y $f'(i) = f(i)$ para $i \notin [a,b]$ .

Quiero que cada una de estas operaciones sea eficiente. Contaría el tiempo $O(1)$ u $O(\lg n)$ como eficiente, pero el tiempo $O(n)$ es demasiado lento. Está bien si los tiempos de ejecución son tiempos de ejecución amortizados. ¿Existe una estructura de datos que simultáneamente hace que todas estas operaciones sean eficientes?

(He notado que surge un patrón similar en varios desafíos de programación. Esta es una generalización que sería suficiente para todos esos problemas de desafío).

— DW
fuente

Supongo que los árboles separados son el punto de partida. addSin embargo, sería lineal en el número de subintervalos de

; ¿Has pensado en un árbol de despliegue con nodos adicionales "

" unitarios, compactados perezosamente?

[a, b]

$[a,b]$

+ δ

$+\delta$

— Gilles 'SO- deja de ser malvado'

Considere

tal que

para todo

. Entonces tienes que tener

valores almacenados en alguna parte. Realizar el

tiene que deshacerse de esos valores de alguna manera (reescribiéndolos o tirándolos a la basura; puede posponerlos con GC, pero tendrá que hacer operaciones

en algún momento) . Como tal, la operación será

f

$f$

f (i) \neq f (j)

$f(i)\neq f(j)$

i

$i$

j

$j$

n

$n$

set ([a, b], y)

$\text{set}([a,b],y)$

O (n)

$O(n)$

O (n)

$O(n)$

— avakar

@avakar, estaría contento con una solución que trata a GC como efectivamente "gratis". En términos más generales, estaría contento con una solución en la que los tiempos de ejecución se amortizan (por lo tanto, el costo de GC se puede amortizar en el costo de crear el valor en primer lugar).

— DW

Usted notó que el tiempo constante y logarítmico es eficiente, y el tiempo lineal es lento. ¿

tiempo es demasiado lento para sus necesidades?

O (\sqrt{n} \lg n)

$O(\sqrt{n} \lg n)$

— jbapple

@jbapple, oye, ¡es un comienzo! Creo que vale la pena documentarlo como respuesta.

— DW

Creo que el tiempo logarítmico para todas las consultas es alcanzable. La idea principal es usar un árbol de intervalos, donde cada nodo en el árbol corresponde a un intervalo de índices. Desarrollaré las ideas clave comenzando con una versión más simple de la estructura de datos (que puede admitir get y set pero no las otras operaciones), luego agregaré características para admitir también las otras características.

Un esquema simple (admite get y set, pero no agrega ni apuñala)

Digamos que un intervalo es plano si la función es constante en , es decir, si . $[a,b]$ $f$ $[a,b]$ $f(a)=f(a+1)=\cdots =f(b)$

Nuestra estructura de datos simple será un árbol de intervalos. En otras palabras, tenemos un árbol binario, donde cada nodo corresponde a un intervalo (de índices). Almacenaremos el intervalo correspondiente en cada nodo del árbol. Cada hoja corresponderá a un intervalo plano, y se organizarán de modo que leer las hojas de izquierda a derecha nos dé una secuencia de intervalos planos consecutivos que son disjuntos y cuya unión es toda . El intervalo para un nodo interno será la unión de los intervalos de sus dos hijos. Además, en cada nodo hoja almacenaremos el valor $I(v)$ $v$ $[1,n]$ $\ell$ $V(\ell)$ de la función en el intervalo correspondiente a este nodo (tenga en cuenta que este intervalo es plano, por lo que es constante en el intervalo, por lo que solo almacenamos un único valor de en cada nodo hoja). $f$ $I(\ell)$ $f$ $f$

De manera equivalente, puede imaginar que dividimos en intervalos planos, y luego la estructura de datos es un árbol de búsqueda binario donde las claves son los puntos finales izquierdos de esos intervalos. Las hojas contienen el valor de en algún rango de índices donde es constante. $[1,n]$ $f$ $f$

Utilice métodos estándar para garantizar que el árbol binario permanezca equilibrado, es decir, su profundidad sea (donde cuenta el número actual de hojas en el árbol). Por supuesto, , por lo que la profundidad es siempre como máximo . Esto será útil a continuación. $O(\lg m)$ $m$ $m\le n$ $O(\lg n)$

Ahora podemos soportar las operaciones get y set de la siguiente manera:

$\text{get}(i)$ $i$ $O(\lg n)$ $O(\lg n)$
$\text{set}([a,b],y)$
1. $[a_0,b_0]$ $a$ $a_0 < a$ $[a_0,a-1]$ $[a,b_0]$
2. $[a_1,b_1]$ $b$ $b < b_1$ $[a_1,b]$ $[b+1,b_1]$
3. $[a,b]$ $O(\lg n)$ $O(\lg n)$ $y$
4. Finalmente, dado que modificamos la forma del árbol, realizaremos las rotaciones necesarias para reequilibrar el árbol (utilizando cualquier técnica estándar para mantener un árbol equilibrado).
$O(\lg n)$ $O(\lg n)$ $O(\lg n)$

$O(\lg n)$ $O(\lg \min(n,s))$ $s$

Agregar soporte para agregar

Podemos modificar la estructura de datos anterior para que también pueda admitir la operación de agregar. En particular, en lugar de almacenar el valor de la función en las hojas, se representará como la suma de los números almacenados en un conjunto de nodos.

Más precisamente, el valor de la función en la entrada será recuperable como la suma de los valores almacenados en los nodos en la ruta desde la raíz del árbol hasta la hoja cuyo intervalo contiene . En cada nodo almacenaremos un valor ; si representan los antepasados de una hoja (incluida la hoja misma), entonces el valor de la función en será . $f(i)$ $i$ $i$ $v$ $V(v)$ $v_0,v_1,\dots,v_k$ $v_k$ $I(v_k)$ $V(v_0)+\dots + V(v_k)$

Es fácil admitir las operaciones get y set utilizando una variante de las técnicas descritas anteriormente. Básicamente, a medida que atravesamos el árbol hacia abajo, llevamos un registro de la suma de valores en ejecución, de modo que para cada nodo que visite el recorrido, sepamos la suma de valores de los nodos en el camino desde la raíz hasta . Una vez que hagamos eso, bastarán los ajustes simples a la implementación de get y set descritos anteriormente. $x$ $x$

Y ahora podemos admitir eficiente. Primero, expresamos el intervalo como la unión de los intervalos correspondientes a algún conjunto de nodos en el árbol (dividiendo un nodo en el punto final izquierdo y el punto final derecho si es necesario) ), exactamente como se hizo en los pasos 1-3 de la operación de configuración. Ahora, simplemente agregamos al valor almacenado en cada uno de esos nodos . (No eliminamos a sus descendientes). $\text{add}([a,b],\delta)$ $[a,b]$ $O(\lg n)$ $O(\lg n)$ $\delta$ $O(\lg n)$

Esto proporciona una manera de admitir obtener, establecer y agregar, en tiempo por operación. De hecho, el tiempo de ejecución por operación es donde cuenta el número de operaciones establecidas más el número de operaciones de suma. $O(\lg n)$ $O(\lg \min(n,s))$ $s$

Apoyando la operación de puñalada

La consulta de apuñalamiento es la más difícil de soportar. La idea básica será modificar la estructura de datos anterior para preservar la siguiente invariante adicional:

(*) El intervalo correspondiente a cada hoja es un intervalo plano máximo. $I(\ell)$ $\ell$

Aquí digo que un intervalo es el intervalo plano máximo si (i) es plano, y (ii) ningún intervalo que contenga es plano (en otras palabras, para todo satisface , ya sea o no es plano). $[a,b]$ $[a,b]$ $[a,b]$ $a',b'$ $1 \le a' \le a \le b \le b' \le n$ $[a',b']=[a,b]$ $[a',b']$

Esto hace que la operación de apuñalamiento sea fácil de implementar:

$\text{stab}(i)$ encuentra la hoja cuyo intervalo contiene , y luego devuelve ese intervalo. $i$

Sin embargo, ahora necesitamos modificar el conjunto y agregar operaciones para mantener el invariante (*). Cada vez que dividimos una hoja en dos, podríamos violar la invariante si algún par adyacente de intervalos de hoja tiene el mismo valor de la función . Afortunadamente, cada operación de establecer / agregar agrega como máximo 4 nuevos intervalos de hoja. Además, para cada nuevo intervalo, es fácil encontrar el intervalo de hoja inmediatamente a la izquierda y derecha del mismo. Por lo tanto, podemos decir si el invariante fue violado; si lo fuera, entonces fusionamos intervalos adyacentes donde tiene el mismo valor. Afortunadamente, la fusión de dos intervalos adyacentes no desencadena cambios en cascada (por lo que no es necesario verificar si la fusión podría haber introducido violaciones adicionales de la invariante). En total, esto implica examinar $f$ $f$ $12=O(1)$ pares de intervalos y posiblemente fusionándolos. Finalmente, dado que una fusión cambia la forma del árbol, si esto viola los invariantes del equilibrio, realice las rotaciones necesarias para mantener el árbol equilibrado (siguiendo las técnicas estándar para mantener equilibrados los árboles binarios). En total, esto agrega como máximo trabajo adicional a las operaciones set / add. $O(\lg n)$

Por lo tanto, esta estructura de datos final admite las cuatro operaciones, y el tiempo de ejecución para cada operación es . Una estimación más precisa es el tiempo por operación, donde cuenta el número de operaciones de establecimiento y suma. $O(\lg n)$ $O(\lg \min(n,s))$ $s$

Pensamientos de despedida

Uf, este era un esquema bastante complejo. Espero no haber cometido ningún error. Por favor revise mi trabajo cuidadosamente antes de confiar en esta solución.

— DW
fuente