Fusione di elenchi di oggetti fragili

Background: Chao Xu ha postato la seguente domanda qualche tempo fa: " Esistono algoritmi di ordinamento comparativo noti che non si riducono alle reti di ordinamento, in modo tale che ogni elemento venga confrontato volte? $O(\log n)$ ". Sembra che siamo un po 'bloccati dal problema; Ho discusso dello stesso problema con Valentin Polishchuk nel 2009 e non siamo riusciti da nessuna parte.

Per avere alcune idee originali, ho cercato di formulare la domanda più semplice possibile che avesse un sapore simile e non fosse del tutto banale. Da qui la seguente domanda.

Domanda: vengono forniti due elenchi ordinati, ciascuno con elementi. Riesci a unire gli elenchi in modo che ogni elemento venga confrontato solo volte? $n$ $O(1)$

Naturalmente, l'uscita dovrebbe essere un elenco ordinato che contiene tutti i elementi. $2n$

[Questo si è rivelato banale, la risposta è "no".]

Domanda 2: ti vengono dati due elenchi ordinati, ognuno con elementi. Puoi unire gli elenchi in modo che ogni elemento venga confrontato solo volte, se ti è permesso di scartare una piccola frazione di elementi ? $n$ $O(1)$

Più precisamente, l'output dovrebbe essere un elenco ordinato che contiene e un "cestino" che contiene elementi . Quanto è piccolo il valore ? Ottenere è banale. Qualcosa come dovrebbe essere fattibile in modo semplice. Ma puoi ottenere $2n-T(n)$ $T(n)$ $T(n)$ $T(n) = n$ $T(n) = n/100$ ? $T(n) = o(n)$

Appunti:

Usiamo il modello di confronto qui. Solo algoritmi deterministici, siamo interessati alle garanzie nel caso peggiore.
Nota che entrambi gli elenchi hanno esattamente elementi. Se avessimo una lista con elementi e un'altra con elemento, la risposta è chiaramente "no"; tuttavia, se entrambi gli elenchi sono lunghi, sembra che si possa essere in grado di eseguire un "bilanciamento del carico". $n$ $n$ $1$
Questa volta è valido qualsiasi tipo di algoritmo. Se il tuo algoritmo utilizza le reti di ordinamento come blocco predefinito, va perfettamente bene.
Per iniziare, ecco un semplice algoritmo che confronta ogni elemento per un massimo di 200 volte: basta usare l'algoritmo di unione standard, ma mantenere i contatori per i capi delle liste. Una volta raggiunti 200, scarta l'elemento. Ora per ogni elemento che hai scartato, hai inserito correttamente 200 elementi nel tuo array di output. Quindi hai raggiunto . $T(n) = n/100$

ds.algorithms sorting sorting-network

— Jukka Suomela
fonte

Hai detto che "Se avessimo una lista con n elementi e un'altra con 1 elemento, la risposta è chiaramente no". Il caso con n elementi in ciascuna lista non è un problema più generale? Ad esempio, se ci viene promesso che tutti gli elementi nel secondo elenco tranne il primo elemento sono molto più grandi di tutti gli elementi nel primo elenco, ciò non si riduce al primo problema?

— Robin Kothari,

@Robin: Giusto, quindi non sono riuscito a formulare una domanda non banale, grazie. La tua osservazione sembra dare un limite inferiore di

se insistiamo sul fatto che tutti gli elementi vengano ordinati. Consentitemi di aumentare leggermente la domanda ...

Ω (\log n)

$\Omega(\log n)$

— Jukka Suomela,

E nel caso qualcuno si chieda qual è il punto della definizione apparentemente strana nella domanda 2: se possiamo rendere

molto piccolo, forse potremmo usare qualcosa come unire l'ordinamento per quasi risolvere il problema originale e preoccuparci di una piccola frazione di elementi nel cestino più tardi.

T (n)

$T(n)$

— Jukka Suomela,

No, un tale algoritmo non può esistere.

Assumere confronti per elemento sono ammessi. $t$

$2^t$ $2^t+1$ $t+1$

$n$ $n/2^t$ $n/2^t$

$t$ $o(n)$

In una nota a margine, sembra che sia possibile abbinare questo limite da un algoritmo in cui ogni elemento viene confrontato con un registro approssimativo delle dimensioni della parte circostante dell'altro elenco. Se questo è interessante, proverò a elaborare i dettagli.

— Riko Jacob
fonte