Scambio tempo-spazio per problema elemento mancante

Ecco un problema ben noto.

Dato un array di numeri interi positivi, genera il numero intero positivo più piccolo non presente nell'array. $A[1\dots n]$

Il problema può essere risolto nello spazio e nel tempo : leggere l'array, tenere traccia nello spazio indipendentemente dal fatto che si siano verificati , cercare l'elemento più piccolo. $O(n)$ $O(n)$ $1,2,\dots,n+1$

Ho notato che puoi scambiare spazio con il tempo. Se hai $O(\frac{n}{k})$ solo memoria, puoi farlo inround e ottenere il tempo. In un caso speciale, esiste ovviamente un algoritmo a tempo quadratico a spazio costante. $k$ $O(k n)$

La mia domanda è:

È questo il compromesso ottimale, ovvero ? In generale, come si dimostra questo tipo di limiti? $\operatorname{time} \cdot \operatorname{space} = \Omega(n^2)$

Assumi il modello RAM, con aritmetica limitata e accesso casuale agli array in O (1).

Ispirazione per questo problema: compromesso spazio-tempo per i palindromi nel modello a nastro singolo (vedi ad esempio qui ).

complexity-theory time-complexity space-complexity

— sdcvvc
fonte

No, potresti ordinare il tuo array in

O (n \log n)

$O(n \log n)$ quindi trovare il numero mancante (il primo numero dovrebbe essere 1, il secondo dovrebbe essere 2, ... altrimenti lo troverai) in O (n), questo ordinamento potrebbe essere fatto con inplace mergesort, significa

O (1)

$O(1)$ spazio extra, quindi il tempo

\cdot

$\cdot$ spazio appartiene a

O (n \log n)

$O(n \log n)$ . Non so di avere il tuo problema esattamente o no (per questo non ho risposto, inoltre non so se esiste un limite migliore).

Presumo che l'input sia di sola lettura. (In caso contrario, il problema può essere risolto in modo ottimale nello spazio

: moltiplica l'input per 2 e usa la parità per simulare l' algoritmo

)

O (n)

$O(n)$

O (1)

$O(1)$

O (n) / O (n)

$O(n)/O(n)$

— sdcvvc

Qual è l'algoritmo dello spazio costante? Sembra che avresti bisogno di

spazio per la versione

che è "ovvia" per me

\log n

$\log n$

n^{2}

$n^2$

— Xodarap

In questo modello, numeri interi di dimensioni di parole prendono

; se è più conveniente, puoi rispondere a qualsiasi variante della domanda con il

O (1)

$O(1)$

per qualche costante

time \cdot space = Ω (\frac{n^{2}}{\log^{k} n})

$\operatorname{time} \cdot \operatorname{space} = \Omega(\frac{n^2}{\log^k n})$

k

$k$

— sdcvvc,

@sdcvvc, non riesco a capire il tuo algoritmo

, lo descriveresti un po 'di più? (basta notare che la lettura in bit richiede

O (n) / O (1)

$O(n)/O(1)$

O (\log n)

$O(\log n)$

Risposte:

Questo può essere fatto in operazioni a parola $O(n \log n)$ e parole di memoria $O(1)$ (rispettivamente tempo $O(n \log^2 n)$ e memoria $O(\log n)$ nel modello RAM a livello di bit). In effetti, la soluzione si baserà sulla seguente osservazione.

Supponiamo che ci siano $n_0$ numeri pari e $n_1$ numeri dispari nell'intervallo $[1, n + 1]$ (quindi $n_0 \approx n_1$ e $n_0 + n_1 = n + 1$ ). Quindi c'è $b \in \{0, 1\}$ tale che ci sono al massimo $n_b - 1$ valori con parità $b$ nell'input. Anzi, altrimenti ci sono almeno $n_0$ pari e almeno $n_1$ valori dispari nell'input, il che significa che ci sono almeno $n_0 + n_1 = n + 1$ valori nell'input, contraddizione (ce ne sono solo $n$ ). Significa che possiamo continuare a cercare il numero mancante solo tra i numeri pari o dispari. Lo stesso algoritmo può essere applicato anche a bit più alti di notazione binaria.

Quindi il nostro algoritmo sarà simile a questo:

