Complessità bit dell'interrogazione O (1) dell'intervallo di tempo in a

Considera il seguente problema:

Permettere $k$ essere una costante. Ci viene dato un $k$ -ary array $A_{d_1\times\ldots\times d_k}$ di $0$ e $1$ 'S. Permettere $N = \prod_{i=1}^k d_i$ .

Vogliamo creare una struttura di dati mediante preelaborazione $A$ per eseguire il seguente tipo di operazioni di query:

Date le coordinate di a $k$ -a scatola $D$ , C'è un $1$ nella scatola?
Date le coordinate di a $k$ -a scatola $D$ , restituisce la posizione di a $1$ nella casella (se ce n'è uno).

Le operazioni devono essere eseguite a tempo costante $O(1)$ . La complessità temporale viene misurata su una macchina RAM. Il tempo di preelaborazione e lo spazio per la struttura dei dati non sono importanti per noi.

La domanda è: quanto spazio (in bit di complessità) è necessario per archiviare una struttura di dati che consenta le operazioni di cui sopra?

Il banale limite inferiore è $N$ bit poiché l'array può essere ricostruito per queste query (quindi la struttura dei dati dovrebbe contenere almeno la stessa quantità di informazioni).

Il banale limite superiore è memorizzare la risposta a tutte le query. Ciò richiederebbe $\prod_{i=1}^k {d_i \choose 2} = \Theta(N^2)$ bit. Tuttavia sospettiamo che ciò possa essere fatto in modo molto più efficiente.

Ad esempio, considera il caso speciale in cui $k=1$ . In questo caso possiamo usare una struttura dati RMQ sintetica per risolvere il primo problema e la struttura dati impiega $2N+o(N)$ bit per memorizzare.

Che cos'è una struttura dati efficiente per questo compito?
Quanto può essere ridotta la complessità dello spazio (il numero di bit) per supportare queste operazioni (o solo la prima operazione)?

Aggiornamento (1/15): nel caso speciale , è sufficiente usare bit (in realtà meglio, , dove è il numero di è in ) riducendo il problema a un problema precedente e usando la riduzione dal problema precedente al dizionario completamente indicizzabile (FID). Vedi " Più fretta, meno rifiuti: ridurre la ridondanza nei dizionari completamente indicizzabili " di Grossi, Orlandi, Raman e Rao (2009). $k=1$ $N +o(N)$ $\log {N\choose t}+O(t)$ $t$ $1$ $A$

Aggiornamento (27/06): di nuovo riducendo il problema a RMQ. Usiamo un RMQ -dimensional da Yuan e Atallah per ottenere un limite superiore della quantità di spazio necessario quando è fisso. $k$ $O(n\log n)$ $k$

reference-request data-structures space-complexity

— Chao Xu
fonte

La domanda non è chiara: è una domanda sulla struttura dei dati? In tal caso, quali sono le altre operazioni su questo array kD? Se non vi sono altre operazioni, non vi è 1 su di essa. Se la domanda è che ci viene dato un array kD e cosa fare un po 'di preelaborazione su di esso e quindi memorizzarlo in modo tale da usare poca quantità di memoria ma in grado di eseguire questa operazione di controllo nel caso peggiore di , chiarirlo. Spiega anche qual è il modello di calcolo se desideri un limite inferiore.

O (1)

$O(1)$

— Kaveh,

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

— Kaveh

IIUC, il documento dice che la risposta per 1D è davvero bit e l'idea è quella di conservare tutte le piccole scatole più tutte le scatole con lunghezze di potenza 2 e altre scatole possono essere ottenute da scatole len pow-2 in costante tempo ( ) e mi sembra che la stessa cosa funzionerebbe qui e i bit saranno sufficienti.

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,

Grazie, ho aggiunto alcuni chiarimenti. Il documento non ha detto che il loro contributo principale è l'uso di bit sia in pre-elaborazione che in memoria?

2 n + o (n)

$2n+o(n)$

— Chao Xu,

Siamo spiacenti, quello che ho descritto era di un lavoro precedente. Tuttavia, il loro risultato sembra concettualmente simile, ovvero dividono l'array in blocchi, precompongono la risposta su di essi e ne usano un numero costante per calcolare la risposta per ogni dato. Se in kD il numero di blocchi base necessari per calcolare la risposta a un blocco arbitrario è una costante, un algoritmo simile funzionerebbe qui e darebbe probabilmente qualcosa come (I haven ' controllare che sia così).

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

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

— Kaveh,

Puoi risparmiare molto di più in memoria se permetti solo la complessità del tempo logaritmico. È possibile implementare un albero di segmenti kD che avrà bisogno di memoria N * 2 ^ k bit e viene eseguito con complessità temporale logaritmica per entrambe le attività secondarie e complessità temporale lineare per la costruzione dell'albero.

Se si desidera rigorosamente O (1), pre-calcolare tutto.

— Bojan Serafimov
fonte

Puoi delineare come l'albero è costruito nel tempo logaritmico?

— Raffaello

scusate, è costruito in tempo lineare

— Bojan Serafimov,

@BojanSerafimov È necessario aggiornare la risposta quindi :) I commenti potrebbero essere eliminati.

— Juho,

Penso che questa possa essere una buona risposta, se l'hai appena modificata per essere corretta e forse un po 'più elaborata su come appaiono questi alberi e su come li costruisci.

— Raffaello