Struttura dei dati per la mappa a intervalli

Sia un numero intero e denota l'insieme di tutti i numeri interi. Lascia che denoti l'intervallo di numeri interi . $n$ $\mathbb{Z}$ $[a,b]$ $\{a,a+1,a+2,\dots,b\}$

Sto cercando una struttura di dati per rappresentare una mappa . Voglio che la struttura dei dati supporti le seguenti operazioni: $f:[1,n] \to \mathbb{Z}$

$\text{get}(i)$ dovrebbe restituire . $f(i)$
$\text{set}([a,b],y)$ dovrebbe aggiornare modo che , cioè aggiorna in una nuova mappa tale che per e per . $f$ $f(a)=f(a+1)=\cdots=f(b)=y$ $f$ $f'$ $f'(i) = y$ $i \in [a,b]$ $f'(i) = f(i)$ $i \notin [a,b]$
$\text{stab}(i)$ dovrebbe restituire l'intervallo più grande tale che e sia costante su (cioè, ). $[a,b]$ $i \in [a,b]$ $f$ $[a,b]$ $f(a)=f(a+1)=\cdots=f(b)$
$\text{add}([a,b],\delta)$ dovrebbe aggiornare ad una nuova mappa tale che per e per . $f$ $f'$ $f'(i) = f(i) + \delta$ $i \in [a,b]$ $f'(i) = f(i)$ $i \notin [a,b]$

Voglio che ciascuna di queste operazioni sia efficiente. Conterrei il tempo o come efficiente, ma il tempo è troppo lento. Va bene se i tempi di esecuzione sono ammortizzati. Esiste una struttura di dati che rende contemporaneamente efficienti tutte queste operazioni? $O(1)$ $O(\lg n)$ $O(n)$

(Ho notato un modello simile emergere in diverse sfide di programmazione. Questa è una generalizzazione che sarebbe sufficiente per tutti quei problemi di sfida.)

— DW
fonte

Immagino che gli alberi splay siano il punto di partenza. addsarebbe lineare nel numero di sottointervalli di ; hai pensato a un albero splay con ulteriori nodi unari " ", compattati pigramente?

[a, b]

$[a,b]$

+ δ

$+\delta$

— Gilles 'SO- smetti di essere malvagio' il

Considera tale che per tutti , . Quindi devi avere valori memorizzati da qualche parte. L'esecuzione di deve sbarazzarsi di quei valori in qualche modo (riscrivendoli o gettandoli via - puoi rimandare con GC, ma dovrai fare operazioni ad un certo punto). Pertanto, l'operazione sarà .

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, sarei felice con una soluzione che tratta GC in modo efficace "gratuito". Più in generale, sarei contento di una soluzione in cui i tempi di esecuzione sono ammortizzati i tempi di esecuzione (quindi il costo di GC può essere ammortizzato nel costo della creazione del valore in primo luogo).

— DW

Hai notato che il tempo costante e logaritmico sono efficienti e il tempo lineare è lento. Sarebbe tempo di essere troppo lento per le vostre esigenze?

O (\sqrt{n} \lg n)

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

— jbapple,

@jbapple, ehi, è un inizio! Penso che valga la pena documentare come risposta.

— DW

Credo che il tempo logaritmico per tutte le domande sia realizzabile. L'idea principale è quella di utilizzare un albero degli intervalli, in cui ciascun nodo dell'albero corrisponde a un intervallo di indici. Svilupperò le idee chiave iniziando con una versione più semplice della struttura dei dati (che può supportare get e set ma non le altre operazioni), quindi aggiungerò funzionalità per supportare anche le altre funzionalità.

Uno schema semplice (supporta get e set, ma non aggiungere o pugnalare)

Supponiamo che un intervallo sia piatto se la funzione è costante su , cioè se . $[a,b]$ $f$ $[a,b]$ $f(a)=f(a+1)=\cdots =f(b)$

