Struttura dei dati basata sul confronto per la ricerca di elementi

Esiste una struttura di dati che accetta una matrice non ordinata di $n$ elementi, esegue la preelaborazione in $O(n)$ e risponde alle query: c'è qualche elemento $x$ nell'elenco, ogni query nel peggior tempo $O(\log n)$ ?

Penso davvero che non ci sia, quindi una prova del fatto che non ce n'è nessuno è anche benvenuta.

ds.data-structures sorting

— Chi-Lan
fonte

(1) Non so perché tu possa dire "Certo che considero il tempo previsto", perché non dichiari affatto "previsto" nella tua domanda. Per favore, prova a porre la tua domanda in modo più preciso prima di dire "ovviamente". (2) Per favore, definisci "non-hashable".

— Tsuyoshi Ito

(1) vedo. Grazie per la spiegazione. Se qualcuno chiedesse "Ti interessa il tempo di esecuzione?", La risposta sarebbe effettivamente "ovviamente". :) (2) Penso che "L'unica azione consentita è confrontare due valori nell'elenco" è molto più preciso oltre a dichiarare "non hash". Puoi modificare la domanda in modo che le persone non debbano leggere i commenti per capire cosa significhi "non hash"?

— Tsuyoshi Ito,

A proposito, se non puoi provarlo, perché sai che è impossibile? Se si tratta di un esercizio in un libro di testo o in una classe, lo stai chiedendo su un sito Web sbagliato.

— Tsuyoshi Ito,

È questa la tua domanda: esiste una struttura di dati che accetta una matrice non ordinata di n elementi, esegue la preelaborazione in O (n) e risponde alle domande: c'è qualche elemento x nell'elenco, ogni query nel peggior tempo O (registro n)?

— sdcvvc,

@Filip: è facile da vedere? Se è vero, sono d'accordo che risolve la domanda.

— Tsuyoshi Ito,

Risposte:

Ecco una prova che è impossibile. Supponiamo che tu possa costruire una tale struttura di dati. Costruiscilo. Quindi scegli elementi a caso dall'elenco, aggiungi a ciascuno di essi, dove è inferiore alla differenza tra due elementi qualsiasi nell'elenco, ed esegui le query per verificare se uno qualsiasi degli elementi risultanti è nella elenco. Finora hai eseguito query. $n/\log n$ $\epsilon$ $\epsilon$ $O(n)$

Vorrei affermare che i confronti effettuati sono sufficienti per stabilire se un elemento nell'elenco originale è più piccolo o più grande di qualsiasi nuovo elemento . Supponi di non poterlo dire. Quindi, poiché si tratta di un modello basato sul confronto, non si saprebbe se fosse uguale a , una contraddizione del presupposto che la struttura dei dati funzioni. $a$ $b$ $a$ $b$

Ora, dato che elementi scelti sono casuali, i tuoi confronti hanno dato con alta probabilità informazioni sufficienti per dividere l'elenco originale in elenchi ciascuno di dimensioni . Ordinando ciascuno di questi elenchi, si ottiene un algoritmo di ordinamento randomizzato basato esclusivamente su confronti, una contraddizione. $n/\log n$ $n/\log n$ $O(\log n)$ $O(n \log \log n)$

— Peter Shor
fonte

Alcuni suggerimenti per aiutare a comprendere la prova (supponendo che io la capisca correttamente da solo ovviamente): gli elementi

devono essere compilati dagli elementi dopo che

è stato aggiunto a loro; il modello di confronto garantisce di sapere quale dei casi vale

; le liste

sono in 'ordine crescente': ogni elemento in una lista superiore è più alto di ogni elemento in una lista inferiore; dopo le query originali hai abbastanza informazioni per fare le liste intorno agli oggetti che hai scelto casualmente,

b

$b$

ϵ

$\epsilon$

a \leq b

$a \leq b$

a \geq b

$a \geq b$

n / \log n

$n / \log n$

— Alex ten Brink

(continua) tieni presente che non devi nemmeno essere in grado di costruire esplicitamente l'elenco nei tempi previsti perché la prova sia valida.

— Alex ten Brink,

Non ho capito bene questa prova. La contraddizione finale è "algoritmo basato esclusivamente sui confronti", ma nei primi passi del nostro algoritmo abbiamo aggiunto

