Risolvere la relazione di ricorrenza con due chiamate ricorsive


10

Sto studiando il caso peggiore di quicksort a condizione che non farà mai una partizione molto sbilanciata per le diverse definizioni di molto .

Per fare questo mi chiedo quale sarebbe il runtime nel caso in cui Quicksort capiti sempre di partizionare in una frazione tale che elementi sono nella partizione sinistra e sono nella partizione destra (lasciando elemento, il perno, al centro).T(n,p)0<p≤12⌊p(n−1)⌋⌈(1−p)(n−1)⌉1

Non dovrebbe essere difficile vedere che fornisce un limite superiore per il caso peggiore in cui è la partizione consentita massimamente sbilanciata, poiché qualsiasi partizione con frazione sarà più bilanciata e avrà un tempo di esecuzione minore, e qualsiasi frazione non è consentita.T(n,p)p>p<p

È ovvio che è il caso migliore e è il caso peggiore di quicksort. Entrambi hanno facili relazioni di ricorrenza che si trovano in qualsiasi risorsa educativa. Ma non ho idea di come studiare in generale. La relazione ovvia sarebbe:T(n,12)T(n,0)T(n,p)

T(n,p)=n+T(⌊p(n−1)⌋,p)+T(⌈(1−p)(n−1)⌉,p)

Qui mi blocco. Ho provato a cercare in giro, ma tutta la letteratura che ho capito sugli algoritmi di divisione e conquista ha preso letteralmente il "divario" e ha "ingannato" l'analisi usando il fatto che le partizioni hanno sempre le stesse dimensioni, unendo i termini in una volta costante.

Non so come gestire due chiamate ricorsive e non so se sia sicuro rimuovere l'arrotondamento. È possibile risolvere analiticamente e, se sì, come?

PS: Non mi interessano gli asintotici (che è facile mostrare per qualsiasi costante ). Sono interessato a quanto lo slowsort più lento diventa man mano che si riduce , ad esempio mi interessa il rapporto .p p T ( n , 0,25 )Θ(nlog⁡n)ppT(n,0.25)T(n,0.5)

PPS: Come studente universitario, mi scuso se ho fatto cose ovvie troppo lunghe o non spiegate non banali. E anche se non so se sia guardato in basso qui tanto quanto gli altri siti SE, noterò che questo è un interesse personale, non compiti a casa.

Risposte:


9

Come dici tu, il teorema di Akra – Bazzi mostra che la soluzione alla ricorrenza è per tutti i . Tuttavia, ciò non rivela la natura della dipendenza da . Per determinare quest'ultimo, possiamo usare un approccio ad albero di ricorsione.O ( n log n ) p ∈ ( 0 , 1 ) pT(n,p)O(nlog⁡n)p∈(0,1)p

Alla radice dell'albero di ricorsione si trova l'intervallo . I suoi due figli sono gli intervalli e , la cui lunghezza totale è di nuovo . Ognuno di questi nodi ha due figli (supponendo che sia abbastanza grande) e così via. Per semplicità ignoriamo gli errori di arrotondamento, ovvero supponiamo che sia un numero intero; questo è solo un tecnicismo e non me ne preoccuperei. Interrompiamo il processo ogni volta che un nodo ha una lunghezza al massimo . La complessità dell'algoritmo è proporzionale alla lunghezza totale degli intervalli nella struttura. Quando , le foglie{ 1 , ... , p n } { p n + 1 , ... , n } n n p n 1 p ≠ 1 / 2{1,…n}{1,…,pn}{pn+1,…,n}nnpn1p≠1/2 (nodi in cui interrompiamo il processo) hanno profondità diverse e ciò rende più difficile determinare la complessità complessiva.