La nostra semplice struttura di dati sarà una struttura ad intervalli. In altre parole, abbiamo un albero binario, in cui ogni nodo corrisponde a un intervallo (di indici). Memorizzeremo l'intervallo in ciascun nodo dell'albero. Ogni foglia corrisponderà ad un intervallo piatto e saranno disposti in modo tale che la lettura delle foglie da sinistra a destra ci dia una sequenza di intervalli piatti consecutivi che sono disgiunti e la cui unione è tutta di . L'intervallo per un nodo interno sarà l'unione degli intervalli dei suoi due figli. Inoltre, in ogni nodo foglia memorizzeremo il valore della funzione sull'intervallo $I(v)$ $v$ $[1,n]$ $\ell$ $V(\ell)$ $f$ $I(\ell)$ corrispondente a questo nodo (si noti che questo intervallo è piatto, quindi è costante sull'intervallo, quindi memorizziamo un singolo valore di in ciascun nodo foglia). $f$ $f$

Allo stesso modo, puoi immaginare che partizioniamo in intervalli piatti, e quindi la struttura dei dati è un albero di ricerca binario in cui le chiavi sono gli endpoint di sinistra di quegli intervalli. Le foglie contengono il valore di in un intervallo di indici in cui è costante. $[1,n]$ $f$ $f$

Utilizzare metodi standard per garantire che l'albero binario rimanga bilanciato, ovvero che la sua profondità sia (dove conta il numero corrente di foglie nell'albero). Certo, , quindi la profondità è sempre al massimo . Questo sarà utile di seguito. $O(\lg m)$ $m$ $m\le n$ $O(\lg n)$

Ora possiamo supportare le operazioni get e set come segue:

$\text{get}(i)$ è facile: attraversiamo l'albero per trovare la foglia il cui intervallo contiene . Fondamentalmente si tratta solo di attraversare un albero di ricerca binario. Poiché la profondità è , il tempo di esecuzione è . $i$ $O(\lg n)$ $O(\lg n)$
$\text{set}([a,b],y)$ è più complicato. Funziona così:
1. Innanzitutto, troviamo l'intervallo foglia contenente ; se , allora suddividiamo questo intervallo foglia in due intervalli e (trasformando così questo nodo foglia in un nodo interno e introducendo due figli). $[a_0,b_0]$ $a$ $a_0 < a$ $[a_0,a-1]$ $[a,b_0]$
2. Successivamente, troviamo l'intervallo foglia contenente ; se , suddividiamo questo intervallo foglia nei due intervalli e (trasformando così questo nodo foglia in un nodo interno e introducendo due figli). $[a_1,b_1]$ $b$ $b < b_1$ $[a_1,b]$ $[b+1,b_1]$
3. A questo punto, sostengo che l'intervallo può essere espresso come l'unione disgiunta di intervalli corrispondenti ad alcuni sottogruppi di nodi nella struttura ad albero. Quindi, elimina tutti i discendenti di quei nodi (trasformandoli in foglie) e imposta il valore memorizzato in quei nodi su . $[a,b]$ $O(\lg n)$ $O(\lg n)$ $y$
4. Infine, poiché abbiamo modificato la forma dell'albero, eseguiremo tutte le rotazioni necessarie per riequilibrare l'albero (utilizzando qualsiasi tecnica standard per mantenere un albero in equilibrio).
Poiché questa operazione comporta alcune semplici operazioni sui nodi (e quella serie di nodi può essere facilmente trovata nel tempo ), il tempo totale per questa operazione è . $O(\lg n)$ $O(\lg n)$ $O(\lg n)$

Questo dimostra che possiamo supportare sia le operazioni get che set in per operazione. In effetti, il tempo di esecuzione può essere indicato come , dove è il numero di operazioni impostate eseguite fino ad ora. $O(\lg n)$ $O(\lg \min(n,s))$ $s$

Aggiunta del supporto per Aggiungi

Siamo in grado di modificare la struttura di dati di cui sopra in modo che possa supportare anche l'operazione di aggiunta. In particolare, invece di memorizzare il valore della funzione nelle foglie, verrà rappresentata come la somma dei numeri memorizzati in un insieme di nodi.

Più precisamente, il valore della funzione all'ingresso sarà recuperabile come la somma dei valori memorizzati nei nodi sul percorso dalla radice dell'albero fino alla foglia il cui intervallo contiene . In ogni nodo memorizzeremo un valore ; se rappresentano gli antenati di una foglia (compresa la foglia stessa), il valore della funzione su sarà . $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)$

