Struttura dei dati per aggiornamenti su intervalli e interrogazione del numero di zeri

Sto cercando una struttura di dati che mantenga una tabella intera $t$ di dimensione $n$ e consenta le seguenti operazioni nel tempo $O(\log n)$ .

$\text{increase}(a,b)$ , che aumenta $t[a],t[a+1],\ldots,t[b]$ .
$\text{decrease}(a,b)$ , che diminuisce $t[a],t[a+1],\ldots,t[b]$ .
$\text{support}()$ , che restituisce il numero di indici $i$ tale che $t[i]\neq 0$ .

Hai la promessa che ogni chiamata a diminuire può essere abbinata a una chiamata precedente per aumentare con gli stessi parametri . L'applicazione che ho in mente è un algoritmo sweepline per calcolare nel tempo l'area dell'unione di n determinati rettangoli rettilinei. $a,b$ $O(n\log n)$

Un quad-albero avrebbe dimensioni , quindi non è una soluzione. Gli alberi Fenwick o Interval hanno il giusto sapore, ma non vedo come estenderli per supportare le operazioni sopra. $\Theta(n^2)$

ds.data-structures cg.comp-geom

— Christoph Dürr
fonte

Gli alberi di Fenwick non userebbero la promessa che "ogni chiamata per diminuire può essere abbinata a una chiamata precedente per aumentare con gli stessi parametri a, b", quindi potrebbe esserci una soluzione più semplice usando quella promessa (ma per ora mi sfugge).

— Jeremy,

Poiché il numero di input che è possibile avere è al massimo

(è possibile rilevare ripetizioni e non inserirle nella struttura dei dati), otteniamo comunque prestazioni

utilizzando la struttura dei dati dell'albero delle misure comune. Vedi cosy.sbg.ac.at/~ksafdar/data/courses/SeminarADS/… slide 47-52.

n^{2}

$n^2$

O (\log n)

$O(\log n)$

— Chao Xu,

Jérémie e Chao Xu. Grazie per i tuoi commenti Capisco ora come l'albero degli intervalli può essere utilizzato per mantenere la lunghezza totale dell'unione di un insieme variabile di intervalli. Questa è in effetti una struttura dati molto carina.

— Christoph Dürr,

Per il problema generale della struttura dei dati, la ricerca nel

richiede spazio

dove

è la dimensione dell'elenco di coppie attive di coordinate. Ma in effetti per l'algoritmo sweepline

quindi lo spazio rimane lineare. Il problema è ancora aperto per una struttura di dati con spazio migliore di

, quando

\log (n^{2}) \in O (\log (n))

$\log(n^2)\in O(\log(n))$

O (p) \subset O (n^{2})

$O(p)\subset O(n^2)$

p

$p$

p \in O (n)

$p\in O(n)$

O (p)

$O(p)$

p \in ω (n)

$p\in\omega(n)$

— Jeremy,

Ecco un bel link dove puoi testare le tue implementazioni con altre soluzioni allo stesso problema: spoj.com/OI/problems/NKMARS

— Erel Segal-Halevi

Risposte:

Usa un albero dei segmenti - una partizione ricorsiva dell'intervallo in intervalli più piccoli. Ogni intervallo delle operazioni di aggiornamento può essere partizionato in degli intervalli in questa partizione ricorsiva. Per ogni intervallo memorizza: $[1,n]$ $[a,b]$ $O(\log n)$ $[x,y]$

Il numero degli intervalli $c(x,y)$ $[a,b]$ che sono stati aumentati e non diminuiti in modo tale che sia uno degli intervalli in cui è partizionato $[x,y]$ $[a,b]$
Il numero di celle che non sono coperte da sottoinsiemi di intervalli partizionati che sono a o inferiori nella ricorsione $u(x,y)$ $[x,y]$

Quindi se è suddiviso ricorsivamente in e abbiamo $[x,y]$ $[x,z]$ $[z+1,w]$

u (x, y) = {\begin{cases} 0 & if c (x, y) > 0 \\ u (x, z) + u (z + 1, y) & otherwise \end{cases}

$u(x,y)=\begin{cases} 0&\text{if }c(x,y)>0\\ u(x,z)+u(z+1,y)&\text{otherwise} \end{cases}$ così possiamo aggiornare ogni valore

in tempo costante quando cambiano gli altri dati per un intervallo. Ad ogni query di supporto è possibile rispondere guardando

u (x, y)

$u(x,y)$

u (1, n)

$u(1,n)$

$(a,b)$ $[a,b]$ $O(\log n)$ $c(x,y)$ $u(x,y)$

— David Eppstein
fonte

[x, y]

$[x,y]$

[x, y]

$[x,y]$

[x, y]

$[x,y]$

u (x, y) = 0

$u(x,y) = 0$ ?

— jbapple,

Dipende dall'aumento delle operazioni effettuate. Inizialmente vengono scoperti tutti, ma quando si aumenta un piccolo intervallo all'interno

[x, y]

$[x,y]$ (o qualsiasi intervallo che inizi o termini entro

[x, y]

$[x,y]$ o che include

[x, y]

$[x,y]$ nella sua partizione) diminuisce.

— David Eppstein,

Potresti fare un esempio?

— jbapple,

Supponiamo che il tuo intervallo sia i numeri [1,8]. È ricorsivamente diviso in [1,4], [4,8], quindi [1,2], [3,4], [5,6] e [7,8], quindi tutte le gamme di un elemento. Inizialmente, tutto è scoperto, tutto c [x, y] = 0 e ogni intervallo ha u = la sua lunghezza. Supponiamo quindi di eseguire un'operazione di aumento [2,6]. Gli intervalli massimi O (log n) in cui [2,6] può essere scomposto sono [2,2], [3,4] e [5,6], quindi impostiamo c [x, y] per quei tre varia a 1. Secondo la formula nella mia risposta, questo fa sì che [x, y] anche questi tre intervalli diventino 0. u [1,2] diventa 1, u [1,4] diventa anche 1, u [ 5,8] = 2 e u [1,8] = 1 + 2 = 3

— David Eppstein

Puoi supportare $\text{increase}$ e $\text{decrease}$ nel $O(\sqrt{n}\log n)$ e $\text{support}$ nel $O(1)$ tempo. L'idea chiave è quella di suddividere la tabella in gruppi di dimensioni $\Theta(\sqrt{n})$ . Quindi ogni operazione di modifica ( $\text{increase}$ o $\text{decrease}$ ) funziona al massimo $O(\sqrt{n})$ gruppi e solo quelli vicini alla fine del suo intervallo ( $a$ e $b$ , nella tua formulazione) prendere $\omega(\log n)$ tempo.

— jbapple
fonte

Perché non adottare questo approccio al limite. Invece di passare a

O (\sqrt{n})

$O(\sqrt{n})$ secchi, possiamo invece formare un albero simile a questo: 1 / \ 2 3 / \ / \ 4 5 6 7 di cui, aggiornando, prendi

O (\log n)

$O(\log{n})$ per tutte le operazioni.

— S. Pek,