Possiamo ottenere un semplice limite superiore notando che l'albero ha al massimo livelli : ogni nodo è almeno un fattore più piccolo del suo genitore. Proprio come nell'analisi per , la lunghezza totale degli intervalli a qualsiasi livello è al massimo , e otteniamo un limite superiore di sul tempo di esecuzione. Poiché e per piccola , possiamo scrivere questo come .1 - p p = 1 / 2 n O ( n log 1 - p ( 1 / n ) ) log 1 - p ( 1 / n ) = log n / log ( 1 - p ) - 1 registro ( 1 - p ) - 1log1−p⁡(1/n)1−pp=1/2nO(nlog1−p⁡(1/n))log1−p⁡(1/n)=log⁡n/log⁡(1−p)−1p O ( n log n / p )log⁡(1−p)−1=−log⁡(1−p)=p±O(p2)pO(nlog⁡n/p)

Ecco un calcolo più accurato. Considera il livello . Supponiamo di non interrompere il processo al raggiungimento di un piccolo intervallo. Possiamo generare un vertice casuale prendendo passi, in ognuno dei quali andiamo a sinistra (diciamo) con probabilità e a destra (diciamo) con probabilità . Ogni volta che facciamo un passo a sinistra il registro della lunghezza dell'intervallo diminuisce di , e ogni volta che facciamo un passo a destra diminuisce di . Un vertice si trova nell'albero reale del registro della lunghezza diminuita al massimo . Il peso totale degli intervalli al livellotp 1 - p - log p - log ( 1 - p ) log n t log n D - log p p - log ( 1 - p ) 1 - p X 1 , … , X t ∼ D t Pr [ X 1 + ⋯ + X t ≤ log n ] ttp1−p−log⁡p−log⁡(1−p)log⁡ntdell'albero è esattamente la probabilità che un vertice generato secondo questo processo corrisponda ad una diminuzione al massimo . Cioè, se è la distribuzione che è uguale a con probabilità e a con probabilità e sono indipendenti, quindi il il peso totale del livello è . Per super costante , la variabile casuale è approssimativamente normalmente distribuita con media varianza lineare inlog⁡nD−log⁡pp−log⁡(1−p)1−pX1,…,Xt∼DtPr[X1+⋯+Xt≤log⁡n]t [ - p log p - ( 1 - p ) log ( 1 - p ) ] t t t [ - p log p - ( 1 - p ) log ( 1 - p ) ] t ≤ ( log n ) / 2 1 t [ - p logX1+⋯+Xt[−plog⁡p−(1−p)log⁡(1−p)]tt, quindi per soddisfacente , diciamo, la probabilità sarà molto vicina a , mentre per soddisfacente , diciamo, sarà molto vicino allo zero. Definendo (nota come funzione di entropia binaria), concludiamo che il tempo di esecuzione è (uniforme in , come da ). Come abbiamo , e quindi la nostra stima precedente non era stretta.t[−plog⁡p−(1−p)log⁡(1−p)]t≤(log⁡n)/21th ( p ) = - p log p - ( 1 - p ) log ( 1 - p ) Θ ( n log n / h ( p ) ) p n → ∞ p → 0 h ([−plog⁡p−(1−p)log⁡(1−p)]t≥2log⁡nh(p)=−plog⁡p−(1−p)log⁡(1−p)Θ(nlog⁡n/h(p))pn→∞p→0h(p)≈−plog⁡p

Un altro modo di guardare la stessa analisi è avere una sequenza infinita di variabili casuali indipendenti come in precedenza e definire un tempo di arresto per essere la prima volta tale che . Il tempo di esecuzione è quindi proporzionale a . Il teorema di rinnovamento elementare afferma quindi che , sottintendendo che il la dimensione totale degli intervalli è uguale a . Più precisamente, per ogni costante la dimensione totale degli intervalli è , doveT t X 1 + ⋯ + X t ≥ log n n E [ T ] lim n → ∞ E [ T ] / log n = 1 / E [ D ] = 1 / h ( p ) ( 1 + o ( 1 ) ) n log nX1,X2,…TtX1+⋯+Xt≥log⁡nnE[T]limn→∞E[T]/log⁡n=1/E[D]=1/h(p)p ( 1 + α p ( n ) ) n log n / h ( p ) α p ( n ) = o ( n ) log n n α p ( n ) = O ( n - C p ) p ∈ ( δ , 1 - δ ) δ > 0(1+o(1))nlog⁡n/h(p)p(1+αp(n))nlog⁡n/h(p)αp(n)=o(n) . La convergenza nel teorema di rinnovo elementare è esponenziale nel parametro time - nel nostro caso - quindi dovrebbe essere polinomiale in , cioè . La convergenza è probabilmente anche uniforme per per qualsiasi .log⁡nnαp(n)=O(n−Cp)p∈(δ,1−δ)δ>0


