L'unicità degli elementi può essere risolta nel tempo lineare deterministico?

9

Considera il seguente problema:

Input : elenca di numeri interi $X,Y$

Obiettivo : determinare se esiste un numero intero presente in entrambi gli elenchi. $x$

Supponiamo che entrambe le liste siano della dimensione . Esiste un algoritmo deterministico a tempo lineare per questo problema? In altre parole, puoi risolvere questo problema in tempo in modo deterministico, senza usare la casualità? $X,Y$ $n$ $O(n)$

Sfortunatamente, non puoi presumere che gli elementi dell'elenco siano tutti piccoli.

Posso vedere come risolverlo nel tempo previsto usando un algoritmo randomizzato: scegliere casualmente una funzione hash 2-universale , memorizzare gli elementi di in una tabella hash (usando come funzione hash), quindi cercare ogni elemento di per vedere se è nella tabella hash. Il tempo di esecuzione previsto sarà . Tuttavia, non riesco a vedere come trovare un algoritmo deterministico con tempo di esecuzione . Se si tenta di derandomizzare questo e correggere una singola funzione hash specifica, esiste un input nel caso peggiore che causa l'esecuzione di questa procedura $O(n)$ $h$ $X$ $h$ $Y$ $O(n)$ $O(n)$ tempo. Il miglior algoritmo deterministico che riesco a trovare comporta l'ordinamento dei valori, ma non sarà un tempo lineare. Possiamo raggiungere un tempo di esecuzione lineare? $\Theta(n^2)$

Inoltre, posso vedere come risolverlo in tempo lineare se supponi che tutti gli elementi dell'elenco siano numeri interi nell'intervallo (sostanzialmente, contando l'ordinamento) - ma sono interessato a ciò che accade in generale caso in cui non possiamo assumerlo. $[1,n]$

Se la risposta dipende dal modello di calcolo, mi viene in mente il modello RAM, ma sarei interessato ai risultati per qualsiasi modello ragionevole di calcolo. Sono a conoscenza dei limiti inferiori per gli algoritmi dell'albero decisionale per l'univocità degli elementi , ma questo non è definitivo, poiché a volte possiamo trovare algoritmi a tempo lineare anche quando è presente un limite il modello dell'albero decisionale. $\Omega(n \log n)$ $\Omega(n \log n)$

algorithms complexity-theory lower-bounds

— DW
fonte

Gli hashtable sono O (n log n) in quanto è necessario gestire le collisioni.

— Thorbjørn Ravn Andersen,

1

@ ThorbjørnRavnAndersen, non vedo da dove lo stai ottenendo. L'uso di funzioni hash 2-universali e una tabella hash di dimensioni adeguate assicura che il numero di collisioni hash sia minimo (con alta probabilità), quindi credo che sia possibile raggiungere il tempo di esecuzione

. Non sono sicuro da dove hai preso

; se non fai qualcosa di speciale (come usare l'hash 2-universale), il caso peggiore è

, a causa di collisioni.

O (n)

$O(n)$

O (n \lg n)

$O(n \lg n)$

O (n^{2})

$O(n^2)$

— DW

Il diavolo è nei dettagli, qui una "tabella di hash di dimensioni adeguate". Questo potrebbe rivelarsi piuttosto grande, se non vuoi collisioni. Il tipico n-log-n è (se ricordo bene) per gestire le collisioni della funzione hash con un elenco.

— Thorbjørn Ravn Andersen,

1

@ ThorbjørnRavnAndersen Il numero previsto di chiavi mappate allo stesso indirizzo è costante (per le tabelle che non sono sovraccaricate), quindi il tipo di risoluzione delle collisioni è irrilevante. Vedi anche qui .

adatta al caso peggiore se si utilizzano BST (esterni) bilanciati anziché elenchi.

O (n \log n)

$O(n \log n)$

— Raffaello

1

È possibile risolvere il problema in tempo lineare se si dispone di memoria sufficiente per disporre di un bit per ciascun valore possibile in X e Y. Ciò non impone alcuna restrizione all'ordinamento di X e Y.

Inizialmente tutti i bit non sono impostati.
Scorrere su X impostando il bit corrispondente.
Scorrere su Y controllando se il bit corrispondente è stato impostato sopra.

— Thorbjørn Ravn Andersen
fonte

2

Sfortunatamente, non puoi presumere che tutti gli interi siano piccoli (non puoi supporre che siano abbastanza piccoli da far funzionare questo algoritmo). Nel caso generale, il tempo di esecuzione di questo algoritmo sarà esponenziale nella lunghezza in bit degli elementi dell'elenco. Grazie comunque!

— DW

Chiamiamolo quindi un "bit-array di dimensioni adeguate". Anche lineare nella lunghezza in bit equivale a log-n. Sei seriamente intenzionato a ottenere le prestazioni del log-n senza alcuna restrizione o condizione preliminare sui dati di input?

— Thorbjørn Ravn Andersen,

2

@ ThorbjørnRavnAndersen Lo spazio è esponenziale nella lunghezza dei bit (è necessario mappare da tutti i valori possibili) e il tempo è lineare nella dimensione totale dell'elenco (è necessario esaminare tutti i valori in entrambi gli elenchi). Nulla è lineare nella lunghezza dei bit.

— mercoledì

0

Dal momento che stai dicendo che le due liste contengono numeri interi, immagino che possiamo eseguire un ordinamento radix sulle due liste e quindi fare una ricerca lineare confrontando le due liste per elementi equivalenti.

— Anirudh
fonte

4

Funziona solo se c'è un limite all'entità dei numeri.

— Luke Mathieson,

ma ho pensato che l'alta magnitudine sarà un problema solo per contare l'ordinamento e per l'ordinamento radix possiamo selezionare un radix abbastanza alto per risolvere quel problema ... per favore fatemi sapere cosa mi manca qui

— anirudh

Cosa succede se uno dei numeri è 2 ^ (2 ^ 128)?

— miniBill

@anirudh ma poi hai un algoritmo diverso per dimensioni di input diverse: hai bisogno di un alfabeto più grande ogni volta che aumenti il radix, stai solo esportando la complessità di aumentare la grandezza per aumentare la dimensione dell'alfabeto. Naturalmente questo è possibile anche solo in teoria, non penso che molto hardware ti permetta di cambiare in quale base rappresenta i numeri (possiamo pretendere alle estremità di input e output, ma si riduce a (principalmente) binario ).

— Luke Mathieson,

0

$\mathcal O\left(n\cdot \overline m\right)$ $\overline m$

— Realz Slaw
fonte

O (n)

$O(n)$

O (n \cdot \overbar m)

$O(n \cdot \overbar{m})$

w

$w$

m

$m$

\bar{m}

$\overline{m}$

O (n)

$\mathcal O\left(n\right)$

w

$w$

w

$w$

n

$n$

m

$m$

n

$n$

n^{m}

$n^m$

-1

$O(n\log n)$

— Omer Gold
fonte

1

La domanda è abbastanza esplicita sul tempo deterministico lineare, non log-lineare. Inoltre, per determinare se l'insieme (non su quale valore) ha solo elementi univoci, è possibile eseguire più velocemente di loglinear.

— Evil

1

Ω (n \log n)

$\Omega(n\log n)$

1

Ω (n \log n)

$\Omega(n \log n)$

Ω (n \log n)

$\Omega(n \log n)$

O (n \log \log n)

$O(n \log \log n)$

O (n \log n)

$O(n \log n)$

Ω (n \log n)

$\Omega(n \log n)$