Supponiamo che già ora ci siano solo $x$ valori nell'input con il resto modulo $2^b$ uguale a $r \in [0, 2^b)$ ma ci sono almeno $x + 1$ numeri nell'intervallo $[1, n + 1]$ che hanno resto $r$ modulo $2^b$ (all'inizio sappiamo che per $b = 0, r = 0$ ).
Supponiamo che ci siano $x_0$ valori nell'input con resto $r$ modulo $2^{b + 1}$ e $x_1$ valori nell'input con resto $r + 2^b$ modulo $2^{b + 1}$ (possiamo trovare questi numeri in un singolo passaggio attraverso l'ingresso). Chiaramente, $x_0 + x_1 = x$ . Inoltre, poiché ci sono almeno $x + 1$ numeri nell'input con resto $r$ modulo $2^b$ , almeno una delle coppie $(r, b + 1), (r + 2^b, b + 1)$ soddisfa i requisiti del passaggio $1$ .
Abbiamo trovato il numero mancante quando $2^b \geqslant n + 1$ : c'è un solo numero nell'intervallo $[1, n + 1]$ che può avere resto $r$ modulo $2^b$ ( $r$ stesso se è nell'intervallo), quindi ci sono maggior parte dei valori zero nell'input che hanno tale resto. Quindi manca davvero $r$ .

Chiaramente, l'algoritmo si interrompe nei passaggi $O(\log n)$ , ognuno di essi richiede tempo $O(n)$ (passaggio singolo sull'array di input). Inoltre, sono necessarie solo $O(1)$ parole di memoria.

— Kaban-5
fonte

Sono felice di vedere la risposta alla domanda dopo quel momento :)

— sdcvvc,

Se capisco le tue definizioni, questo può essere fatto in tempo lineare con spazio costante. Questo è ovviamente il limite più basso, perché dobbiamo almeno leggere l'intero input.

La risposta fornita in questa domanda è soddisfacente.

È impossibile eseguirlo con meno tempo o spazio e l'aggiunta di tempo o spazio extra è inutile, quindi non c'è compromesso spazio-tempo qui. (Osserva che , quindi il compromesso che hai osservato non si mantiene asintoticamente, in ogni caso.) $n=O(n/k)$

Per quanto riguarda la tua domanda generale, non conosco i teoremi simpatici che ti aiuteranno a dimostrare i compromessi spazio-temporali. Questa domanda sembra indicare che non esiste una risposta (nota) facile. Fondamentalmente:

Supponiamo che una certa lingua sia decidibile in tempo (usando una certa quantità di spazio) e spazio (usando una certa quantità di tempo). Possiamo trovare tale che sia decidibile per che corre nello spazio e nello spazio ? $t$ $s$ $f,g$ $L$ $M$ $f(t,s)$ $g(t,s)$

è sconosciuto, e una risposta forte risolverebbe molti problemi aperti (in particolare su SC), il che implica che non esiste una soluzione facile.

EDIT: Ok, con ripetizione (ma sto ancora supponendo che con un input di dimensione il numero massimo possibile sia ). $n$ $n+1$

Osserva che il nostro algoritmo deve essere in grado di distinguere tra almeno possibili risposte. Supponiamo che ad ogni passaggio attraverso i dati possiamo ottenere al massimo pezzi di dati. Quindi avremo bisogno di pass per differenziare tutte le risposte. Supponendo che corriamo in $n$ $k$ $n/k$ $k=n/s$ tempo. Quindi penso che questo provi quello che vuoi. $\frac{n}{n/s}n=sn$

La difficoltà sta nel mostrare che ogni volta che otteniamo solo bit. Se supponi che la nostra unica operazione legale sia =, allora siamo a posto. Tuttavia, se consenti operazioni più complesse, sarai in grado di ottenere maggiori informazioni. $k$

— Xodarap
fonte

La domanda che hai collegato presuppone che ogni numero appaia al massimo una volta. Non faccio questo presupposto, quindi la soluzione non si applica. Grazie per il secondo link.

— sdcvvc,

@sdcvvc: errore mio, ho pensato che stavi usando la versione che conosco. Non ho una risposta completa, ma è troppo lungo per un commento - spero che la mia modifica sia utile.

— Xodarap,

Non compro il tuo argomento dopo "EDIT". Anche se puoi raccogliere

bit in un solo passaggio, in linea di principio è sufficiente distinguere

possibili output. Quindi questo argomento può implicare solo un limite inferiore di

passaggi, non

k

$k$

2^{k}

$2^k$

n / 2^{k}

$n/2^k$

n / k

$n/k$

— JeffE,