Riassumendo, la lunghezza totale degli intervalli nell'albero di ricorsione, che è proporzionale al tempo di esecuzione, è della seguente forma per ogni : dove e vengono portati sulla stessa base e è una funzione che dipende da e tende a con .T ( n , p ) = ( 1 + o ( 1 ) ) n log nplognh(p)=-plogp-(1-p)log(1-p)o(1)p0n

T(n,p)=(1+o(1))nlog⁡nh(p),
log⁡nh(p)=−plog⁡p−(1−p)log⁡(1−p)o(1)p0n

Inoltre, è probabilmente vero che per qualsiasi e qualsiasi è vero che la lunghezza totale degli intervalli è della forma dove e la grande costante O nascosta dipendono solo da . In particolare, dovrebbe essere il caso che per tutte le costanti , e la convergenza è polinomialmente veloce.δ>0p∈(δ,1−δ)

T(n,p)=(1+O(n−Cδ))nlog⁡nh(p),
Cδ>0δp1,p2
limn→∞T(n,p1)T(n,p2)=h(p2)h(p1),

Grazie per la tua rapida risposta Yuval. Sono un po 'confuso dal fatto che tu abbia usato nel tuo riassunto. è una costante e ciò non significa che sia irrilevante in ? Ho deciso di scrivere un piccolo programma di test , che ha mostrato che per confrontando tra il metodo analitico e uno computazionale ha dato un errore di 0,03. Sembra piuttosto grande, o è prevedibile? Θh(p)Θn=100000000000000T(n,0.1)/T(n,0.5)
— orlp

La costante in è uniforme in . Più precisamente, per alcune costanti è il caso che per ogni esista tale che per , . Probabilmente puoi ottenere un'istruzione ancora più forte della forma per ogni fissa , dove la piccola o è rispetto a ( ma potrebbe dipendere da ); non dovrebbe dipendere da . Θpc,CpNpn≥Npcnlog⁡n/h(p)≤T(n,p)≤Cnlog⁡n/h(p)p n p C pT(n,p)=(1+o(1))Cnlog⁡n/h(p)pnpCp
— Yuval Filmus,

La convergenza al limite dipende da , quindi potrebbe essere necessario che sia grande per ottenere una buona approssimazione. D'altra parte, un errore relativo di 0,03 non sembra così grande. Puoi provare a correggere e tracciare il tempo di esecuzione in funzione di , confrontandolo con . log n n p 1 / h ( p )log⁡nlog⁡nnp1/h(p)
— Yuval Filmus,

Oh mi dispiace, non intendevo un errore relativo di 0,03, ma assoluto (2,13222 vs 2,10339). Tracciare in funzione di , rispetto a dato una differenza relativa del 4%, con essendo il 96% di . p 1 / h ( p ) T ( 10 11 , 0,05 ) ∗ h ( 0,05 ) T ( 10 11 , 0,4 ) ∗ h ( 0,4 )T(n,p)p1/h(p)T(1011,0.05)∗h(0.05)T(1011,0.4)∗h(0.4)
— orlp

1
La super-costante è una funzione che tende all'infinito rispetto alla variabile rilevante (in questo caso ). È lo stesso di . ω ( 1 )nω(1)
— Yuval Filmus,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.