a ciascun elemento (inoltre, "dove

è inferiore alla differenza tra due elementi nell'elenco"). Perché siamo ancora giustificati che il nostro algoritmo sia ancora basato sul confronto solo se assumiamo che i nostri articoli abbiano un ordine totale non discreto su di essi?

ϵ

$\epsilon$

ϵ

$\epsilon$

— Artem Kaznatcheev

@Artem: Il vostro contributo originale è costituito da elementi

. Quindi costruisci un nuovo set

; rappresenti una

originale come

e una

modificata come

. Ora usi l'algoritmo black box; l'algoritmo confronta gli elementi di

x \in X

$x \in X$

X^{'} = X \times {0, 1}

$X' = X \times \{0,1\}$

x \in X

$x \in X$

(x, 0) \in X^{'}

$(x,0) \in X'$

x + ϵ

$x + \epsilon$

(x, 1) \in X^{'}

$(x,1) \in X'$

X^{'}

$X'$ l'un l'altro; per rispondere a tali domande, devi solo confrontare un numero costante di elementi di

tra loro. Quindi tutto dovrebbe essere fattibile nel modello di confronto, con un sovraccarico costante.

X

$X$

— Jukka Suomela,

@Aryabhata: lo fa. Cos'è l' algoritmo

O (\log^{2} n)

$O(\log^2 n)$

— Peter Shor,

Credo che qui sia una prova diversa, che dimostra l'impossibilità di una struttura temporale della query , con pre-elaborazione . $\mathcal{O}(\log ^k n)$ $\mathcal{O}(n)$

Supponiamo che nella pre-elaborazione tu faccia confronti, portando a un ordine parziale. $\mathcal{O}(n)$

Consideriamo ora la dimensione dell'antichain più grande in questo. Poiché questi elementi non sono comparabili, per noi avere un algoritmo di query , dobbiamo avere . $A$ $\mathcal{O}(\log ^k n)$ $A = \mathcal{O}(\log ^k n)$

Ora secondo il teorema di Dilworth, c'è una divisione della dimensione , in catene. $A$

Ora possiamo integrare l'algoritmo per determinare le catene nella partizione. Possiamo determinare se due elementi sono comparabili creando un grafico diretto di confronti e facendo un'analisi di raggiungibilità. Questo può essere fatto senza ulteriori confronti. Ora basta forzare ogni possibile partizione della dimensione per determinare se si tratta di una partizione di catene. $A$

Una volta che abbiamo le catene, possiamo unirle per dare un algoritmo di confronto per ordinare l'intero elenco. $\mathcal{O}(n \log \log n)$

— Aryabhata
fonte

Questa è una bella idea E se potessi mostrare che la partizione a catena deve essere nota all'algoritmo, allora potresti usare mergesort per mostrare che ci vorrebbe solo un ulteriore confronto O (n log log n) per ordinare l'intero input, piuttosto che usare Jensen. Ma c'è un problema: perché l'algoritmo di preelaborazione deve costruire una partizione a catena? Deve esistere una partizione a catena, sì, ma è molto diversa dalla sua conoscenza dell'algoritmo.

— David Eppstein,

Ok, ora credo a questa prova. E mostra più fortemente che per ottenere il tempo di interrogazione del polilogo è necessario utilizzare una serie di confronti all'interno di un additivo

dell'ordinamento. Bello. A proposito, la partizione a catena può essere trovata in tempo polinomiale dall'insieme di confronti già eseguiti, piuttosto che richiedere una ricerca della forza bruta, ma questo non fa alcuna differenza per il tuo argomento.

O (n \log \log n)

$O(n\log\log n)$

— David Eppstein,

Le prove dimostrano che è necessario disporre di preelaborazione

per ogni query. Naturalmente entrambi sono stretti. Ciò dimostra che la ricerca binaria e la ricerca lineare sono gli unici algoritmi di ricerca "interessanti" (almeno nel mondo classico).

Ω (n \log n)

$\Omega(n\log n)$

Ω (n)

$\Omega(n)$

— Yuval Filmus,

@Yuval: forse dovresti scrivere questa osservazione come una risposta effettiva, perché mi sembra che devi fare una moderata quantità di lavoro per ottenere il risultato di cui sopra dalle prove nelle risposte.

— Peter Shor,

@Yuval: pensando alle prove, vedo solo che devi avere

preelaborazione o

tempo di interrogazione per tutti

. E 'possibile avere

il tempo pre-elaborazione e

tempo di risposta. Si può dividere l'elenco in

elenchi di dimensioni

ciascuno nel tempo

Ω (n \log n)

$\Omega(n \log n)$

Ω (n^{1 - ϵ})

$\Omega(n^{1-\epsilon})$

ϵ

$\epsilon$

o (n \log n)

$o(n \log n)$

O (n / \log n)

$O(n / \log n)$

\log n

$\log n$

n / \log n

$n/\log n$

utilizzando ripetute rilevazioni mediane.

θ (n \log \log n)

$\theta(n \log\log n)$

— Peter Shor,

Come osserva la risposta di Peter Shor, per escludere l'appartenenza a un modello basato sul confronto, dobbiamo sapere come l'elemento si confronta con ogni membro. Quindi, usando query casuali (il numero di membri inferiore al non membro interrogato è casuale), otteniamo informazioni relative ad avere valori non ordinati. Pertanto, per alcune costanti , usando $k<n$ $Θ(n \log k)$ $n$ $c>0$ preprocesssing, non possiamo avere $c \, n \log k$ costo query. Questo è ottimale fino a un fattore costante poiché possiamo ordinare i dati in bucket approssimativamente uguali (ogni bucket non ordinato) in tempo, che consente ilcosto della query . $≤c \, n \log k/k$ $k' = k / \log k ≤ n/\log n$ $O(n \log k') = O(n \log k)$ $O(n/k')$

In particolare, utilizzando la pre elaborazione , non è possibile avere un costo di query . Inoltre, la preelaborazione di corrisponde a in per ogni costo di query e quindi . $O(n)$ $o(n)$ $o(n \log n)$ $k$ $O(n^ε)$ $ε>0$ $Ω(n^{1−ε})$

— Dmytro Taranovsky
fonte