È facile supportare le operazioni get e set usando una variante delle tecniche sopra descritte. Fondamentalmente, mentre attraversiamo l'albero verso il basso, teniamo traccia della somma corrente dei valori, in modo che per ogni nodo che la visita attraversi, conosciamo la somma dei valori dei nodi sul percorso dalla radice a . Una volta fatto ciò, saranno sufficienti semplici adattamenti all'implementazione di get e set sopra descritti. $x$ $x$

E ora possiamo supportare efficiente. Innanzitutto, esprimiamo l'intervallo come l'unione di intervalli corrispondenti a un insieme di nodi nella struttura (suddividendo un nodo all'endpoint sinistro e all'endpoint destro se necessario ), esattamente come fatto nei passaggi 1-3 dell'operazione impostata. Ora, aggiungiamo semplicemente al valore memorizzato in ciascuno di quei nodi . (Non eliminiamo i loro discendenti.) $\text{add}([a,b],\delta)$ $[a,b]$ $O(\lg n)$ $O(\lg n)$ $\delta$ $O(\lg n)$

Questo fornisce un modo per supportare ottenere, impostare e aggiungere, in tempo per operazione. In effetti, il tempo di esecuzione per operazione è dove conta il numero di operazioni impostate più il numero di operazioni di aggiunta. $O(\lg n)$ $O(\lg \min(n,s))$ $s$

Supportare l'operazione di pugnalata

La query lancinante è la più impegnativa da supportare. L'idea di base sarà quella di modificare la struttura di dati sopra per preservare il seguente invariante aggiuntivo:

(*) L'intervallo corrispondente a ciascuna foglia è un intervallo massimo piatto. $I(\ell)$ $\ell$

Qui dico che un intervallo è un intervallo massimo piatto se (i) è piatto, e (ii) nessun intervallo contenente è piatto (in altre parole, per tutto soddisfacente , o non è piatto). $[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']$

Ciò rende l'operazione di stabilizzazione facile da implementare:

$\text{stab}(i)$ trova la foglia il cui intervallo contiene , quindi restituisce quell'intervallo. $i$

Tuttavia, ora dobbiamo modificare il set e aggiungere operazioni per mantenere l'invariante (*). Ogni volta che dividiamo una foglia in due, potremmo violare l'invariante se alcune coppie adiacenti di intervalli di foglie hanno lo stesso valore della funzione . Fortunatamente, ogni operazione di impostazione / aggiunta aggiunge al massimo 4 nuovi intervalli di foglie. Inoltre, per ogni nuovo intervallo, è facile trovare l'intervallo foglia immediatamente a sinistra e a destra di esso. Pertanto, possiamo dire se l'invariante è stato violato; in tal caso, uniamo gli intervalli adiacenti in cui ha lo stesso valore. Fortunatamente, l'unione di due intervalli adiacenti non provoca cambiamenti in cascata (quindi non è necessario verificare se la fusione potrebbe aver introdotto ulteriori violazioni dell'invariante). Complessivamente, ciò implica l'esame di $f$ $f$ $12=O(1)$ coppie di intervalli e possibilmente fondendole. Infine, poiché una fusione modifica la forma dell'albero, se ciò viola gli invarianti di equilibrio, esegui tutte le rotazioni necessarie per mantenere l'albero equilibrato (seguendo le tecniche standard per mantenere equilibrati gli alberi binari). In totale, questo aggiunge al massimo lavoro aggiuntivo alle operazioni set / add. $O(\lg n)$

Pertanto, questa struttura dati finale supporta tutte e quattro le operazioni e il tempo di esecuzione per ciascuna operazione è . Una stima più precisa è il tempo per operazione, dove conta il numero di operazioni impostate e aggiunte. $O(\lg n)$ $O(\lg \min(n,s))$ $s$

Pensieri di separazione

Accidenti, questo era uno schema piuttosto complesso. Spero di non aver fatto errori. Si prega di controllare attentamente il mio lavoro prima di fare affidamento su questa soluzione.

— DW
fonte